dart-lang
diff --git a/‎pkg/vm/lib/transformations/ffi/common.dart
Lines changed: 8 additions & 20 deletions b/‎pkg/vm/lib/transformations/ffi/common.dart
Lines changed: 8 additions & 20 deletions
diff --git a/‎pkg/vm/lib/transformations/ffi/native.dart
Lines changed: 119 additions & 119 deletions b/‎pkg/vm/lib/transformations/ffi/native.dart
Lines changed: 119 additions & 119 deletions
diff --git a/‎pkg/vm/lib/transformations/ffi/use_sites.dart
Lines changed: 3 additions & 3 deletions b/‎pkg/vm/lib/transformations/ffi/use_sites.dart
Lines changed: 3 additions & 3 deletions
@@ -1160,31 +1160,19 @@ class FfiTransformer extends Transformer {
         ]))
       ..fileOffset = fileOffset;
 
-    final possibleCompoundReturn = findCompoundReturnType(dartSignature);
-    if (possibleCompoundReturn != null) {
-      return invokeCompoundConstructor(
-          asFunctionInternalInvocation, possibleCompoundReturn);
+    if (dartSignature is FunctionType) {
+      final returnType = dartSignature.returnType;
+      if (returnType is InterfaceType) {
+        final clazz = returnType.classNode;
+        if (clazz.superclass == structClass || clazz.superclass == unionClass) {
+          return invokeCompoundConstructor(asFunctionInternalInvocation, clazz);
+        }
+      }
     }
 
     return asFunctionInternalInvocation;
   }
 
-  /// Returns the compound [Class] if a compound is returned, otherwise `null`.
-  Class? findCompoundReturnType(DartType dartSignature) {
-    if (dartSignature is! FunctionType) {
-      return null;
-    }
-    final returnType = dartSignature.returnType;
-    if (returnType is! InterfaceType) {
-      return null;
-    }
-    final clazz = returnType.classNode;
-    if (clazz.superclass == structClass || clazz.superclass == unionClass) {
-      return clazz;
-    }
-    return null;
-  }
-
   /// Returns
   /// - `true` if leaf
   /// - `false` if not leaf
 
@@ -183,6 +183,81 @@ class FfiNativeTransformer extends FfiTransformer {
     );
   }
 
+  // Create field holding the resolved native function pointer.
+  //
+  // For:
+  //   @FfiNative<IntPtr Function(Pointer<Void>)>('DoXYZ', isLeaf:true)
+  //   external int doXyz(NativeFieldWrapperClass1 obj);
+  //
+  // Create:
+  //   static final _doXyz$FfiNative$ptr =
+  //       Pointer<NativeFunction<IntPtr Function(Pointer<Void>)>>
+  //           .fromAddress(_ffi_resolver('..', 'DoXYZ', 1))
+  //           .asFunction<int Function(Pointer<Void>)>(isLeaf:true);
+  Field _createResolvedFfiNativeField(
+    String dartFunctionName,
+    StringConstant nativeFunctionName,
+    StringConstant? assetName,
+    bool isLeaf,
+    FunctionType dartFunctionType,
+    FunctionType ffiFunctionType,
+    int fileOffset,
+    Uri fileUri,
+  ) {
+    // Derive number of arguments from the native function signature.
+    final numberNativeArgs = ffiFunctionType.positionalParameters.length;
+
+    final nativeFunctionType = InterfaceType(
+      nativeFunctionClass,
+      Nullability.legacy,
+      <DartType>[ffiFunctionType],
+    );
+
+    // _ffi_resolver('...', 'DoXYZ', 1)
+    final resolverInvocation = FunctionInvocation(
+        FunctionAccessKind.FunctionType,
+        StaticGet(resolverField),
+        Arguments(<Expression>[
+          ConstantExpression(
+              assetName ?? StringConstant(currentLibrary.importUri.toString())),
+          ConstantExpression(nativeFunctionName),
+          ConstantExpression(IntConstant(numberNativeArgs)),
+        ]),
+        functionType: resolverField.type as FunctionType)
+      ..fileOffset = fileOffset;
+
+    // _fromAddress<NativeFunction<Double Function(Double)>>(...)
+    final functionPointerExpression = StaticInvocation(
+        fromAddressInternal,
+        Arguments(
+          <Expression>[resolverInvocation],
+          types: [nativeFunctionType],
+        ))
+      ..fileOffset = fileOffset;
+
+    final asFunctionInvocation = buildAsFunctionInternal(
+      functionPointer: functionPointerExpression,
+      dartSignature: dartFunctionType,
+      nativeSignature: ffiFunctionType,
+      isLeaf: isLeaf,
+      fileOffset: fileOffset,
+    );
+
+    // static final _doXyz$FfiNative$Ptr = ...
+    final fieldName =
+        Name('_$dartFunctionName\$FfiNative\$Ptr', currentLibrary);
+    final functionPointerField = Field.immutable(fieldName,
+        type: dartFunctionType,
+        initializer: asFunctionInvocation,
+        isStatic: true,
+        isFinal: true,
+        fileUri: fileUri,
+        getterReference: currentLibraryIndex?.lookupGetterReference(fieldName))
+      ..fileOffset = fileOffset;
+
+    return functionPointerField;
+  }
+
   // Whether a parameter of [dartParameterType], passed as [ffiParameterType],
   // needs to be converted to Pointer.
   bool _requiresPointerConversion(
@@ -275,7 +350,7 @@ class FfiNativeTransformer extends FfiTransformer {
   //     reachabilityFence(#t0);
   //   } => #t1
   Expression _wrapArgumentsAndReturn({
-    required StaticInvocation invocation,
+    required FunctionInvocation invocation,
     required FunctionType dartFunctionType,
     required FunctionType ffiFunctionType,
     bool checkReceiverForNullptr = false,
@@ -412,8 +487,6 @@ class FfiNativeTransformer extends FfiTransformer {
     return validSignature;
   }
 
-  static const vmFfiNative = 'vm:ffi:native';
-
   Procedure _transformProcedure(
     Procedure node,
     StringConstant nativeFunctionName,
@@ -435,135 +508,74 @@ class FfiNativeTransformer extends FfiTransformer {
       return node;
     }
 
-    final pragmaConstant = ConstantExpression(
-      InstanceConstant(pragmaClass.reference, [], {
-        pragmaName.fieldReference: StringConstant(vmFfiNative),
-        pragmaOptions.fieldReference: InstanceConstant(
-          nativeClass.reference,
-          [ffiFunctionType],
-          {
-            nativeSymbolField.fieldReference: nativeFunctionName,
-            nativeAssetField.fieldReference: assetName ??
-                StringConstant(currentLibrary.importUri.toString()),
-            nativeIsLeafField.fieldReference: BoolConstant(isLeaf),
-          },
-        )
-      }),
-      InterfaceType(
-        pragmaClass,
-        Nullability.nonNullable,
-        [],
-      ),
-    );
-
-    final possibleCompoundReturn = findCompoundReturnType(dartFunctionType);
-    if (dartFunctionType == wrappedDartFunctionType &&
-        node.isStatic &&
-        possibleCompoundReturn == null) {
-      // We are not wrapping/unwrapping arguments or return value.
-      node.addAnnotation(pragmaConstant);
-      return node;
-    }
-
-    // Introduce a new function as external with the annotation and give the
-    // current function a body that does the wrapping/unwrapping.
-    node.isExternal = false;
-
-    node.addAnnotation(ConstantExpression(
-      InstanceConstant(pragmaClass.reference, [], {
-        pragmaName.fieldReference: StringConstant("vm:prefer-inline"),
-        pragmaOptions.fieldReference: NullConstant(),
-      }),
-    ));
-
     final parent = node.parent;
-    var fileUri = currentLibrary.fileUri;
-    if (parent is Class) {
-      fileUri = parent.fileUri;
-    } else if (parent is Library) {
-      fileUri = parent.fileUri;
-    }
 
-    int varCounter = 0;
-    final nonWrappedFfiNative = Procedure(
-      Name('_${node.name.text}\$${node.kind.name}\$FfiNative', currentLibrary),
-      ProcedureKind.Method,
-      FunctionNode(
-        /*body=*/ null,
-        requiredParameterCount: wrappedDartFunctionType.requiredParameterCount,
-        positionalParameters: [
-          for (final positionalParameter
-              in wrappedDartFunctionType.positionalParameters)
-            VariableDeclaration(
-              /*name=*/ '#t${varCounter++}',
-              type: positionalParameter,
-            )..fileOffset = node.fileOffset,
-        ],
-        returnType: wrappedDartFunctionType.returnType,
-      )..fileOffset = node.fileOffset,
-      fileUri: fileUri,
-      isStatic: true,
-      isExternal: true,
-    )
-      ..isNonNullableByDefault = node.isNonNullableByDefault
-      ..fileOffset = node.fileOffset;
-    nonWrappedFfiNative.addAnnotation(pragmaConstant);
+    // static final _myMethod$FfiNative$Ptr = ..
+    final resolvedField = _createResolvedFfiNativeField(
+      '${node.name.text}\$${node.kind.name}',
+      nativeFunctionName,
+      assetName,
+      isLeaf,
+      wrappedDartFunctionType,
+      ffiFunctionType,
+      node.fileOffset,
+      node.fileUri,
+    );
 
-    // Add procedure to the parent the FfiNative function belongs to.
+    // Add field to the parent the FfiNative function belongs to.
     if (parent is Class) {
-      parent.addProcedure(nonWrappedFfiNative);
+      parent.addField(resolvedField);
     } else if (parent is Library) {
-      parent.addProcedure(nonWrappedFfiNative);
+      parent.addField(resolvedField);
     } else {
-      throw 'Unexpected parent of @Native function. '
+      throw 'Unexpected parent of @FfiNative function. '
           'Expected Class or Library, but found ${parent}.';
     }
 
-    final nonWrappedInvocation = StaticInvocation(
-      nonWrappedFfiNative,
-      Arguments(argumentList),
-    )..fileOffset = node.fileOffset;
+    // _myFunction$FfiNative$Ptr(obj, x)
+    final functionPointerInvocation = FunctionInvocation(
+        FunctionAccessKind.FunctionType,
+        StaticGet(resolvedField),
+        Arguments(argumentList),
+        functionType: wrappedDartFunctionType)
+      ..fileOffset = node.fileOffset;
 
     Expression result = (wrappedDartFunctionType == dartFunctionType
-        ? nonWrappedInvocation
+        ? functionPointerInvocation
         : _wrapArgumentsAndReturn(
-            invocation: nonWrappedInvocation,
+            invocation: functionPointerInvocation,
             dartFunctionType: dartFunctionType,
             ffiFunctionType: ffiFunctionType,
             checkReceiverForNullptr: checkReceiverForNullptr,
           ));
-    if (possibleCompoundReturn != null) {
-      result = invokeCompoundConstructor(result, possibleCompoundReturn);
-    }
 
+    //   => _myFunction$FfiNative$Ptr(
+    //     Pointer<Void>.fromAddress(_getNativeField(obj)), x)
     node.function.body = ReturnStatement(result)..parent = node.function;
 
     return node;
   }
 
   // Transform FfiNative instance methods.
-  //
   // Example:
-  //
   //   class MyNativeClass extends NativeFieldWrapperClass1 {
-  //     @Native<IntPtr Function(Pointer<Void>, IntPtr)>(symbol: 'MyClass_MyMethod')
+  //     @FfiNative<IntPtr Function(Pointer<Void>, IntPtr)>('MyClass_MyMethod')
   //     external int myMethod(int x);
   //   }
-  //
   // Becomes, roughly:
-  //
   //   ... {
-  //     @pragma(
-  //       'vm:ffi:native',
-  //       Native<IntPtr Function(Pointer<Void>, IntPtr)>(
-  //         symbol: 'MyClass_MyMethod',
-  //         assetId: '<library uri>',
-  //       ),
-  //     )
-  //     external int _myFunction$FfiNative(Pointer<Void> self, int x);
+  //     static final _myMethod$FfiNative$Ptr = ...
+  //     static _myMethod$FfiNative(MyNativeClass self, int x)
+  //       => _myMethod$FfiNative$Ptr(
+  //         Pointer<Void>.fromAddress(_getNativeField(self)), x);
+  //     int myMethod(int x) => _myMethod$FfiNative(this, x);
+  //   }
   //
-  //     @pragma('vm:prefer-inline')
-  //     int myMethod(int x) => _myMethod$FfiNative(_getNativeField(this), x);
+  //   ... {
+  //     static final _myMethod$FfiNative$Ptr = ...
+  //     int myMethod(int x)
+  //       => _myMethod$FfiNative$Ptr(
+  //         Pointer<Void>.fromAddress(_getNativeField(this)), x);
   //   }
   Procedure _transformInstanceMethod(
       Procedure node,
@@ -597,26 +609,13 @@ class FfiNativeTransformer extends FfiTransformer {
   }
 
   // Transform FfiNative static functions.
-  //
   // Example:
-  //
-  //   @Native<IntPtr Function(Pointer<Void>, IntPtr)>(symbol: 'MyFunction')
+  //   @FfiNative<IntPtr Function(Pointer<Void>, IntPtr)>('MyFunction')
   //   external int myFunction(MyNativeClass obj, int x);
-  //
   // Becomes, roughly:
-  //
-  //   @pragma(
-  //     'vm:ffi:native',
-  //     Native<IntPtr Function(Pointer<Void>, IntPtr)>(
-  //       symbol: 'MyFunction',
-  //       assetId: '<library uri>',
-  //     ),
-  //   )
-  //   external int _myFunction$FfiNative(Pointer<Void> self, int x);
-  //
-  //   @pragma('vm:prefer-inline')
+  //   static final _myFunction$FfiNative$Ptr = ...
   //   int myFunction(MyNativeClass obj, int x)
-  //     => _myFunction$FfiNative(
+  //     => myFunction$FfiNative$Ptr(
   //       Pointer<Void>.fromAddress(_getNativeField(obj)), x);
   Procedure _transformStaticFunction(
       Procedure node,
@@ -649,7 +648,7 @@ class FfiNativeTransformer extends FfiTransformer {
   @override
   visitProcedure(Procedure node) {
     // Only transform functions that are external and have FfiNative annotation:
-    //   @Native<Double Function(Double)>(symbol: 'Math_sqrt')
+    //   @FfiNative<Double Function(Double)>('Math_sqrt')
     //   external double _square_root(double x);
     final ffiNativeAnnotation =
         tryGetNativeAnnotation(node) ?? tryGetFfiNativeAnnotation(node);
@@ -662,6 +661,7 @@ class FfiNativeTransformer extends FfiTransformer {
           1, node.location?.file);
       return node;
     }
+    node.isExternal = false;
 
     node.annotations.remove(ffiNativeAnnotation);
 
 
@@ -352,7 +352,7 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
             .where((c) =>
                 c.superclass == structClass || c.superclass == unionClass)
             .toList();
-        return invokeCompoundConstructors(replacement, compoundClasses);
+        return _invokeCompoundConstructors(replacement, compoundClasses);
       } else if (target == allocateMethod) {
         final DartType nativeType = node.arguments.types[0];
 
@@ -387,7 +387,7 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
     return node;
   }
 
-  Expression invokeCompoundConstructors(
+  Expression _invokeCompoundConstructors(
           Expression nestedExpression, List<Class> compoundClasses) =>
       compoundClasses
           .distinct()
@@ -748,7 +748,7 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
         .map((t) => t.classNode)
         .where((c) => c.superclass == structClass || c.superclass == unionClass)
         .toList();
-    return invokeCompoundConstructors(replacement, compoundClasses);
+    return _invokeCompoundConstructors(replacement, compoundClasses);
   }
 
   Expression _replaceGetRef(StaticInvocation node) {