[vm/ffi] Add refWithFinalizer methods to StructPointer and UnionPointer

TEST=tests/ffi/extension_methods_test.dart

CoreLibraryReviewExempt: VM only
Closes: #56796
Change-Id: I29af1e6b61b5a07887f00b3a924f1b354ffb0bbf
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/399600
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Daco Harkes <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>

Author: halildurmus

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

@@ -355,6 +355,11 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
         if (element.name3 == 'lookupFunction') {
           _validateLookupFunction(node);
         }
+      } else if (enclosingElement.isNativeStructPointerExtension ||
+          enclosingElement.isNativeUnionPointerExtension) {
+        if (element.name3 == 'refWithFinalizer') {
+          _validateRefWithFinalizer(node);
+        }
       }
     } else if (element is TopLevelFunctionElement) {
       if (element.library2.name3 == 'dart.ffi') {
@@ -1929,6 +1934,20 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  /// Validate the invocation of the
+  /// `Pointer<T extends Struct>.refWithFinalizer` and
+  /// `Pointer<T extends Union>.refWithFinalizer` extension methods.
+  void _validateRefWithFinalizer(MethodInvocation node) {
+    var targetType = node.realTarget?.staticType;
+    if (!_isValidFfiNativeType(targetType, allowEmptyStruct: true)) {
+      _errorReporter.atNode(
+        node,
+        FfiCode.NON_CONSTANT_TYPE_ARGUMENT,
+        arguments: ['refWithFinalizer'],
+      );
+    }
+  }
+
   void _validateSizeOf(MethodInvocation node) {
     var typeArgumentTypes = node.typeArgumentTypes;
     if (typeArgumentTypes == null || typeArgumentTypes.length != 1) {

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

@@ -998,6 +998,12 @@ extension StructPointer<T extends Struct> on Pointer<T> {
   external T get ref;
 
   external T operator [](int index);
+
+  @Since('3.7')
+  external T refWithFinalizer(
+    Pointer<NativeFinalizerFunction> finalizer, {
+    Pointer<Void>? token,
+  });
 }
 
 @Since('2.19')
@@ -1084,6 +1090,9 @@ abstract interface class Finalizable {
   factory Finalizable._() => throw UnsupportedError("");
 }
 
+typedef NativeFinalizerFunction =
+    NativeFunction<Void Function(Pointer<Void> token)>;
+
 @Since('3.0')
 abstract final class VarArgs<T extends Record> implements NativeType {}
 

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

@@ -74,4 +74,46 @@ T genericRef<T extends Struct>(Pointer<T> p) =>
     p.ref;
 ''', [error(FfiCode.NON_CONSTANT_TYPE_ARGUMENT, 72, 5)]);
   }
+
+  test_refWithFinalizer_class() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:ffi';
+
+final class MyStruct extends Struct {
+  @Uint8()
+  external int myField;
+}
+
+void main() {
+  final pointer = Pointer<MyStruct>.fromAddress(0);
+  pointer.refWithFinalizer(nullptr).myField = 1;
+}
+''');
+  }
+
+  test_refWithFinalizer_class_cascade() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:ffi';
+
+final class MyStruct extends Struct {
+  @Uint8()
+  external int myField;
+}
+
+void main() {
+  final pointer = Pointer<MyStruct>.fromAddress(0)
+    ..refWithFinalizer(nullptr).myField = 1;
+  print(pointer);
+}
+''');
+  }
+
+  test_refWithFinalizer_typeParameter() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+
+T genericRefWithFinalizer<T extends Struct>(Pointer<T> p) =>
+    p.refWithFinalizer(nullptr);
+''', [error(FfiCode.NON_CONSTANT_TYPE_ARGUMENT, 85, 27)]);
+  }
 }

pkg/vm/lib/modular/transformations/ffi/common.dart

@@ -252,6 +252,8 @@ class FfiTransformer extends Transformer {
   final Procedure addressGetter;
   final Procedure structPointerGetRef;
   final Procedure structPointerSetRef;
+  final Procedure structPointerRefWithFinalizer;
+  final Procedure structPointerRefWithFinalizerTearoff;
   final Procedure structPointerGetElemAt;
   final Procedure structPointerSetElemAt;
   final Procedure structPointerElementAt;
@@ -260,12 +262,15 @@ class FfiTransformer extends Transformer {
   final Procedure structPointerElementAtTearoff;
   final Procedure unionPointerGetRef;
   final Procedure unionPointerSetRef;
+  final Procedure unionPointerRefWithFinalizer;
+  final Procedure unionPointerRefWithFinalizerTearoff;
   final Procedure unionPointerGetElemAt;
   final Procedure unionPointerSetElemAt;
   final Procedure unionPointerElementAt;
   final Procedure unionPointerPlusOperator;
   final Procedure unionPointerMinusOperator;
   final Procedure unionPointerElementAtTearoff;
+  final Procedure uint8PointerAsTypedList;
   final Procedure structArrayElemAt;
   final Procedure unionArrayElemAt;
   final Procedure arrayArrayElemAt;
@@ -355,6 +360,7 @@ class FfiTransformer extends Transformer {
   late final InterfaceType nativeTypeType;
   // The Pointer type when instantiated to bounds.
   late final InterfaceType pointerNativeTypeType;
+  late final InterfaceType uint8Type;
   late final InterfaceType compoundType;
 
   /// Classes corresponding to [NativeType], indexed by [NativeType].
@@ -494,6 +500,10 @@ class FfiTransformer extends Transformer {
             index.getProcedure('dart:ffi', 'StructPointer', 'get:ref'),
         structPointerSetRef =
             index.getProcedure('dart:ffi', 'StructPointer', 'set:ref'),
+        structPointerRefWithFinalizer =
+            index.getProcedure('dart:ffi', 'StructPointer', 'refWithFinalizer'),
+        structPointerRefWithFinalizerTearoff = index.getProcedure('dart:ffi',
+            'StructPointer', LibraryIndex.tearoffPrefix + 'refWithFinalizer'),
         structPointerGetElemAt =
             index.getProcedure('dart:ffi', 'StructPointer', '[]'),
         structPointerSetElemAt =
@@ -510,6 +520,10 @@ class FfiTransformer extends Transformer {
             index.getProcedure('dart:ffi', 'UnionPointer', 'get:ref'),
         unionPointerSetRef =
             index.getProcedure('dart:ffi', 'UnionPointer', 'set:ref'),
+        unionPointerRefWithFinalizer =
+            index.getProcedure('dart:ffi', 'UnionPointer', 'refWithFinalizer'),
+        unionPointerRefWithFinalizerTearoff = index.getProcedure('dart:ffi',
+            'UnionPointer', LibraryIndex.tearoffPrefix + 'refWithFinalizer'),
         unionPointerGetElemAt =
             index.getProcedure('dart:ffi', 'UnionPointer', '[]'),
         unionPointerSetElemAt =
@@ -522,6 +536,8 @@ class FfiTransformer extends Transformer {
             index.getProcedure('dart:ffi', 'UnionPointer', '-'),
         unionPointerElementAtTearoff = index.getProcedure('dart:ffi',
             'UnionPointer', LibraryIndex.tearoffPrefix + 'elementAt'),
+        uint8PointerAsTypedList =
+            index.getProcedure('dart:ffi', 'Uint8Pointer', 'asTypedList'),
         structArrayElemAt = index.getProcedure('dart:ffi', 'StructArray', '[]'),
         unionArrayElemAt = index.getProcedure('dart:ffi', 'UnionArray', '[]'),
         arrayArrayElemAt = index.getProcedure('dart:ffi', 'ArrayArray', '[]'),
@@ -676,6 +692,8 @@ class FfiTransformer extends Transformer {
     intptrNativeTypeCfe =
         NativeTypeCfe(this, InterfaceType(intptrClass, Nullability.nonNullable))
             as AbiSpecificNativeTypeCfe;
+    uint8Type = InterfaceType(
+        nativeTypesClasses[NativeType.kUint8]!, Nullability.nonNullable);
     compoundType = InterfaceType(
       compoundClass,
       Nullability.nonNullable,

pkg/vm/lib/modular/transformations/ffi/use_sites.dart

@@ -210,7 +210,9 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
                 node == lookupFunctionTearoff ||
                 node == abiSpecificIntegerPointerElementAtTearoff ||
                 node == structPointerElementAtTearoff ||
-                node == unionPointerElementAtTearoff))) ||
+                node == structPointerRefWithFinalizerTearoff ||
+                node == unionPointerElementAtTearoff ||
+                node == unionPointerRefWithFinalizerTearoff))) ||
         // Dart2wasm uses enabledConstructorTearOffLowerings but these are not
         // users trying to call constructors.
         isConstructorTearOffLowering(node);
@@ -337,6 +339,13 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
         ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true);
 
         return _replaceSetRef(node);
+      } else if (target == structPointerRefWithFinalizer ||
+          target == unionPointerRefWithFinalizer) {
+        final DartType nativeType = node.arguments.types[0];
+
+        ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true);
+
+        return _replaceRefWithFinalizer(node);
       } else if (target == abiSpecificIntegerPointerElementAt ||
           target == structPointerElementAt ||
           target == unionPointerElementAt ||
@@ -1050,6 +1059,52 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
     );
   }
 
+  /// Replaces a `.refWithFinalizer` on a compound pointer extension with a
+  /// typed data view.
+  Expression _replaceRefWithFinalizer(StaticInvocation node) {
+    final dartType = node.arguments.types[0] as InterfaceType;
+    final constructors = dartType.classNode.constructors;
+    final fromTypedDataCtor =
+        constructors.firstWhere((c) => c.name == Name("#fromTypedData"));
+    // args: (receiver, finalizer, {token})
+    final pointer = node.arguments.positional[0];
+    final finalizer =
+        NamedExpression('finalizer', node.arguments.positional[1]);
+    NamedExpression? token;
+    if (node.arguments.named.isNotEmpty) {
+      token = node.arguments.named[0];
+    }
+
+    final cast = InstanceInvocation(
+      InstanceAccessKind.Instance,
+      pointer,
+      castMethod.name,
+      Arguments(const [], types: [uint8Type]),
+      interfaceTarget: castMethod,
+      functionType: FunctionTypeInstantiator.instantiate(
+        castMethod.getterType as FunctionType,
+        [uint8Type],
+      ),
+    );
+
+    return ConstructorInvocation(
+      fromTypedDataCtor,
+      Arguments(
+        [
+          StaticInvocation(
+            uint8PointerAsTypedList,
+            Arguments(
+              [cast, inlineSizeOf(dartType)!],
+              named: [finalizer, if (token != null) token],
+            ),
+          ),
+          ConstantExpression(IntConstant(0)),
+          inlineSizeOf(dartType)!,
+        ],
+      ),
+    );
+  }
+
   Expression _replaceRefArray(StaticInvocation node) {
     final dartType = node.arguments.types[0];
     final clazz = (dartType as InterfaceType).classNode;

pkg/vm/testcases/transformations/ffi/compound_copies.dart renamed to pkg/vm/testcases/transformations/ffi/compound_references.dart

@@ -10,6 +10,14 @@ final class Coordinate extends Struct {
   void copyInto(Pointer<Coordinate> ptr) {
     ptr.ref = this;
   }
+
+  void getRefWithFinalizer(
+    Pointer<Coordinate> ptr,
+    Pointer<NativeFinalizerFunction> finalizer, {
+    Pointer<Void>? token,
+  }) {
+    ptr.refWithFinalizer(finalizer, token: token);
+  }
 }
 
 final class SomeUnion extends Union {
@@ -20,6 +28,14 @@ final class SomeUnion extends Union {
   void copyIntoAtIndex(Pointer<SomeUnion> ptr, int index) {
     ptr[index] = this;
   }
+
+  void getRefWithFinalizer(
+    Pointer<SomeUnion> ptr,
+    Pointer<NativeFinalizerFunction> finalizer, {
+    Pointer<Void>? token,
+  }) {
+    ptr.refWithFinalizer(finalizer, token: token);
+  }
 }
 
 void main() {}

pkg/vm/testcases/transformations/ffi/compound_copies.dart.aot.expect renamed to pkg/vm/testcases/transformations/ffi/compound_references.dart.aot.expect

@@ -39,6 +39,9 @@ final class Coordinate extends ffi::Struct {
       synthesized self::Coordinate #source = this;
     } =>ffi::_memCopy(ptr, #C10, #source.{ffi::_Compound::_typedDataBase}{core::Object}, #source.{ffi::_Compound::_offsetInBytes}{core::int}, self::Coordinate::#sizeOf);
   }
+  method getRefWithFinalizer(ffi::Pointer<self::Coordinate> ptr, ffi::Pointer<ffi::NativeFunction<(ffi::Pointer<ffi::Void>) → ffi::Void>> finalizer, {ffi::Pointer<ffi::Void>? token = #C4}) → void {
+    new self::Coordinate::#fromTypedData(ffi::Uint8Pointer|asTypedList(ptr.{ffi::Pointer::cast}<ffi::Uint8>(){() → ffi::Pointer<ffi::Uint8>}, self::Coordinate::#sizeOf, finalizer: finalizer, token: token), #C10, self::Coordinate::#sizeOf);
+  }
   @#C8
   static get x#offsetOf() → core::int
     return #C11.{core::List::[]}(ffi::_abi()){(core::int) → core::int};
@@ -80,6 +83,9 @@ final class SomeUnion extends ffi::Union {
       synthesized self::SomeUnion #source = this;
     } =>ffi::_memCopy(ptr, index.{core::num::*}(self::SomeUnion::#sizeOf){(core::num) → core::num}, #source.{ffi::_Compound::_typedDataBase}{core::Object}, #source.{ffi::_Compound::_offsetInBytes}{core::int}, self::SomeUnion::#sizeOf);
   }
+  method getRefWithFinalizer(ffi::Pointer<self::SomeUnion> ptr, ffi::Pointer<ffi::NativeFunction<(ffi::Pointer<ffi::Void>) → ffi::Void>> finalizer, {ffi::Pointer<ffi::Void>? token = #C4}) → void {
+    new self::SomeUnion::#fromTypedData(ffi::Uint8Pointer|asTypedList(ptr.{ffi::Pointer::cast}<ffi::Uint8>(){() → ffi::Pointer<ffi::Uint8>}, self::SomeUnion::#sizeOf, finalizer: finalizer, token: token), #C10, self::SomeUnion::#sizeOf);
+  }
   @#C8
   static get coordinate#offsetOf() → core::int
     return #C11.{core::List::[]}(ffi::_abi()){(core::int) → core::int};

pkg/vm/testcases/transformations/ffi/compound_copies.dart.expect renamed to pkg/vm/testcases/transformations/ffi/compound_references.dart.expect

@@ -1358,4 +1358,21 @@ DART_EXPORT char TakeString(char* my_string) {
   return my_string[4];
 }
 
+struct Vec4 {
+  double x;
+  double y;
+  double z;
+  double w;
+};
+
+// Rearranges the components of the input Vec4 and stores them in the result
+// Vec4.
+// [x, y, z, w] -> [y, z, w, x]
+DART_EXPORT void TwiddleVec4Components(Vec4 input, Vec4* result) {
+  result->x = input.y;
+  result->y = input.z;
+  result->z = input.w;
+  result->w = input.x;
+}
+
 }  // namespace dart

runtime/bin/ffi_test/ffi_test_functions.cc

@@ -1279,6 +1279,12 @@ extension StructPointer<T extends Struct> on Pointer<T> {
   set ref(T value) =>
       throw "UNREACHABLE: This case should have been rewritten in the CFE";
 
+  @patch
+  T refWithFinalizer(
+    Pointer<NativeFinalizerFunction> finalizer, {
+    Pointer<Void>? token,
+  }) => throw "UNREACHABLE: This case should have been rewritten in the CFE.";
+
   @patch
   T operator [](int index) =>
       throw "UNREACHABLE: This case should have been rewritten in the CFE.";
@@ -1310,6 +1316,12 @@ extension UnionPointer<T extends Union> on Pointer<T> {
   set ref(T value) =>
       throw "UNREACHABLE: This case should have been rewritten in the CFE";
 
+  @patch
+  T refWithFinalizer(
+    Pointer<NativeFinalizerFunction> finalizer, {
+    Pointer<Void>? token,
+  }) => throw "UNREACHABLE: This case should have been rewritten in the CFE.";
+
   @patch
   T operator [](int index) =>
       throw "UNREACHABLE: This case should have been rewritten in the CFE.";