Revert "[vm/ffi] Unwrap typed data in FFI calls"

This reverts: https://dart-review.googlesource.com/c/sdk/+/338620

We'd like to support this use case with a different API. See the
discussion in #54739.

TEST=tests/ffi

Bug: #44589
Bug: #54771
Change-Id: Ic22fbcab14d374bb9c81bba1f1bf6ae2dfc9e674
Cq-Include-Trybots: luci.dart.try:vm-aot-android-release-arm64c-try,vm-aot-android-release-arm_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-obfuscate-linux-release-x64-try,vm-aot-optimization-level-linux-release-x64-try,vm-aot-win-debug-arm64-try,vm-aot-win-debug-x64c-try,vm-aot-win-release-x64-try,vm-appjit-linux-debug-x64-try,vm-asan-linux-release-x64-try,vm-checked-mac-release-arm64-try,vm-eager-optimization-linux-release-ia32-try,vm-eager-optimization-linux-release-x64-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-x64-try,vm-kernel-linux-debug-x64-try,vm-kernel-precomp-linux-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-x64-try,vm-reload-linux-debug-x64-try,vm-reload-rollback-linux-debug-x64-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/+/349340
Commit-Queue: Daco Harkes <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: dcharkes

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

@@ -5005,29 +5005,6 @@ const MessageCode messageFfiAddressOfMustBeNative = const MessageCode(
     problemMessage:
         r"""Argument to 'Native.addressOf' must be annotated with @Native.""");
 
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<Null> codeFfiCallMustNotReturnTypedData =
-    messageFfiCallMustNotReturnTypedData;
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const MessageCode messageFfiCallMustNotReturnTypedData = const MessageCode(
-    "FfiCallMustNotReturnTypedData",
-    analyzerCodes: <String>["CALL_MUST_NOT_RETURN_TYPED_DATA"],
-    problemMessage: r"""FFI calls can't return typed data.""",
-    correctionMessage: r"""Try changing using `Pointer`s.""");
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<Null> codeFfiCallbackMustNotUseTypedData =
-    messageFfiCallbackMustNotUseTypedData;
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const MessageCode messageFfiCallbackMustNotUseTypedData = const MessageCode(
-    "FfiCallbackMustNotUseTypedData",
-    analyzerCodes: <String>["CALLBACK_MUST_NOT_USE_TYPED_DATA"],
-    problemMessage:
-        r"""FFI callbacks can't take typed data arguments or return value.""",
-    correctionMessage: r"""Try changing using `Pointer`s.""");
-
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String string, String name)>
     templateFfiCompoundImplementsFinalizable =
@@ -5430,17 +5407,6 @@ Message _withArgumentsFfiNativeUnexpectedNumberOfParametersWithReceiver(
       arguments: {'count': count, 'count2': count2});
 }
 
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<Null> codeFfiNonLeafCallMustNotTakeTypedData =
-    messageFfiNonLeafCallMustNotTakeTypedData;
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const MessageCode messageFfiNonLeafCallMustNotTakeTypedData = const MessageCode(
-    "FfiNonLeafCallMustNotTakeTypedData",
-    analyzerCodes: <String>["NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA"],
-    problemMessage: r"""FFI non-leaf calls can't take typed data arguments.""",
-    correctionMessage: r"""Try changing the call to a leaf call.""");
-
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
     Message Function(String name)> templateFfiNotStatic = const Template<

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

@@ -1780,12 +1780,6 @@ FfiCode.LEAF_CALL_MUST_NOT_RETURN_HANDLE:
   status: noFix
 FfiCode.LEAF_CALL_MUST_NOT_TAKE_HANDLE:
   status: noFix
-FfiCode.CALLBACK_MUST_NOT_USE_TYPED_DATA:
-  status: noFix
-FfiCode.CALL_MUST_NOT_RETURN_TYPED_DATA:
-  status: noFix
-FfiCode.NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA:
-  status: noFix
 FfiCode.MISMATCHED_ANNOTATION_ON_STRUCT_FIELD:
   status: noFix
 FfiCode.MISSING_ANNOTATION_ON_STRUCT_FIELD:

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

@@ -91,22 +91,6 @@ class FfiCode extends AnalyzerErrorCode {
         "Try passing a static function or field annotated with '@Native'",
   );
 
-  ///  No parameters.
-  static const FfiCode CALLBACK_MUST_NOT_USE_TYPED_DATA = FfiCode(
-    'CALLBACK_MUST_NOT_USE_TYPED_DATA',
-    "FFI callbacks can't take typed data arguments or return value.",
-    correctionMessage: "Try changing using `Pointer`s.",
-    hasPublishedDocs: true,
-  );
-
-  ///  No parameters.
-  static const FfiCode CALL_MUST_NOT_RETURN_TYPED_DATA = FfiCode(
-    'CALL_MUST_NOT_RETURN_TYPED_DATA',
-    "FFI calls can't return typed data.",
-    correctionMessage: "Try changing using `Pointer`s.",
-    hasPublishedDocs: true,
-  );
-
   ///  Parameters:
   ///  0: the name of the struct or union class
   static const FfiCode COMPOUND_IMPLEMENTS_FINALIZABLE = FfiCode(
@@ -391,14 +375,6 @@ class FfiCode extends AnalyzerErrorCode {
     hasPublishedDocs: true,
   );
 
-  ///  No parameters.
-  static const FfiCode NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA = FfiCode(
-    'NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA',
-    "FFI non-leaf calls can't take typed data arguments.",
-    correctionMessage: "Try changing the call to a leaf call.",
-    hasPublishedDocs: true,
-  );
-
   ///  Parameters:
   ///  0: the type that should be a valid dart:ffi native type.
   static const FfiCode NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER = FfiCode(

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

@@ -585,8 +585,6 @@ const List<ErrorCode> errorCodeValues = [
   FfiCode.ANNOTATION_ON_POINTER_FIELD,
   FfiCode.ARGUMENT_MUST_BE_A_CONSTANT,
   FfiCode.ARGUMENT_MUST_BE_NATIVE,
-  FfiCode.CALLBACK_MUST_NOT_USE_TYPED_DATA,
-  FfiCode.CALL_MUST_NOT_RETURN_TYPED_DATA,
   FfiCode.COMPOUND_IMPLEMENTS_FINALIZABLE,
   FfiCode.CREATION_OF_STRUCT_OR_UNION,
   FfiCode.EMPTY_STRUCT,
@@ -617,7 +615,6 @@ const List<ErrorCode> errorCodeValues = [
   FfiCode.NATIVE_FIELD_MISSING_TYPE,
   FfiCode.NATIVE_FIELD_NOT_STATIC,
   FfiCode.NON_CONSTANT_TYPE_ARGUMENT,
-  FfiCode.NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA,
   FfiCode.NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER,
   FfiCode.NON_POSITIVE_ARRAY_DIMENSION,
   FfiCode.NON_SIZED_TYPE_ARGUMENT,

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

@@ -587,14 +587,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
           [nativeType, dartType, 'Native']);
       return;
     }
-
-    _validateFfiTypedDataUnwrapping(
-      dartType,
-      nativeType,
-      errorNode,
-      isLeaf: isLeaf,
-      isCall: true,
-    );
   }
 
   bool _extendsNativeFieldWrapperClass1(InterfaceType? type) {
@@ -1027,13 +1019,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
       if (isLeaf) {
         _validateFfiLeafCallUsesNoHandles(TPrime, node);
       }
-      _validateFfiTypedDataUnwrapping(
-        F,
-        TPrime,
-        errorNode,
-        isLeaf: isLeaf,
-        isCall: true,
-      );
     }
     _validateIsLeafIsConst(node);
   }
@@ -1193,46 +1178,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
-  void _validateFfiTypedDataUnwrapping(
-    DartType dartType,
-    DartType nativeType,
-    AstNode errorNode, {
-    required bool isLeaf,
-    required bool isCall,
-  }) {
-    if (dartType is FunctionType && nativeType is FunctionType) {
-      if (dartType.returnType.isTypedData && nativeType.returnType.isPointer) {
-        if (!isCall) {
-          _errorReporter.reportErrorForNode(
-              FfiCode.CALLBACK_MUST_NOT_USE_TYPED_DATA, errorNode);
-        } else {
-          _errorReporter.reportErrorForNode(
-              FfiCode.CALL_MUST_NOT_RETURN_TYPED_DATA, errorNode);
-        }
-      }
-      int i = 0;
-      final nativeParamTypes = nativeType.normalParameterTypes.flattenVarArgs();
-      for (final dartParam in dartType.normalParameterTypes) {
-        if (i >= nativeParamTypes.length) {
-          // Cascading error as not the same amount of arguments.
-          // Already results in an error earlier.
-          return;
-        }
-        final nativeParam = nativeParamTypes[i];
-        i++;
-        if (dartParam.isTypedData && nativeParam.isPointer) {
-          if (!isCall) {
-            _errorReporter.reportErrorForNode(
-                FfiCode.CALLBACK_MUST_NOT_USE_TYPED_DATA, errorNode);
-          } else if (!isLeaf) {
-            _errorReporter.reportErrorForNode(
-                FfiCode.NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA, errorNode);
-          }
-        }
-      }
-    }
-  }
-
   /// Validate that the fields declared by the given [node] meet the
   /// requirements for fields within a struct or union class.
   void _validateFieldsInCompound(FieldDeclaration node) {
@@ -1354,7 +1299,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
             FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, e, ['exceptionalReturn']);
       }
     }
-    _validateFfiTypedDataUnwrapping(FT, T, f, isLeaf: false, isCall: false);
   }
 
   /// Ensure `isLeaf` is const as we need the value at compile time to know
@@ -1406,9 +1350,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     if (isLeaf) {
       _validateFfiLeafCallUsesNoHandles(S, typeArguments[0]);
     }
-    final AstNode errorNode = typeArguments[1];
-    _validateFfiTypedDataUnwrapping(F, S, errorNode,
-        isLeaf: isLeaf, isCall: true);
   }
 
   /// Validate the invocation of `Native.addressOf`.
@@ -1551,13 +1492,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
           _errorReporter.reportErrorForNode(
               FfiCode.MUST_BE_A_SUBTYPE, e, [eType, natRetType, name]);
         }
-        _validateFfiTypedDataUnwrapping(
-          funcType,
-          typeArg,
-          e,
-          isLeaf: false,
-          isCall: false,
-        );
         if (!_isConst(e)) {
           _errorReporter.reportErrorForNode(
               FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, e, ['exceptionalReturn']);

pkg/analyzer/messages.yaml

@@ -20032,139 +20032,6 @@ FfiCode:
         }
       }
       ```
-  NON_LEAF_CALL_MUST_NOT_TAKE_TYPED_DATA:
-    problemMessage: "FFI non-leaf calls can't take typed data arguments."
-    correctionMessage: Try changing the call to a leaf call.
-    comment: No parameters.
-    hasPublishedDocs: true
-    documentation: |-
-      #### Description
-
-      The analyzer produces this diagnostic when the value of the `isLeaf`
-      argument of `Pointer.asFunction`, `DynamicLibrary.lookupFunction`, or
-      `@Native` is `false` and the Dart function signature contains a typed
-      data parameter.
-
-      Typed data unwrapping is only supported on arguments for leaf FFI calls.
-
-      For more information about FFI, see [C interop using dart:ffi][ffi].
-
-      #### Example
-
-      The following code produces this diagnostic because the dart function
-      signature contains a typed data, but the `isLeaf` argument is `false`:
-
-      ```dart
-      import 'dart:ffi';
-      import 'dart:typed_data';
-
-      void f(Pointer<NativeFunction<Void Function(Pointer<Uint8>)>> p) {
-        p.asFunction<[!void Function(Uint8List)!]>();
-      }
-      ```
-
-      #### Common fixes
-
-      If the function has at least one typed data parameter, then add
-      the `isLeaf` argument:
-
-      ```dart
-      import 'dart:ffi';
-      import 'dart:typed_data';
-
-      void f(Pointer<NativeFunction<Void Function(Pointer<Uint8>)>> p) {
-        p.asFunction<void Function(Uint8List)>(isLeaf: true);
-      }
-      ```
-
-      If the function also uses `Handle`s, then it must be non-leaf. In That
-      case use `Pointer`s instead of typed data.
-  CALL_MUST_NOT_RETURN_TYPED_DATA:
-    problemMessage: "FFI calls can't return typed data."
-    correctionMessage: Try changing using `Pointer`s.
-    comment: No parameters.
-    hasPublishedDocs: true
-    documentation: |-
-      #### Description
-
-      The analyzer produces this diagnostic when the return type of
-      `Pointer.asFunction`, `DynamicLibrary.lookupFunction`, or
-      `@Native` is a typed data.
-
-      Typed data unwrapping is only supported on arguments for leaf FFI calls.
-
-      For more information about FFI, see [C interop using dart:ffi][ffi].
-
-      #### Example
-
-      The following code produces this diagnostic because the dart function
-      signature contains a typed data, but the `isLeaf` argument is `false`:
-
-      ```dart
-      import 'dart:ffi';
-      import 'dart:typed_data';
-
-      void f(Pointer<NativeFunction<Pointer<Uint8> Function()>> p) {
-        p.asFunction<[!Uint8List Function()!]>();
-      }
-      ```
-
-      #### Common fixes
-
-      Use the `Pointer` type instead:
-
-      ```dart
-      import 'dart:ffi';
-
-      void f(Pointer<NativeFunction<Pointer<Uint8> Function()>> p) {
-        p.asFunction<Pointer<Uint8> Function()>();
-      }
-      ```
-  CALLBACK_MUST_NOT_USE_TYPED_DATA:
-    problemMessage: "FFI callbacks can't take typed data arguments or return value."
-    correctionMessage: Try changing using `Pointer`s.
-    comment: No parameters.
-    hasPublishedDocs: true
-    documentation: |-
-      #### Description
-
-      The analyzer produces this diagnostic when an invocation of
-      `Pointer.fromFunction`, one of`NativeCallable`'s constructors has a
-      typed data argument or return value."
-
-      Typed data unwrapping is only supported on arguments for leaf FFI calls.
-
-      For more information about FFI, see [C interop using dart:ffi][ffi].
-
-      #### Example
-
-      The following code produces this diagnostic because the parameter type
-      of `g` is a typed data.
-
-      ```dart
-      import 'dart:ffi';
-      import 'dart:typed_data';
-
-      void f(Uint8List i) {}
-
-      void g() {
-        Pointer.fromFunction<Void Function(Pointer<Uint8>)>([!f!]);
-      }
-      ```
-
-      #### Common fixes
-
-      Use the `Pointer` type instead:
-
-      ```dart
-      import 'dart:ffi';
-
-      void f(Pointer<Uint8> i) {}
-
-      void g() {
-        Pointer.fromFunction<Void Function(Pointer<Uint8>)>(f);
-      }
-      ```
   NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER:
     problemMessage: "Can't invoke 'asFunction' because the function signature '{0}' for the pointer isn't a valid C function signature."
     correctionMessage: "Try changing the function argument in 'NativeFunction' to only use NativeTypes."