[vm/ffi] Allow omitting native types for @Native functions

This change simplifies working with `@Native`-annotated functions by allowing the native type to be omitted when it can be inferred from the Dart function's signature. While this was previously supported for `@Native` fields, it now applies to functions as well.

Before this change, you needed to specify the native type explicitly:
```
@Native<Void Function(Pointer)>()
external void free(Pointer p);
```

After this change, the native type can now be omitted if it's clear from the Dart signature:
```
@Native()
external void free(Pointer p);
```

TEST=tests/ffi/native_assets/*

CoreLibraryReviewExempt: VM only
Closes: #54810
Change-Id: Ied5407fcd2f49d85284cb7817f0c8cad2a73626b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/400840
Reviewed-by: Daco Harkes <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Moritz Sümmermann <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: halildurmus

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

@@ -6647,6 +6647,18 @@ const MessageCode messageFfiNativeFieldType = const MessageCode(
       r"""Unsupported type for native fields. Native fields only support pointers, compounds and numeric types.""",
 );
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeFfiNativeFunctionMissingType =
+    messageFfiNativeFunctionMissingType;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageFfiNativeFunctionMissingType = const MessageCode(
+  "FfiNativeFunctionMissingType",
+  analyzerCodes: <String>["NATIVE_FUNCTION_MISSING_TYPE"],
+  problemMessage:
+      r"""The native type of this function couldn't be inferred so it must be specified in the annotation.""",
+);
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeFfiNativeMustBeExternal = messageFfiNativeMustBeExternal;
 

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

@@ -1792,6 +1792,8 @@ FfiCode.NATIVE_FIELD_MISSING_TYPE:
   status: needsEvaluation
 FfiCode.NATIVE_FIELD_NOT_STATIC:
   status: needsEvaluation
+FfiCode.NATIVE_FUNCTION_MISSING_TYPE:
+  status: needsEvaluation
 FfiCode.NEGATIVE_VARIABLE_DIMENSION:
   status: noFix
 FfiCode.NON_CONSTANT_TYPE_ARGUMENT:

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

@@ -387,6 +387,16 @@ class FfiCode extends ErrorCode {
     hasPublishedDocs: true,
   );
 
+  ///  No parameters
+  static const FfiCode NATIVE_FUNCTION_MISSING_TYPE = FfiCode(
+    'NATIVE_FUNCTION_MISSING_TYPE',
+    "The native type of this function couldn't be inferred so it must be "
+        "specified in the annotation.",
+    correctionMessage:
+        "Try adding a type parameter extending `NativeType` to the `@Native` "
+        "annotation.",
+  );
+
   ///  No parameters.
   static const FfiCode NEGATIVE_VARIABLE_DIMENSION = FfiCode(
     'NEGATIVE_VARIABLE_DIMENSION',

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

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

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

@@ -110,6 +110,9 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
   /// Subclass of `Struct` or `Union` we are currently visiting, or `null`.
   ClassDeclaration? compound;
 
+  /// The `Void` type from `dart:ffi`, or `null` if unresolved.
+  InterfaceType? ffiVoidType;
+
   /// Initialize a newly created verifier.
   FfiVerifier(this.typeSystem, this._errorReporter,
       {required this.strictCasts});
@@ -493,8 +496,36 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
           );
         }
       } else {
-        if (declarationElement is MethodElement2 ||
-            declarationElement is TopLevelFunctionElement) {
+        if (declarationElement
+            case TopLevelFunctionElement() || MethodElement2()) {
+          declarationElement = declarationElement as ExecutableElement2;
+          var dartSignature = declarationElement.type;
+
+          if (declarationElement.isStatic && ffiSignature is DynamicType) {
+            // No type argument was given on the @Native annotation, so we try
+            // to infer the native type from the Dart signature.
+            if (dartSignature.returnType is VoidType) {
+              // The Dart signature has a `void` return type, so we create a new
+              // `FunctionType` with FFI's `Void` as the return type.
+              dartSignature = FunctionTypeImpl.v2(
+                typeParameters: dartSignature.typeParameters,
+                formalParameters: dartSignature.formalParameters,
+                returnType: ffiVoidType ??= annotationType.element3.library2
+                    .getClass2('Void')!
+                    .thisType,
+                nullabilitySuffix: dartSignature.nullabilitySuffix,
+              );
+            }
+            _checkFfiNativeFunction(
+              errorNode,
+              declarationElement,
+              dartSignature,
+              annotationValue,
+              formalParameters,
+            );
+            return;
+          }
+
           // Function annotated with something that isn't a function type.
           _errorReporter.atToken(
             errorNode,
@@ -512,9 +543,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
           );
         }
       }
-
-      if (ffiSignature is FunctionType &&
-          declarationElement is ExecutableElement2) {}
     }
   }
 
@@ -683,11 +711,20 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
       nullabilitySuffix: ffiSignature.nullabilitySuffix,
     );
     if (!_isValidFfiNativeFunctionType(nativeType)) {
-      _errorReporter.atToken(
-        errorToken,
-        FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
-        arguments: [nativeType, 'Native'],
-      );
+      var nativeTypeIsOmitted = (annotationValue.type! as InterfaceType)
+          .typeArguments[0] is DynamicType;
+      if (nativeTypeIsOmitted) {
+        _errorReporter.atToken(
+          errorToken,
+          FfiCode.NATIVE_FUNCTION_MISSING_TYPE,
+        );
+      } else {
+        _errorReporter.atToken(
+          errorToken,
+          FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
+          arguments: [nativeType, 'Native'],
+        );
+      }
       return;
     }
     if (!_validateCompatibleFunctionTypes(
@@ -1707,45 +1744,70 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
             // When referencing a function, the target type must be a
             // `NativeFunction<T>` so that `T` matches the type from the
             // annotation.
-            if (!targetType.isNativeFunction) {
-              _errorReporter.atNode(
-                node,
-                FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
-                arguments: [targetType, _nativeAddressOf],
-              );
-            } else {
-              var targetFunctionType =
-                  (targetType as InterfaceType).typeArguments[0];
+            if (targetType case InterfaceType(isNativeFunction: true)) {
+              var targetFunctionType = targetType.typeArguments[0];
               if (!typeSystem.isEqualTo(nativeType, targetFunctionType)) {
                 _errorReporter.atNode(
                   node,
                   FfiCode.MUST_BE_A_SUBTYPE,
                   arguments: [nativeType, targetFunctionType, _nativeAddressOf],
                 );
               }
+            } else {
+              _errorReporter.atNode(
+                node,
+                FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
+                arguments: [targetType, _nativeAddressOf],
+              );
             }
           } else {
-            // A native field is being referenced, this doesn't require a
-            // NativeFunction wrapper. However, we can't read the native type
-            // from the annotation directly because it might be inferred if none
-            // was given.
-            if (nativeType is DynamicType) {
-              var staticType = argument.staticType;
-              if (staticType != null) {
-                var canonical = _canonicalFfiTypeForDartType(staticType);
-
-                if (canonical != null) {
-                  nativeType = canonical;
+            if (argument.staticType case var staticType?
+                when nativeType is DynamicType) {
+              // No type argument was given on the @Native annotation, so we try
+              // to infer the native type from the Dart signature.
+              if (staticType is FunctionType) {
+                if (staticType.returnType is VoidType) {
+                  // The Dart signature has a `void` return type, so we create a
+                  // new `FunctionType` with FFI's `Void` as the return type.
+                  staticType = FunctionTypeImpl.v2(
+                    typeParameters: staticType.typeParameters,
+                    formalParameters: staticType.formalParameters,
+                    returnType: ffiVoidType ??= annotationType.element3.library2
+                        .getClass2('Void')!
+                        .thisType,
+                    nullabilitySuffix: staticType.nullabilitySuffix,
+                  );
                 }
-              }
-            }
 
-            if (!typeSystem.isEqualTo(nativeType, targetType)) {
-              _errorReporter.atNode(
-                node,
-                FfiCode.MUST_BE_A_SUBTYPE,
-                arguments: [nativeType, targetType, _nativeAddressOf],
-              );
+                if (targetType case InterfaceType(isNativeFunction: true)) {
+                  var targetFunctionType = targetType.typeArguments[0];
+                  if (!typeSystem.isEqualTo(staticType, targetFunctionType)) {
+                    _errorReporter.atNode(
+                      node,
+                      FfiCode.MUST_BE_A_SUBTYPE,
+                      arguments: [
+                        staticType,
+                        targetFunctionType,
+                        _nativeAddressOf
+                      ],
+                    );
+                  }
+                } else {
+                  _errorReporter.atNode(
+                    node,
+                    FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
+                    arguments: [targetType, _nativeAddressOf],
+                  );
+                }
+              } else {
+                if (!typeSystem.isEqualTo(staticType, targetType)) {
+                  _errorReporter.atNode(
+                    node,
+                    FfiCode.MUST_BE_A_SUBTYPE,
+                    arguments: [staticType, targetType, _nativeAddressOf],
+                  );
+                }
+              }
             }
           }
 

pkg/analyzer/messages.yaml

@@ -19212,6 +19212,49 @@ FfiCode:
         external int f;
       }
       ```
+  NATIVE_FUNCTION_MISSING_TYPE:
+    problemMessage: The native type of this function couldn't be inferred so it must be specified in the annotation.
+    correctionMessage: Try adding a type parameter extending `NativeType` to the `@Native` annotation.
+    hasPublishedDocs: false
+    comment: No parameters
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a `@Native`-annotated function
+      requires a type hint on the annotation to infer the native function type.
+
+      Dart types like `int` and `double` have multiple possible native
+      representations. Since the native type needs to be known at compile time
+      to generate correct bindings and call instructions for the function, an
+      explicit type must be given.
+
+      For more information about FFI, see [C interop using dart:ffi][ffi].
+
+      #### Example
+
+      The following code produces this diagnostic because the function `f()` has
+      the return type `int`, but doesn't have an explicit type parameter on the
+      `Native` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Native()
+      external int [!f!]();
+      ```
+
+      #### Common fixes
+
+      Add the corresponding type to the annotation. For instance, if `f()` was
+      declared to return an `int32_t` in C, the Dart function should be declared
+      as:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Native<Int32 Function()>()
+      external int f();
+      ```
   COMPOUND_IMPLEMENTS_FINALIZABLE:
     problemMessage: "The class '{0}' can't implement Finalizable."
     correctionMessage: "Try removing the implements clause from '{0}'."