[ffigen] Fix ARC for blocks (#1491)

Author: liamappelbe

pkgs/ffigen/lib/src/code_generator/enum_class.dart

@@ -311,6 +311,7 @@ class EnumClass extends BindingType {
     Writer w,
     String value, {
     required bool objCRetain,
+    required bool objCAutorelease,
   }) =>
       sameDartAndFfiDartType ? value : '$value.value';
 

pkgs/ffigen/lib/src/code_generator/func.dart

@@ -132,8 +132,12 @@ class Func extends LookUpBinding {
           .join('');
 
       final argString = functionType.dartTypeParameters.map((p) {
-        final type = p.type.convertDartTypeToFfiDartType(w, p.name,
-            objCRetain: p.objCConsumed);
+        final type = p.type.convertDartTypeToFfiDartType(
+          w,
+          p.name,
+          objCRetain: p.objCConsumed,
+          objCAutorelease: false,
+        );
         return '$type,\n';
       }).join('');
       funcImplCall = functionType.returnType.convertFfiDartTypeToDartType(
@@ -223,11 +227,12 @@ late final $funcVarName = $funcPointerName.asFunction<$dartType>($isLeafString);
   }
 }
 
-/// Represents a Parameter, used in [Func] and [Typealias].
+/// Represents a Parameter, used in [Func], [Typealias], [ObjCMethod], and
+/// [ObjCBlock].
 class Parameter {
   final String? originalName;
   String name;
-  final Type type;
+  Type type;
   final bool objCConsumed;
 
   Parameter({
@@ -239,4 +244,8 @@ class Parameter {
         // A [NativeFunc] is wrapped with a pointer because this is a shorthand
         // used in C for Pointer to function.
         type = type.typealiasType is NativeFunc ? PointerType(type) : type;
+
+  String getNativeType({String varName = ''}) =>
+      '${type.getNativeType(varName: varName)}'
+      '${objCConsumed ? ' __attribute__((ns_consumed))' : ''}';
 }

pkgs/ffigen/lib/src/code_generator/global.dart

@@ -56,8 +56,12 @@ class Global extends LookUpBinding {
       if (!constant) {
         final releaseOldValue = type
             .convertFfiDartTypeToDartType(w, pointerValue, objCRetain: false);
-        final newValue =
-            type.convertDartTypeToFfiDartType(w, 'value', objCRetain: true);
+        final newValue = type.convertDartTypeToFfiDartType(
+          w,
+          'value',
+          objCRetain: true,
+          objCAutorelease: false,
+        );
         s.write('''set $globalVarName($dartType value) {
   $releaseOldValue.ref.release();
   $pointerValue = $newValue;

pkgs/ffigen/lib/src/code_generator/objc_block.dart

@@ -11,14 +11,16 @@ import 'writer.dart';
 
 class ObjCBlock extends BindingType {
   final Type returnType;
-  final List<Type> argTypes;
+  final List<Parameter> params;
+  final bool returnsRetained;
   Func? _wrapListenerBlock;
 
   factory ObjCBlock({
     required Type returnType,
-    required List<Type> argTypes,
+    required List<Parameter> params,
+    required bool returnsRetained,
   }) {
-    final usr = _getBlockUsr(returnType, argTypes);
+    final usr = _getBlockUsr(returnType, params, returnsRetained);
 
     final oldBlock = bindingsIndex.getSeenObjCBlock(usr);
     if (oldBlock != null) {
@@ -27,9 +29,10 @@ class ObjCBlock extends BindingType {
 
     final block = ObjCBlock._(
       usr: usr,
-      name: _getBlockName(returnType, argTypes),
+      name: _getBlockName(returnType, params.map((a) => a.type)),
       returnType: returnType,
-      argTypes: argTypes,
+      params: params,
+      returnsRetained: returnsRetained,
     );
     bindingsIndex.addObjCBlockToSeen(usr, block);
 
@@ -40,48 +43,54 @@ class ObjCBlock extends BindingType {
     required String super.usr,
     required super.name,
     required this.returnType,
-    required this.argTypes,
+    required this.params,
+    required this.returnsRetained,
   }) : super(originalName: name);
 
   // Generates a human readable name for the block based on the args and return
   // type. These names will be pretty verbose and unweildy, but they're at least
   // sensible and stable. Users can always add their own typedef with a simpler
   // name if necessary.
-  static String _getBlockName(Type returnType, List<Type> argTypes) =>
+  static String _getBlockName(Type returnType, Iterable<Type> argTypes) =>
       'ObjCBlock_${[returnType, ...argTypes].map(_typeName).join('_')}';
   static String _typeName(Type type) =>
       type.toString().replaceAll(_illegalNameChar, '');
   static final _illegalNameChar = RegExp(r'[^0-9a-zA-Z]');
 
-  static String _getBlockUsr(Type returnType, List<Type> argTypes) {
+  static String _getBlockUsr(
+      Type returnType, List<Parameter> params, bool returnsRetained) {
     // Create a fake USR code for the block. This code is used to dedupe blocks
-    // with the same signature.
+    // with the same signature. Not intended to be human readable.
     final usr = StringBuffer();
-    usr.write('objcBlock: ${returnType.cacheKey()}');
-    for (final type in argTypes) {
-      usr.write(' ${type.cacheKey()}');
+    usr.write(
+        'objcBlock: ${returnType.cacheKey()} ${returnsRetained ? 'R' : ''}');
+    for (final param in params) {
+      usr.write(' ${param.type.cacheKey()} ${param.objCConsumed ? 'C' : ''}');
     }
     return usr.toString();
   }
 
   bool get hasListener => returnType == voidType;
 
   String _blockType(Writer w) {
-    final args = argTypes.map((t) => t.getObjCBlockSignatureType(w)).join(', ');
-    final func = '${returnType.getObjCBlockSignatureType(w)} Function($args)';
+    final argStr = params.map((param) {
+      final type = param.type.getObjCBlockSignatureType(w);
+      return param.objCConsumed
+          ? '${ObjCBuiltInFunctions.consumedType.gen(w)}<$type>'
+          : type;
+    }).join(', ');
+    final retType = returnType.getObjCBlockSignatureType(w);
+    final retStr = returnsRetained
+        ? '${ObjCBuiltInFunctions.retainedType.gen(w)}<$retType>'
+        : retType;
+    final func = '$retStr Function($argStr)';
     return '${ObjCBuiltInFunctions.blockType.gen(w)}<$func>';
   }
 
   @override
   BindingString toBindingString(Writer w) {
     final s = StringBuffer();
 
-    final params = <Parameter>[];
-    for (var i = 0; i < argTypes.length; ++i) {
-      params.add(
-          Parameter(name: 'arg$i', type: argTypes[i], objCConsumed: false));
-    }
-
     final voidPtr = PointerType(voidType).getCType(w);
     final blockPtr = PointerType(objCBlockType);
     final funcType = FunctionType(returnType: returnType, parameters: params);
@@ -135,12 +144,18 @@ $returnFfiDartType $closureTrampoline($blockCType block, $paramsFfiDartType) =>
     // Snippet that converts a Dart typed closure to FfiDart type. This snippet
     // is used below. Note that the closure being converted is called `fn`.
     final convertedFnArgs = params
-        .map((p) =>
-            p.type.convertFfiDartTypeToDartType(w, p.name, objCRetain: true))
+        .map((p) => p.type.convertFfiDartTypeToDartType(
+              w,
+              p.name,
+              objCRetain: !p.objCConsumed,
+            ))
         .join(', ');
     final convFnInvocation = returnType.convertDartTypeToFfiDartType(
-        w, 'fn($convertedFnArgs)',
-        objCRetain: true);
+      w,
+      'fn($convertedFnArgs)',
+      objCRetain: true,
+      objCAutorelease: !returnsRetained,
+    );
     final convFn = '($paramsFfiDartType) => $convFnInvocation';
 
     // Write the wrapper class.
@@ -183,16 +198,19 @@ abstract final class $name {
 
     // Listener block constructor is only available for void blocks.
     if (hasListener) {
-      // This snippet is the same as the convFn above, except that the args
+      // This snippet is the same as the convFn above, except that the params
       // don't need to be retained because they've already been retained by
       // _wrapListenerBlock.
       final listenerConvertedFnArgs = params
           .map((p) =>
               p.type.convertFfiDartTypeToDartType(w, p.name, objCRetain: false))
           .join(', ');
       final listenerConvFnInvocation = returnType.convertDartTypeToFfiDartType(
-          w, 'fn($listenerConvertedFnArgs)',
-          objCRetain: true);
+        w,
+        'fn($listenerConvertedFnArgs)',
+        objCRetain: true,
+        objCAutorelease: !returnsRetained,
+      );
       final listenerConvFn =
           '($paramsFfiDartType) => $listenerConvFnInvocation';
       final wrapFn = _wrapListenerBlock?.name;
@@ -236,14 +254,21 @@ abstract final class $name {
 extension $callExtension on $blockType {
   ${returnType.getDartType(w)} call($paramsDartType) =>''');
     final callMethodArgs = params
-        .map((p) =>
-            p.type.convertDartTypeToFfiDartType(w, p.name, objCRetain: false))
+        .map((p) => p.type.convertDartTypeToFfiDartType(
+              w,
+              p.name,
+              objCRetain: p.objCConsumed,
+              objCAutorelease: false,
+            ))
         .join(', ');
     final callMethodInvocation = '''
 ref.pointer.ref.invoke.cast<$natTrampFnType>().asFunction<$trampFuncFfiDartType>()(
     ref.pointer, $callMethodArgs)''';
-    s.write(returnType.convertFfiDartTypeToDartType(w, callMethodInvocation,
-        objCRetain: false));
+    s.write(returnType.convertFfiDartTypeToDartType(
+      w,
+      callMethodInvocation,
+      objCRetain: !returnsRetained,
+    ));
     s.write(';\n');
 
     s.write('}\n\n');
@@ -257,11 +282,11 @@ ref.pointer.ref.invoke.cast<$natTrampFnType>().asFunction<$trampFuncFfiDartType>
 
     final argsReceived = <String>[];
     final retains = <String>[];
-    for (var i = 0; i < argTypes.length; ++i) {
-      final t = argTypes[i];
+    for (var i = 0; i < params.length; ++i) {
+      final param = params[i];
       final argName = 'arg$i';
-      argsReceived.add(t.getNativeType(varName: argName));
-      retains.add(t.generateRetain(argName) ?? argName);
+      argsReceived.add(param.getNativeType(varName: argName));
+      retains.add(param.type.generateRetain(argName) ?? argName);
     }
     final fnName = _wrapListenerBlock!.name;
     final blockTypedef = w.objCLevelUniqueNamer.makeUnique('ListenerBlock');
@@ -286,11 +311,11 @@ $blockTypedef $fnName($blockTypedef block) NS_RETURNS_RETAINED {
     dependencies.add(this);
 
     returnType.addDependencies(dependencies);
-    for (final t in argTypes) {
-      t.addDependencies(dependencies);
+    for (final p in params) {
+      p.type.addDependencies(dependencies);
     }
 
-    if (hasListener && argTypes.any((t) => t.generateRetain('') != null)) {
+    if (hasListener && params.any((p) => p.type.generateRetain('') != null)) {
       _wrapListenerBlock = Func(
         name: 'wrapListenerBlock_$name',
         returnType: this,
@@ -318,8 +343,8 @@ $blockTypedef $fnName($blockTypedef block) NS_RETURNS_RETAINED {
 
   @override
   String getNativeType({String varName = ''}) {
-    final args = argTypes.map<String>((t) => t.getNativeType());
-    return '${returnType.getNativeType()} (^$varName)(${args.join(', ')})';
+    final paramStrs = params.map<String>((p) => p.getNativeType());
+    return '${returnType.getNativeType()} (^$varName)(${paramStrs.join(', ')})';
   }
 
   @override
@@ -336,8 +361,9 @@ $blockTypedef $fnName($blockTypedef block) NS_RETURNS_RETAINED {
     Writer w,
     String value, {
     required bool objCRetain,
+    required bool objCAutorelease,
   }) =>
-      ObjCInterface.generateGetId(value, objCRetain);
+      ObjCInterface.generateGetId(value, objCRetain, objCAutorelease);
 
   @override
   String convertFfiDartTypeToDartType(
@@ -352,5 +378,6 @@ $blockTypedef $fnName($blockTypedef block) NS_RETURNS_RETAINED {
   String? generateRetain(String value) => 'objc_retainBlock($value)';
 
   @override
-  String toString() => '($returnType (^)(${argTypes.join(', ')}))';
+  String toString() =>
+      '($returnType (^)(${params.map((p) => p.type.toString()).join(', ')}))';
 }

pkgs/ffigen/lib/src/code_generator/objc_built_in_functions.dart

@@ -28,6 +28,8 @@ class ObjCBuiltInFunctions {
   static const objectRelease = ObjCImport('objectRelease');
   static const objectBase = ObjCImport('ObjCObjectBase');
   static const blockType = ObjCImport('ObjCBlock');
+  static const consumedType = ObjCImport('Consumed');
+  static const retainedType = ObjCImport('Retained');
   static const protocolMethod = ObjCImport('ObjCProtocolMethod');
   static const protocolListenableMethod =
       ObjCImport('ObjCProtocolListenableMethod');
@@ -113,8 +115,7 @@ class ObjCBuiltInFunctions {
   // the return type is a struct, we need to use objc_msgSend_stret instead, and
   // for float return types we need objc_msgSend_fpret.
   final _msgSendFuncs = <String, ObjCMsgSendFunc>{};
-  ObjCMsgSendFunc getMsgSendFunc(
-      Type returnType, List<ObjCMethodParam> params) {
+  ObjCMsgSendFunc getMsgSendFunc(Type returnType, List<Parameter> params) {
     var key = returnType.cacheKey();
     for (final p in params) {
       key += ' ${p.type.cacheKey()}';
@@ -255,8 +256,8 @@ class ObjCMsgSendFunc {
   late final ObjCMsgSendVariantFunc normalFunc;
   late final ObjCMsgSendVariantFunc? variantFunc;
 
-  ObjCMsgSendFunc(String name, Type returnType, List<ObjCMethodParam> params,
-      this.useVariants)
+  ObjCMsgSendFunc(
+      String name, Type returnType, List<Parameter> params, this.useVariants)
       : variant = ObjCMsgSendVariant.fromReturnType(returnType) {
     normalFunc = ObjCMsgSendVariantFunc(
       name: name,
@@ -284,14 +285,13 @@ class ObjCMsgSendFunc {
     }
   }
 
-  static List<Parameter> _params(List<ObjCMethodParam> params,
-      {Type? structRetPtr}) {
+  static List<Parameter> _params(List<Parameter> params, {Type? structRetPtr}) {
     return [
       if (structRetPtr != null)
         Parameter(type: structRetPtr, objCConsumed: false),
       Parameter(type: PointerType(objCObjectType), objCConsumed: false),
       Parameter(type: PointerType(objCSelType), objCConsumed: false),
-      for (final p in params) Parameter(type: p.type, objCConsumed: false),
+      ...params,
     ];
   }