[vm] Async FFI callbacks

More details about the design:
https://docs.google.com/document/d/1QDjyY_6wOTOgURwpeYMKU9qEz0gKxx2MUrdruC6Kp6c/edit?usp=sharing

Change-Id: Ie3985d86dca7f5010044ca46c33ca177588c0f69
Bug: #37022
CoreLibraryReviewExempt: Reviewed by vm and api groups. web and wasm groups not affected because FFI isn't on those platforms.
TEST=async_void_function_callbacks_test.dart, ffi_callback_metadata_test.cc, other front end tests
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/305900
Commit-Queue: Liam Appelbe <[email protected]>
Reviewed-by: Alexander Markov <[email protected]>
Reviewed-by: Lasse Nielsen <[email protected]>
Reviewed-by: Daco Harkes <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: liamappelbe

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

@@ -320,8 +320,8 @@ class FfiCode extends AnalyzerErrorCode {
   ///  0: the return type that should be 'void'.
   static const FfiCode MUST_RETURN_VOID = FfiCode(
     'MUST_RETURN_VOID',
-    "The return type of the function passed to 'RawVoidCallback' must be "
-        "'void' rather than '{0}'.",
+    "The return type of the function passed to 'NativeCallable.listener' must "
+        "be 'void' rather than '{0}'.",
     correctionMessage: "Try changing the return type to 'void'.",
   );
 

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

@@ -30,7 +30,7 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
   static const _dartFfiLibraryName = 'dart.ffi';
   static const _finalizableClassName = 'Finalizable';
   static const _isLeafParamName = 'isLeaf';
-  static const _rawVoidCallback = 'RawVoidCallback';
+  static const _nativeCallable = 'NativeCallable';
   static const _opaqueClassName = 'Opaque';
 
   static const Set<String> _primitiveIntegerNativeTypesFixedSize = {
@@ -228,8 +228,8 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
         FfiCode.CREATION_OF_STRUCT_OR_UNION,
         node.constructorName,
       );
-    } else if (class_.isRawVoidCallback) {
-      _validateRawVoidCallback(node);
+    } else if (class_.isNativeCallable) {
+      _validateNativeCallable(node);
     }
 
     super.visitInstanceCreationExpression(node);
@@ -1143,6 +1143,37 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
         node.argumentList.arguments, S, typeArguments[0]);
   }
 
+  /// Validate the invocation of the constructor `NativeCallable.listener(f)`.
+  void _validateNativeCallable(InstanceCreationExpression node) {
+    var argCount = node.argumentList.arguments.length;
+    if (argCount != 1) {
+      // There are other diagnostics reported against the invocation and the
+      // diagnostics generated below might be inaccurate, so don't report them.
+      return;
+    }
+
+    var typeArg = (node.staticType as ParameterizedType).typeArguments[0];
+    if (!_isValidFfiNativeFunctionType(typeArg)) {
+      _errorReporter.reportErrorForNode(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
+          node.constructorName, [typeArg, _nativeCallable]);
+      return;
+    }
+
+    var f = node.argumentList.arguments[0];
+    var funcType = f.typeOrThrow;
+    if (!_validateCompatibleFunctionTypes(funcType, typeArg)) {
+      _errorReporter.reportErrorForNode(
+          FfiCode.MUST_BE_A_SUBTYPE, f, [funcType, typeArg, _nativeCallable]);
+      return;
+    }
+
+    // TODO(brianwilkerson) Validate that `f` is a top-level function.
+    var retType = (funcType as FunctionType).returnType;
+    if (retType is! VoidType) {
+      _errorReporter.reportErrorForNode(FfiCode.MUST_RETURN_VOID, f, [retType]);
+    }
+  }
+
   /// Validate that none of the [annotations] are from `dart:ffi`.
   void _validateNoAnnotations(NodeList<Annotation> annotations) {
     for (Annotation annotation in annotations) {
@@ -1184,37 +1215,6 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
-  /// Validate the invocation of the static method `RawVoidCallback<T>(f)`.
-  void _validateRawVoidCallback(InstanceCreationExpression node) {
-    var argCount = node.argumentList.arguments.length;
-    if (argCount != 1) {
-      // There are other diagnostics reported against the invocation and the
-      // diagnostics generated below might be inaccurate, so don't report them.
-      return;
-    }
-
-    var typeArg = (node.staticType as ParameterizedType).typeArguments[0];
-    if (!_isValidFfiNativeFunctionType(typeArg)) {
-      _errorReporter.reportErrorForNode(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
-          node.constructorName, [typeArg, _rawVoidCallback]);
-      return;
-    }
-
-    var f = node.argumentList.arguments[0];
-    var funcType = f.typeOrThrow;
-    if (!_validateCompatibleFunctionTypes(funcType, typeArg)) {
-      _errorReporter.reportErrorForNode(
-          FfiCode.MUST_BE_A_SUBTYPE, f, [funcType, typeArg, _rawVoidCallback]);
-      return;
-    }
-
-    // TODO(brianwilkerson) Validate that `f` is a top-level function.
-    var retType = (funcType as FunctionType).returnType;
-    if (retType is! VoidType) {
-      _errorReporter.reportErrorForNode(FfiCode.MUST_RETURN_VOID, f, [retType]);
-    }
-  }
-
   void _validateRefIndexed(IndexExpression node) {
     var targetType = node.realTarget.staticType;
     if (!_isValidFfiNativeType(targetType,
@@ -1472,6 +1472,14 @@ extension on Element? {
         element.isFfiExtension;
   }
 
+  /// Return `true` if this represents the class `NativeCallable`.
+  bool get isNativeCallable {
+    final element = this;
+    return element is ClassElement &&
+        element.name == FfiVerifier._nativeCallable &&
+        element.isFfiClass;
+  }
+
   bool get isNativeFunctionPointerExtension {
     final element = this;
     return element is ExtensionElement &&
@@ -1501,14 +1509,6 @@ extension on Element? {
         element.isFfiClass;
   }
 
-  /// Return `true` if this represents the class `RawVoidCallback`.
-  bool get isRawVoidCallback {
-    final element = this;
-    return element is ClassElement &&
-        element.name == FfiVerifier._rawVoidCallback &&
-        element.isFfiClass;
-  }
-
   /// Return `true` if this represents the class `Struct`.
   bool get isStruct {
     final element = this;

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

@@ -775,10 +775,10 @@ final class Pointer<T extends NativeType> extends NativeType {
 
 final Pointer<Never> nullptr = Pointer.fromAddress(0);
 
-class RawVoidCallback<T extends Function> {
-  RawVoidCallback(@DartRepresentationOf('T') Function callback) {}
+class NativeCallable<T extends Function> {
+  NativeCallable.listener(@DartRepresentationOf('T') Function callback) {}
 
-  Pointer<NativeFunction<T>> get pointer;
+  Pointer<NativeFunction<T>> get nativeFunction;
 
   void close();
 }

pkg/analyzer/messages.yaml

@@ -19016,7 +19016,7 @@ FfiCode:
       }
       ```
   MUST_RETURN_VOID:
-    problemMessage: "The return type of the function passed to 'RawVoidCallback' must be 'void' rather than '{0}'."
+    problemMessage: "The return type of the function passed to 'NativeCallable.listener' must be 'void' rather than '{0}'."
     correctionMessage: "Try changing the return type to 'void'."
     comment: |-
       Parameters:
@@ -19026,12 +19026,12 @@ FfiCode:
       #### Description
 
       The analyzer produces this diagnostic when you pass a function
-      that doesn't return `void` to the `RawVoidCallback` constructor.
+      that doesn't return `void` to the `NativeCallable.listener` constructor.
 
-      `RawVoidCallback` creates a native callback that can be invoked
-      from any thread. The native code that invokes the callback sends a message
-      back to the isolate that created the callback, and doesn't wait for a
-      response. So it isn't possible to return a result from the callback.
+      `NativeCallable.listener` creates a native callable that can be invoked
+      from any thread. The native code that invokes the callable sends a message
+      back to the isolate that created the callable, and doesn't wait for a
+      response. So it isn't possible to return a result from the callable.
 
       For more information about FFI, see [C interop using dart:ffi][ffi].
 
@@ -19046,7 +19046,7 @@ FfiCode:
       int f(int i) => i * 2;
 
       void g() {
-        RawVoidCallback<Int32 Function(Int32)>([!f!]);
+        NativeCallable<Int32 Function(Int32)>.listener([!f!]);
       }
       ```
 
@@ -19060,7 +19060,7 @@ FfiCode:
       void f(int i) => print(i * 2);
 
       void g() {
-        RawVoidCallback<Void Function(Int32)>(f);
+        NativeCallable<Void Function(Int32)>.listener(f);
       }
       ```
   NON_CONSTANT_TYPE_ARGUMENT:

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

@@ -9,78 +9,79 @@ import '../dart/resolution/context_collection_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
-    defineReflectiveTests(FfiRawVoidCallbacksMustReturnVoid);
+    defineReflectiveTests(FfiNativeCallableListenersMustReturnVoid);
   });
 }
 
 @reflectiveTest
-class FfiRawVoidCallbacksMustReturnVoid extends PubPackageResolutionTest {
-  test_RawVoidCallback_inferred() async {
+class FfiNativeCallableListenersMustReturnVoid
+    extends PubPackageResolutionTest {
+  test_NativeCallable_listener_inferred() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 void f(int i) => i * 2;
 void g() {
-  RawVoidCallback<Void Function(Int32)>? callback;
-  callback = RawVoidCallback(f);
+  NativeCallable<Void Function(Int32)>? callback;
+  callback = NativeCallable.listener(f);
   callback.close();
 }
 ''', []);
   }
 
-  test_RawVoidCallback_mustBeANativeFunctionType() async {
+  test_NativeCallable_listener_mustBeANativeFunctionType() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 void f(int i) => i * 2;
 void g() {
-  RawVoidCallback<void Function(int)>(f);
+  NativeCallable<void Function(int)>.listener(f);
 }
 ''', [
-      error(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE, 56, 35),
+      error(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE, 56, 43),
     ]);
   }
 
-  test_RawVoidCallback_mustBeASubtype() async {
+  test_NativeCallable_listener_mustBeASubtype() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 void f(int i) => i * 2;
 void g() {
-  RawVoidCallback<Void Function(Double)>(f);
+  NativeCallable<Void Function(Double)>.listener(f);
 }
 ''', [
-      error(FfiCode.MUST_BE_A_SUBTYPE, 95, 1),
+      error(FfiCode.MUST_BE_A_SUBTYPE, 103, 1),
     ]);
   }
 
-  test_RawVoidCallback_mustHaveTypeArgs() async {
+  test_NativeCallable_listener_mustHaveTypeArgs() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 int f(int i) => i * 2;
 void g() {
-  RawVoidCallback(f);
+  NativeCallable.listener(f);
 }
 ''', [
-      error(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE, 55, 15),
+      error(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE, 55, 23),
     ]);
   }
 
-  test_RawVoidCallback_mustReturnVoid() async {
+  test_NativeCallable_listener_mustReturnVoid() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 int f(int i) => i * 2;
 void g() {
-  RawVoidCallback<Int32 Function(Int32)>(f);
+  NativeCallable<Int32 Function(Int32)>.listener(f);
 }
 ''', [
-      error(FfiCode.MUST_RETURN_VOID, 94, 1),
+      error(FfiCode.MUST_RETURN_VOID, 102, 1),
     ]);
   }
 
-  test_RawVoidCallback_ok() async {
+  test_NativeCallable_listener_ok() async {
     await assertErrorsInCode(r'''
 import 'dart:ffi';
 void f(int i) => i * 2;
 void g() {
-  RawVoidCallback<Void Function(Int32)>(f);
+  NativeCallable<Void Function(Int32)>.listener(f);
 }
 ''', []);
   }

pkg/analyzer/tool/diagnostics/diagnostics.md

@@ -13437,18 +13437,18 @@ class B extends A {
 
 ### must_return_void
 
-_The return type of the function passed to 'RawVoidCallback' must be 'void'
-rather than '{0}'._
+_The return type of the function passed to 'NativeCallable.listener' must be
+'void' rather than '{0}'._
 
 #### Description
 
 The analyzer produces this diagnostic when you pass a function
-that doesn't return `void` to the `RawVoidCallback` constructor.
+that doesn't return `void` to the `NativeCallable.listener` constructor.
 
-`RawVoidCallback` creates a native callback that can be invoked
-from any thread. The native code that invokes the callback sends a message
-back to the isolate that created the callback, and doesn't wait for a
-response. So it isn't possible to return a result from the callback.
+`NativeCallable.listener` creates a native callable that can be invoked
+from any thread. The native code that invokes the callable sends a message
+back to the isolate that created the callable, and doesn't wait for a
+response. So it isn't possible to return a result from the callable.
 
 For more information about FFI, see [C interop using dart:ffi][ffi].
 
@@ -13463,7 +13463,7 @@ import 'dart:ffi';
 int f(int i) => i * 2;
 
 void g() {
-  RawVoidCallback<Int32 Function(Int32)>([!f!]);
+  NativeCallable<Int32 Function(Int32)>.listener([!f!]);
 }
 {% endprettify %}
 
@@ -13477,7 +13477,7 @@ import 'dart:ffi';
 void f(int i) => print(i * 2);
 
 void g() {
-  RawVoidCallback<Void Function(Int32)>(f);
+  NativeCallable<Void Function(Int32)>.listener(f);
 }
 {% endprettify %}
 

pkg/dart2wasm/lib/ffi_native_transformer.dart

@@ -44,7 +44,8 @@ void transformLibraries(
     'dart:_internal',
     'dart:typed_data',
     'dart:nativewrappers',
-    'dart:_wasm'
+    'dart:_wasm',
+    'dart:isolate',
   ]);
   final transformer = WasmFfiNativeTransformer(
       index, coreTypes, hierarchy, diagnosticReporter, referenceFromIndex);

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

@@ -78,6 +78,7 @@ export '../fasta/fasta_codes.dart'
         noLength,
         templateCantHaveNamedParameters,
         templateCantHaveOptionalParameters,
+        templateFfiNativeCallableListenerReturnVoid,
         templateFfiCompoundImplementsFinalizable,
         templateFfiDartTypeMismatch,
         templateFfiEmptyStruct,

pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart

@@ -1114,6 +1114,34 @@ Message _withArgumentsFfiExpectedNoExceptionalReturn(
       arguments: {'type': _type});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<Message Function(DartType _type, bool isNonNullableByDefault)>
+    templateFfiNativeCallableListenerReturnVoid = const Template<
+            Message Function(DartType _type, bool isNonNullableByDefault)>(
+        problemMessageTemplate:
+            r"""The return type of the function passed to NativeCallable.listener must be void rather than '#type'.""",
+        withArguments: _withArgumentsFfiNativeCallableListenerReturnVoid);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(DartType _type, bool isNonNullableByDefault)>
+    codeFfiNativeCallableListenerReturnVoid =
+    const Code<Message Function(DartType _type, bool isNonNullableByDefault)>(
+  "FfiNativeCallableListenerReturnVoid",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsFfiNativeCallableListenerReturnVoid(
+    DartType _type, bool isNonNullableByDefault) {
+  TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+  List<Object> typeParts = labeler.labelType(_type);
+  String type = typeParts.join();
+  return new Message(codeFfiNativeCallableListenerReturnVoid,
+      problemMessage:
+          """The return type of the function passed to NativeCallable.listener must be void rather than '${type}'.""" +
+              labeler.originMessages,
+      arguments: {'type': _type});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
     Message Function(

pkg/front_end/messages.status

@@ -401,6 +401,7 @@ FfiNativeUnexpectedNumberOfParametersWithReceiver/analyzerCode: Fail
 FfiNotStatic/analyzerCode: Fail
 FfiPackedAnnotation/analyzerCode: Fail
 FfiPackedAnnotationAlignment/analyzerCode: Fail
+FfiNativeCallableListenerReturnVoid/analyzerCode: Fail
 FfiSizeAnnotation/analyzerCode: Fail
 FfiSizeAnnotationDimensions/analyzerCode: Fail
 FfiStructAnnotation/analyzerCode: Fail