[vm/ffi] Allow configuring the variable dimension of variable-length arrays

TEST=tests/ffi/*

CoreLibraryReviewExempt: VM only
Closes: #52366
Change-Id: I545a323f48d955b591cedf2dae7106d9004242e2
Cq-Include-Trybots: dart/try:vm-aot-android-release-arm64c-try,vm-aot-android-release-arm_x64-try,vm-aot-asan-linux-release-x64-try,vm-aot-linux-debug-x64-try,vm-aot-linux-debug-x64c-try,vm-aot-mac-release-arm64-try,vm-aot-mac-release-x64-try,vm-aot-msan-linux-release-x64-try,vm-aot-obfuscate-linux-release-x64-try,vm-aot-optimization-level-linux-release-x64-try,vm-aot-tsan-linux-release-x64-try,vm-aot-ubsan-linux-release-x64-try,vm-aot-win-debug-arm64-try,vm-aot-win-debug-x64-try,vm-aot-win-debug-x64c-try,vm-appjit-linux-debug-x64-try,vm-asan-linux-release-arm64-try,vm-asan-linux-release-x64-try,vm-checked-mac-release-arm64-try,vm-ffi-android-debug-arm-try,vm-ffi-android-debug-arm64c-try,vm-ffi-qemu-linux-release-arm-try,vm-ffi-qemu-linux-release-riscv64-try,vm-fuchsia-release-arm64-try,vm-fuchsia-release-x64-try,vm-linux-debug-ia32-try,vm-linux-debug-x64-try,vm-linux-debug-x64c-try,vm-mac-debug-arm64-try,vm-mac-debug-x64-try,vm-msan-linux-release-arm64-try,vm-msan-linux-release-x64-try,vm-reload-linux-debug-x64-try,vm-reload-rollback-linux-debug-x64-try,vm-tsan-linux-release-arm64-try,vm-tsan-linux-release-x64-try,vm-ubsan-linux-release-arm64-try,vm-ubsan-linux-release-x64-try,vm-win-debug-arm64-try,vm-win-debug-x64-try,vm-win-debug-x64c-try,vm-win-release-ia32-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/398621
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>
Reviewed-by: Daco Harkes <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: halildurmus

BUILD.gn

@@ -1,6 +1,6 @@
 # Copyright (c) 2016, 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.
+# BSD-style license that can be found in the LICENSE file.
 
 import("build/config/gclient_args.gni")
 import("sdk_args.gni")
@@ -258,6 +258,7 @@ if (is_fuchsia) {
     "tests/ffi/function_structs_by_value_generated_args_native_leaf_test.dart",
     "tests/ffi/function_structs_by_value_generated_args_native_test.dart",
     "tests/ffi/function_structs_by_value_generated_args_test.dart",
+    "tests/ffi/function_structs_by_value_generated_compounds_sizeof_test.dart",
     "tests/ffi/function_structs_by_value_generated_ret_arg_leaf_test.dart",
     "tests/ffi/function_structs_by_value_generated_ret_arg_native_leaf_test.dart",
     "tests/ffi/function_structs_by_value_generated_ret_arg_native_test.dart",

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

@@ -13365,6 +13365,17 @@ const MessageCode messageNativeClauseShouldBeAnnotation = const MessageCode(
       r"""Try removing this native clause and adding @native() or @native('native-name') before the declaration.""",
 );
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeNegativeVariableDimension =
+    messageNegativeVariableDimension;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageNegativeVariableDimension = const MessageCode(
+  "NegativeVariableDimension",
+  problemMessage:
+      r"""The variable dimension of a variable-length array must be non-negative.""",
+);
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeNeverReachableSwitchDefaultError =
     messageNeverReachableSwitchDefaultError;

pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml

@@ -1740,7 +1740,7 @@ FfiCode.FFI_NATIVE_MUST_BE_EXTERNAL:
   since: ~2.15
   notes: |-
     The fix is to add the `external` keyword.
-FfiCode.FFI_NATIVE_ONLY_CLASSES_EXTENDING_NATIVEFIELDWRAPPERCLASS1_CAN_BE_POINTER: 
+FfiCode.FFI_NATIVE_ONLY_CLASSES_EXTENDING_NATIVEFIELDWRAPPERCLASS1_CAN_BE_POINTER:
   status: noFix
   since: ~2.15
 FfiCode.FFI_NATIVE_UNEXPECTED_NUMBER_OF_PARAMETERS:
@@ -1790,6 +1790,8 @@ FfiCode.NATIVE_FIELD_MISSING_TYPE:
   status: needsEvaluation
 FfiCode.NATIVE_FIELD_NOT_STATIC:
   status: needsEvaluation
+FfiCode.NEGATIVE_VARIABLE_DIMENSION:
+  status: noFix
 FfiCode.NON_CONSTANT_TYPE_ARGUMENT:
   status: noFix
 FfiCode.NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER:

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

@@ -386,6 +386,13 @@ class FfiCode extends ErrorCode {
     hasPublishedDocs: true,
   );
 
+  ///  No parameters.
+  static const FfiCode NEGATIVE_VARIABLE_DIMENSION = FfiCode(
+    'NEGATIVE_VARIABLE_DIMENSION',
+    "The variable dimension of a variable-length array must be non-negative.",
+    correctionMessage: "Try using a value that is zero or greater.",
+  );
+
   ///  Parameters:
   ///  0: the name of the function, method, or constructor having type arguments
   static const FfiCode NON_CONSTANT_TYPE_ARGUMENT = FfiCode(

pkg/analyzer/lib/src/error/error_code_values.g.dart

@@ -631,6 +631,7 @@ const List<ErrorCode> errorCodeValues = [
   FfiCode.NATIVE_FIELD_INVALID_TYPE,
   FfiCode.NATIVE_FIELD_MISSING_TYPE,
   FfiCode.NATIVE_FIELD_NOT_STATIC,
+  FfiCode.NEGATIVE_VARIABLE_DIMENSION,
   FfiCode.NON_CONSTANT_TYPE_ARGUMENT,
   FfiCode.NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER,
   FfiCode.NON_POSITIVE_ARRAY_DIMENSION,

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

@@ -1991,28 +1991,54 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
       }
     }
 
-    // Check dimensions are positive.
-    List<AstNode>? getArgumentNodes() {
-      var arguments = annotation.arguments?.arguments;
-      if (arguments != null && arguments.length == 1) {
-        var firstArgument = arguments[0];
-        if (firstArgument is ListLiteral) {
-          return firstArgument.elements;
+    // Check dimensions are valid.
+    (List<AstNode>? dimensionsNodes, AstNode? variableDimensionNode)
+        getArgumentNodes() {
+      return switch (annotation.arguments) {
+        // `@Array.variableMulti([..], variableDimension: ..)`
+        ArgumentList(
+          arguments: [ListLiteral dimensions, NamedExpression variableDimension]
+        ) =>
+          (dimensions.elements, variableDimension.expression),
+        // `@Array.variableMulti([..])`
+        ArgumentList(arguments: [ListLiteral dimensions]) => (
+            dimensions.elements,
+            null
+          ),
+        // `@Array(..)`, `@Array.variable(..)`,
+        // `@Array.variableWithVariableDimension(..)`
+        ArgumentList(arguments: NodeList<AstNode> dimensions) => (
+            dimensions,
+            null
+          ),
+        _ => (null, null)
+      };
+    }
+
+    var (dimensionsNodes, variableDimensionNode) = getArgumentNodes();
+    AstNode errorNode = variableDimensionNode ?? annotation;
+
+    for (int i = 0; i < dimensions.length; i++) {
+      if (dimensionsNodes case var dimensionsNodes?) {
+        if (dimensionsNodes.length > i && variableDimensionNode == null) {
+          var node = dimensionsNodes[i];
+          errorNode = node is NamedExpression ? node.expression : node;
         }
       }
-      return arguments;
-    }
 
-    for (int i = 0; i < dimensions.length; i++) {
+      // First dimension is variable.
       if (i == 0 && variableLength) {
-        continue; // First dimension is variable.
+        // Variable dimension can't be negative.
+        if (dimensions[0] < 0) {
+          _errorReporter.atNode(
+            errorNode,
+            FfiCode.NEGATIVE_VARIABLE_DIMENSION,
+          );
+        }
+        continue;
       }
+
       if (dimensions[i] <= 0) {
-        AstNode errorNode = annotation;
-        var argumentNodes = getArgumentNodes();
-        if (argumentNodes != null && argumentNodes.isNotEmpty) {
-          errorNode = argumentNodes[i];
-        }
         _errorReporter.atNode(
           errorNode,
           FfiCode.NON_POSITIVE_ARRAY_DIMENSION,
@@ -2093,8 +2119,8 @@ extension on ElementAnnotation {
     assert(isArray);
     var value = computeConstantValue();
 
-    var variableLength =
-        value?.getField('variableLength')?.toBoolValue() ?? false;
+    var variableDimension = value?.getField('variableDimension')?.toIntValue();
+    var variableLength = variableDimension != null;
 
     // Element of `@Array.multi([1, 2, 3])`.
     var listField = value?.getField('dimensions');
@@ -2105,7 +2131,10 @@ extension on ElementAnnotation {
           .whereType<int>()
           .toList();
       if (listValues != null) {
-        return ([if (variableLength) 0, ...listValues], variableLength);
+        return (
+          [if (variableLength) variableDimension, ...listValues],
+          variableLength
+        );
       }
     }
 

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

@@ -902,20 +902,38 @@ final class DartRepresentationOf {
 
 @Since('2.13')
 final class Array<T extends NativeType> extends _Compound {
-  const factory Array(int dimension1,
-      [int dimension2,
-      int dimension3,
-      int dimension4,
-      int dimension5]) = _ArraySize<T>;
+  const factory Array(
+    int dimension1, [
+    int dimension2,
+    int dimension3,
+    int dimension4,
+    int dimension5,
+  ]) = _ArraySize<T>;
 
   const factory Array.multi(List<int> dimensions) = _ArraySize<T>.multi;
 
   @Since('3.6')
-  const factory Array.variable() = _ArraySize<T>.variable;
+  const factory Array.variable([
+    int dimension2,
+    int dimension3,
+    int dimension4,
+    int dimension5,
+  ]) = _ArraySize<T>.variable;
+
+  @Since('3.7')
+  const factory Array.variableWithVariableDimension([
+    int dimension1,
+    int dimension2,
+    int dimension3,
+    int dimension4,
+    int dimension5,
+  ]) = _ArraySize<T>.variableWithVariableDimension;
 
   @Since('3.6')
-  const factory Array.variableMulti(List<int> dimensions) =
-      _ArraySize<T>.variableMulti;
+  const factory Array.variableMulti(
+    List<int> dimensions, {
+    @Since('3.7') int variableDimension,
+  }) = _ArraySize<T>.variableMulti;
 }
 
 final class _ArraySize<T extends NativeType> implements Array<T> {
@@ -927,7 +945,7 @@ final class _ArraySize<T extends NativeType> implements Array<T> {
 
   final List<int>? dimensions;
 
-  final bool variableLength;
+  final int? variableDimension;
 
   const _ArraySize(
     this.dimension1, [
@@ -936,35 +954,44 @@ final class _ArraySize<T extends NativeType> implements Array<T> {
     this.dimension4,
     this.dimension5,
   ])  : dimensions = null,
-        variableLength = false;
+        variableDimension = null;
 
   const _ArraySize.multi(this.dimensions)
       : dimension1 = null,
         dimension2 = null,
         dimension3 = null,
         dimension4 = null,
         dimension5 = null,
-        variableLength = false;
-
-  static const variableLengthLength = 0;
+        variableDimension = null;
 
   const _ArraySize.variable([
     this.dimension2,
     this.dimension3,
     this.dimension4,
     this.dimension5,
-  ])  : dimension1 = variableLengthLength,
+  ])  : dimension1 = 0,
         dimensions = null,
-        variableLength = true;
+        variableDimension = 0;
+
+  const _ArraySize.variableWithVariableDimension([
+    this.dimension1,
+    this.dimension2,
+    this.dimension3,
+    this.dimension4,
+    this.dimension5,
+  ])  : dimensions = null,
+        variableDimension = dimension1;
 
-  const _ArraySize.variableMulti(List<int> nestedDimensions)
-      : dimensions = nestedDimensions,
+  const _ArraySize.variableMulti(
+    List<int> nestedDimensions, {
+    int variableDimension = 0,
+  })  : dimensions = nestedDimensions,
         dimension1 = null,
         dimension2 = null,
         dimension3 = null,
         dimension4 = null,
         dimension5 = null,
-        variableLength = true;
+        variableDimension = variableDimension;
 }
 
 extension StructPointer<T extends Struct> on Pointer<T> {

pkg/analyzer/messages.yaml

@@ -20400,6 +20400,76 @@ FfiCode:
         NativeCallable<Void Function(Int32)>.listener(f);
       }
       ```
+  NEGATIVE_VARIABLE_DIMENSION:
+    problemMessage: The variable dimension of a variable-length array must be non-negative.
+    correctionMessage: Try using a value that is zero or greater.
+    hasPublishedDocs: false
+    comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic in two cases.
+
+      The first is when the variable dimension given in an
+      `Array.variableWithVariableDimension` annotation is negative. The variable
+      dimension is the first argument in the annotation.
+
+      The second is when the variable dimension given in an
+      `Array.variableMulti` annotation is negative. The variable dimension is
+      specified in the `variableDimension` argument of the annotation.
+
+      For more information about FFI, see [C interop using dart:ffi][ffi].
+
+      #### Examples
+
+      The following code produces this diagnostic because a variable dimension
+      of `-1` was provided in the `Array.variableWithVariableDimension`
+      annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      final class MyStruct extends Struct {
+        @Array.variableWithVariableDimension([!-1!])
+        external Array<Uint8> a0;
+      }
+      ```
+
+      The following code produces this diagnostic because a variable dimension
+      of `-1` was provided in the `Array.variableMulti` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      final class MyStruct2 extends Struct {
+        @Array.variableMulti(variableDimension: [!-1!], [1, 2])
+        external Array<Array<Array<Uint8>>> a0;
+      }
+      ```
+
+      #### Common fixes
+
+      Change the variable dimension with zero (`0`) or a positive number:
+
+      ```dart
+      import 'dart:ffi';
+
+      final class MyStruct extends Struct {
+        @Array.variableWithVariableDimension(1)
+        external Array<Uint8> a0;
+      }
+      ```
+
+      Change the variable dimension with zero (`0`) or a positive number:
+
+      ```dart
+      import 'dart:ffi';
+
+      final class MyStruct2 extends Struct {
+        @Array.variableMulti(variableDimension: 1, [1, 2])
+        external Array<Array<Array<Uint8>>> a0;
+      }
+      ```
   NON_CONSTANT_TYPE_ARGUMENT:
     problemMessage: "The type arguments to '{0}' must be known at compile time, so they can't be type parameters."
     correctionMessage: Try changing the type argument to be a constant type.
@@ -20515,7 +20585,7 @@ FfiCode:
       #### Example
 
       The following code produces this diagnostic because an array dimension of
-      `-1` was provided:
+      `-8` was provided:
 
       ```dart
       import 'dart:ffi';
@@ -20539,7 +20609,8 @@ FfiCode:
       }
       ```
 
-      If this is a variable length inline array, change the annotation to `Array.variable()`:
+      If this is a variable length inline array, change the annotation to
+      `Array.variable()`:
 
       ```dart
       import 'dart:ffi';