[vm/ffi] Support multi-dimensional inline arrays

This CL only changes dart:ffi API, CFE, and analyzer. No VM changes
were needed because the dimensions of inline arrays can be flattened
before passing them to the VM. The multi-dimensionality does not
impact the ABI.

Closes: #45023

TEST=pkg/analyzer/test/src/diagnostics/size_annotation_dimensions_test.dart
TEST=pkg/front_end/testcases/nnbd/ffi_struct_inline_array_multi_dimensional.dart
TEST=tests/ffi/function_structs_by_value_generated_test.dart
TEST=tests/ffi/inline_array_multi_dimensional_test.dart

Change-Id: Ica2c01fccbea7e513879365b34086d8968b54c5b
Cq-Include-Trybots: luci.dart.try:dart-sdk-linux-try,dart-sdk-mac-try,dart-sdk-win-try,vm-ffi-android-debug-arm-try,vm-ffi-android-debug-arm64-try,vm-kernel-asan-linux-release-x64-try,vm-kernel-mac-debug-x64-try,vm-kernel-linux-debug-ia32-try,vm-kernel-linux-debug-x64-try,vm-kernel-nnbd-linux-debug-x64-try,vm-kernel-nnbd-linux-debug-ia32-try,vm-kernel-nnbd-mac-release-x64-try,vm-kernel-nnbd-win-debug-x64-try,vm-kernel-precomp-linux-debug-x64-try,vm-kernel-precomp-linux-debug-simarm_x64-try,vm-kernel-precomp-nnbd-linux-debug-x64-try,vm-kernel-precomp-win-release-x64-try,vm-kernel-reload-linux-debug-x64-try,vm-kernel-reload-rollback-linux-debug-x64-try,vm-kernel-win-debug-x64-try,vm-kernel-win-debug-ia32-try,vm-precomp-ffi-qemu-linux-release-arm-try,vm-kernel-precomp-obfuscate-linux-release-x64-try,vm-kernel-msan-linux-release-x64-try,vm-kernel-precomp-msan-linux-release-x64-try,vm-kernel-precomp-android-release-arm_x64-try,analyzer-analysis-server-linux-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/188286
Commit-Queue: Daco Harkes <[email protected]>
Reviewed-by: Aske Simon Christensen <[email protected]>

Author: dcharkes

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -3925,6 +3925,32 @@ Message _withArgumentsFfiSizeAnnotation(String name) {
       arguments: {'name': name});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateFfiSizeAnnotationDimensions = const Template<
+        Message Function(String name)>(
+    messageTemplate:
+        r"""Field '#name' must have an 'Array' annotation that matches the dimensions.""",
+    withArguments: _withArgumentsFfiSizeAnnotationDimensions);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)> codeFfiSizeAnnotationDimensions =
+    const Code<Message Function(String name)>(
+  "FfiSizeAnnotationDimensions",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsFfiSizeAnnotationDimensions(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeFfiSizeAnnotationDimensions,
+      message:
+          """Field '${name}' must have an 'Array' annotation that matches the dimensions.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String name)> templateFfiStructGeneric =
     const Template<Message Function(String name)>(

pkg/analyzer/lib/error/error.dart

@@ -476,6 +476,7 @@ const List<ErrorCode> errorCodeValues = [
   FfiCode.NON_CONSTANT_TYPE_ARGUMENT,
   FfiCode.NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER,
   FfiCode.NON_SIZED_TYPE_ARGUMENT,
+  FfiCode.SIZE_ANNOTATION_DIMENSIONS,
   FfiCode.SUBTYPE_OF_FFI_CLASS_IN_EXTENDS,
   FfiCode.SUBTYPE_OF_FFI_CLASS_IN_IMPLEMENTS,
   FfiCode.SUBTYPE_OF_FFI_CLASS_IN_WITH,

pkg/analyzer/lib/src/dart/error/ffi_code.dart

@@ -206,6 +206,15 @@ class FfiCode extends AnalyzerErrorCode {
       correction: "Try using a native integer, 'Float', 'Double', 'Pointer', "
           "or subtype of 'Struct'.");
 
+  /**
+   * No parameters.
+   */
+  static const FfiCode SIZE_ANNOTATION_DIMENSIONS = FfiCode(
+      name: 'SIZE_ANNOTATION_DIMENSIONS',
+      message:
+          "'Array's must have an 'Array' annotation that matches the dimensions.",
+      correction: "Try adjusting the arguments in the 'Array' annotation.");
+
   /**
    * Parameters:
    * 0: the name of the subclass

pkg/analyzer/lib/src/generated/ffi_verifier.dart

@@ -18,7 +18,7 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
   static const _allocatorClassName = 'Allocator';
   static const _allocateExtensionMethodName = 'call';
   static const _allocatorExtensionName = 'AllocatorAlloc';
-  static const _cArrayClassName = 'Array';
+  static const _arrayClassName = 'Array';
   static const _dartFfiLibraryName = 'dart.ffi';
   static const _opaqueClassName = 'Opaque';
 
@@ -248,6 +248,9 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     if (nativeType.isPointer) {
       return true;
     }
+    if (nativeType.isArray) {
+      return true;
+    }
     return false;
   }
 
@@ -554,9 +557,10 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
         final typeArg = (declaredType as InterfaceType).typeArguments.single;
         if (!_isSized(typeArg)) {
           _errorReporter.reportErrorForNode(FfiCode.NON_SIZED_TYPE_ARGUMENT,
-              fieldType, [_cArrayClassName, typeArg.toString()]);
+              fieldType, [_arrayClassName, typeArg.toString()]);
         }
-        _validateSizeOfAnnotation(fieldType, annotations);
+        final arrayDimensions = declaredType.arrayDimensions;
+        _validateSizeOfAnnotation(fieldType, annotations, arrayDimensions);
       } else if (declaredType.isStructSubtype) {
         final clazz = (declaredType as InterfaceType).element;
         if (clazz.isEmptyStruct) {
@@ -708,8 +712,8 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
   /// Validate that the [annotations] include exactly one size annotation. If
   /// an error is produced that cannot be associated with an annotation,
   /// associate it with the [errorNode].
-  void _validateSizeOfAnnotation(
-      AstNode errorNode, NodeList<Annotation> annotations) {
+  void _validateSizeOfAnnotation(AstNode errorNode,
+      NodeList<Annotation> annotations, int arrayDimensions) {
     final ffiSizeAnnotations = annotations.where((annotation) {
       final element = annotation.element;
       return element is ConstructorElement &&
@@ -720,14 +724,34 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     if (ffiSizeAnnotations.isEmpty) {
       _errorReporter.reportErrorForNode(
           FfiCode.MISSING_SIZE_ANNOTATION_CARRAY, errorNode);
+      return;
     }
+
     if (ffiSizeAnnotations.length > 1) {
       final extraAnnotations = ffiSizeAnnotations.skip(1);
       for (final annotation in extraAnnotations) {
         _errorReporter.reportErrorForNode(
             FfiCode.EXTRA_SIZE_ANNOTATION_CARRAY, annotation);
       }
     }
+
+    // Check number of dimensions.
+    final annotation = ffiSizeAnnotations.first;
+    final expressions = annotation.arguments!.arguments;
+    int annotationDimensions = 0;
+    for (var expression in expressions) {
+      if (expression is IntegerLiteral) {
+        // Element of `@Array(1, 2, 3)`.
+        annotationDimensions++;
+      } else if (expression is ListLiteral) {
+        // Element of `@Array.multi([1, 2, 3])`.
+        annotationDimensions += expression.elements.length;
+      }
+    }
+    if (annotationDimensions != arrayDimensions) {
+      _errorReporter.reportErrorForNode(
+          FfiCode.SIZE_ANNOTATION_DIMENSIONS, annotation);
+    }
   }
 
   /// Validate that the given [typeArgument] has a constant value. Return `true`
@@ -845,11 +869,23 @@ extension on DartType {
     final self = this;
     if (self is InterfaceType) {
       final element = self.element;
-      return element.name == FfiVerifier._cArrayClassName && element.isFfiClass;
+      return element.name == FfiVerifier._arrayClassName && element.isFfiClass;
     }
     return false;
   }
 
+  int get arrayDimensions {
+    DartType iterator = this;
+    int dimensions = 0;
+    while (iterator is InterfaceType &&
+        iterator.element.name == FfiVerifier._arrayClassName &&
+        iterator.element.isFfiClass) {
+      dimensions++;
+      iterator = iterator.typeArguments.single;
+    }
+    return dimensions;
+  }
+
   bool get isPointer {
     final self = this;
     return self is InterfaceType && self.element.isPointer;

pkg/analyzer/lib/src/test_utilities/mock_sdk.dart

@@ -691,7 +691,10 @@ class DartRepresentationOf {
 }
 
 class Array<T extends NativeType> extends NativeType {
-  external const factory Array(int dimension1);
+  external const factory Array(int dimension1,
+      [int dimension2, int dimension3, int dimension4, int dimension5]);
+
+  external const factory Array.multi(List<int> dimensions);
 }
 
 extension StructPointer<T extends Struct> on Pointer<T> {

pkg/analyzer/test/src/diagnostics/non_sized_type_argument_test.dart

@@ -32,10 +32,10 @@ import 'dart:ffi';
 
 class C extends Struct {
   @Array(8)
-  Array<Array<Uint8>> a0;
+  Array<Void> a0;
 }
 ''', [
-      error(FfiCode.NON_SIZED_TYPE_ARGUMENT, 59, 19),
+      error(FfiCode.NON_SIZED_TYPE_ARGUMENT, 59, 11),
     ]);
   }
 }

pkg/analyzer/test/src/diagnostics/size_annotation_dimensions_test.dart

@@ -0,0 +1,67 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/src/dart/error/ffi_code.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SizeAnnotationDimensions);
+  });
+}
+
+@reflectiveTest
+class SizeAnnotationDimensions extends PubPackageResolutionTest {
+  test_error_array_2_3() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8, 8)
+  Array<Array<Array<Uint8>>> a0;
+}
+''', [
+      error(FfiCode.SIZE_ANNOTATION_DIMENSIONS, 47, 12),
+    ]);
+  }
+
+  test_error_array_3_2() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8, 8, 8)
+  Array<Array<Uint8>> a0;
+}
+''', [
+      error(FfiCode.SIZE_ANNOTATION_DIMENSIONS, 47, 15),
+    ]);
+  }
+
+  test_error_multi_2_3() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array.multi([8, 8])
+  Array<Array<Array<Uint8>>> a0;
+}
+''', [
+      error(FfiCode.SIZE_ANNOTATION_DIMENSIONS, 47, 20),
+    ]);
+  }
+
+  test_no_error() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8, 8)
+  Array<Array<Uint8>> a0;
+}
+''');
+  }
+}

pkg/analyzer/test/src/diagnostics/test_all.dart

@@ -571,6 +571,7 @@ import 'set_element_from_deferred_library_test.dart'
 import 'set_element_type_not_assignable_test.dart'
     as set_element_type_not_assignable;
 import 'shared_deferred_prefix_test.dart' as shared_deferred_prefix;
+import 'size_annotation_dimensions_test.dart' as size_annotation_dimensions;
 import 'spread_expression_from_deferred_library_test.dart'
     as spread_expression_from_deferred_library;
 import 'static_access_to_instance_member_test.dart'
@@ -1044,6 +1045,7 @@ main() {
     sdk_version_ui_as_code_in_const_context.main();
     set_element_type_not_assignable.main();
     shared_deferred_prefix.main();
+    size_annotation_dimensions.main();
     spread_expression_from_deferred_library.main();
     static_access_to_instance_member.main();
     strict_raw_type.main();

pkg/front_end/lib/src/api_unstable/vm.dart

@@ -65,6 +65,7 @@ export '../fasta/fasta_codes.dart'
         templateFfiFieldNull,
         templateFfiNotStatic,
         templateFfiSizeAnnotation,
+        templateFfiSizeAnnotationDimensions,
         templateFfiStructGeneric,
         templateFfiTypeInvalid,
         templateFfiTypeMismatch;

pkg/front_end/messages.status

@@ -330,6 +330,7 @@ FfiFieldNoAnnotation/analyzerCode: Fail
 FfiFieldNull/analyzerCode: Fail
 FfiNotStatic/analyzerCode: Fail
 FfiSizeAnnotation/analyzerCode: Fail
+FfiSizeAnnotationDimensions/analyzerCode: Fail
 FfiStructAnnotation/analyzerCode: Fail
 FfiStructGeneric/analyzerCode: Fail
 FfiTypeInvalid/analyzerCode: Fail

pkg/front_end/messages.yaml

@@ -4272,6 +4272,11 @@ FfiSizeAnnotation:
   template: "Field '#name' must have exactly one 'Array' annotation."
   external: test/ffi_test.dart
 
+FfiSizeAnnotationDimensions:
+  # Used by dart:ffi
+  template: "Field '#name' must have an 'Array' annotation that matches the dimensions."
+  external: test/ffi_test.dart
+
 FfiStructGeneric:
   # Used by dart:ffi
   template: "Struct '#name' should not be generic."

pkg/front_end/test/spell_checking_list_common.txt

@@ -857,6 +857,9 @@ dig
 digit
 digits
 dill
+dimension
+dimensional
+dimensions
 dir
 direct
 direction

pkg/front_end/test/spell_checking_list_tests.txt

@@ -99,6 +99,7 @@ c's
 c59cdee365b94ce066344840f9e3412d642019b
 ca
 cafebabe
+calloc
 camel
 capitalized
 causal

pkg/front_end/testcases/nnbd/ffi_struct_inline_array.dart.strong.expect

@@ -9,19 +9,20 @@ class StructInlineArray extends ffi::Struct {
   synthetic constructor •() → self::StructInlineArray
     : super ffi::Struct::•()
     ;
-  @#C2
+  @#C3
   external get a0() → ffi::Array<ffi::Uint8>;
-  @#C2
+  @#C3
   external set a0(ffi::Array<ffi::Uint8> #externalFieldValue) → void;
 }
 static method main() → dynamic {}
 
 constants  {
   #C1 = 8
-  #C2 = ffi::_ArraySize<ffi::NativeType> {dimension1:#C1}
+  #C2 = null
+  #C3 = ffi::_ArraySize<ffi::NativeType> {dimension1:#C1, dimension2:#C2, dimension3:#C2, dimension4:#C2, dimension5:#C2, dimensions:#C2}
 }
 
 
 Constructor coverage from constants:
 org-dartlang-testcase:///ffi_struct_inline_array.dart:
-- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:133:9)
+- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:156:9)

pkg/front_end/testcases/nnbd/ffi_struct_inline_array.dart.strong.transformed.expect

@@ -23,7 +23,7 @@ class StructInlineArray extends ffi::Struct {
     return new ffi::Array::_<ffi::Array<ffi::Uint8>>( block {
       core::Object #typedDataBase = this.{ffi::Struct::_addressOf};
       core::int #offset = (#C14).{core::List::[]}(ffi::_abi());
-    } =>#typedDataBase is ffi::Pointer<dynamic> ?{core::Object} ffi::_fromAddress<ffi::Uint8>(#typedDataBase.{ffi::Pointer::address}.{core::num::+}(#offset)) : let typ::TypedData #typedData = _in::unsafeCast<typ::TypedData>(#typedDataBase) in #typedData.{typ::TypedData::buffer}.{typ::ByteBuffer::asUint8List}(#typedData.{typ::TypedData::offsetInBytes}.{core::num::+}(#offset), (#C8).{core::List::[]}(ffi::_abi())), #C3);
+    } =>#typedDataBase is ffi::Pointer<dynamic> ?{core::Object} ffi::_fromAddress<ffi::Uint8>(#typedDataBase.{ffi::Pointer::address}.{core::num::+}(#offset)) : let typ::TypedData #typedData = _in::unsafeCast<typ::TypedData>(#typedDataBase) in #typedData.{typ::TypedData::buffer}.{typ::ByteBuffer::asUint8List}(#typedData.{typ::TypedData::offsetInBytes}.{core::num::+}(#offset), (#C8).{core::List::[]}(ffi::_abi())), #C3, #C15);
   @#C12
   set a0(ffi::Array<ffi::Uint8> #externalFieldValue) → void
     return ffi::_memCopy(this.{ffi::Struct::_addressOf}, (#C14).{core::List::[]}(ffi::_abi()), #externalFieldValue.{ffi::Array::_typedDataBase}, #C13, (#C8).{core::List::[]}(ffi::_abi()));
@@ -42,12 +42,13 @@ constants  {
   #C9 = "vm:entry-point"
   #C10 = null
   #C11 = core::pragma {name:#C9, options:#C10}
-  #C12 = ffi::_ArraySize<ffi::NativeType> {dimension1:#C3}
+  #C12 = ffi::_ArraySize<ffi::NativeType> {dimension1:#C3, dimension2:#C10, dimension3:#C10, dimension4:#C10, dimension5:#C10, dimensions:#C10}
   #C13 = 0
   #C14 = <core::int*>[#C13, #C13, #C13]
+  #C15 = <core::int*>[]
 }
 
 
 Constructor coverage from constants:
 org-dartlang-testcase:///ffi_struct_inline_array.dart:
-- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:133:9)
+- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:156:9)

pkg/front_end/testcases/nnbd/ffi_struct_inline_array.dart.weak.expect

@@ -9,19 +9,20 @@ class StructInlineArray extends ffi::Struct {
   synthetic constructor •() → self::StructInlineArray
     : super ffi::Struct::•()
     ;
-  @#C2
+  @#C3
   external get a0() → ffi::Array<ffi::Uint8>;
-  @#C2
+  @#C3
   external set a0(ffi::Array<ffi::Uint8> #externalFieldValue) → void;
 }
 static method main() → dynamic {}
 
 constants  {
   #C1 = 8
-  #C2 = ffi::_ArraySize<ffi::NativeType*> {dimension1:#C1}
+  #C2 = null
+  #C3 = ffi::_ArraySize<ffi::NativeType*> {dimension1:#C1, dimension2:#C2, dimension3:#C2, dimension4:#C2, dimension5:#C2, dimensions:#C2}
 }
 
 
 Constructor coverage from constants:
 org-dartlang-testcase:///ffi_struct_inline_array.dart:
-- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:133:9)
+- _ArraySize. (from org-dartlang-sdk:///sdk/lib/_internal/vm/lib/ffi_patch.dart:156:9)

pkg/front_end/testcases/nnbd/ffi_struct_inline_array.dart.weak.outline.expect

@@ -18,6 +18,6 @@ static method main() → dynamic
 
 
 Extra constant evaluation status:
-Evaluated: ConstructorInvocation @ org-dartlang-testcase:///ffi_struct_inline_array.dart:10:4 -> InstanceConstant(const _ArraySize<NativeType*>{_ArraySize.dimension1: 8})
-Evaluated: ConstructorInvocation @ org-dartlang-testcase:///ffi_struct_inline_array.dart:10:4 -> InstanceConstant(const _ArraySize<NativeType*>{_ArraySize.dimension1: 8})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///ffi_struct_inline_array.dart:10:4 -> InstanceConstant(const _ArraySize<NativeType*>{_ArraySize.dimension1: 8, _ArraySize.dimension2: null, _ArraySize.dimension3: null, _ArraySize.dimension4: null, _ArraySize.dimension5: null, _ArraySize.dimensions: null})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///ffi_struct_inline_array.dart:10:4 -> InstanceConstant(const _ArraySize<NativeType*>{_ArraySize.dimension1: 8, _ArraySize.dimension2: null, _ArraySize.dimension3: null, _ArraySize.dimension4: null, _ArraySize.dimension5: null, _ArraySize.dimensions: null})
 Extra constant evaluation: evaluated: 2, effectively constant: 2