[ffigen] Add flags controlling how transitive deps are pulled in

pkgs/ffigen/CHANGELOG.md

@@ -6,6 +6,12 @@
   - https://github.com/dart-lang/native/issues/1582
   - https://github.com/dart-lang/native/issues/1594
   - https://github.com/dart-lang/native/issues/1595
+- Add `includeTransitiveObjCInterfaces` and `includeTransitiveObjCProtocols`
+  config flags, which control whether transitively included ObjC interfaces and
+  protocols are generated.
+- __Breaking change__: `includeTransitiveObjCInterfaces` defaults to false,
+  which changes the default behavior from pulling in all transitive deps, to
+  generating them as stubs.
 
 ## 15.0.0
 

pkgs/ffigen/README.md

@@ -810,6 +810,31 @@ objc-protocols:
 
   </td>
   </tr>
+
+  <tr>
+    <td>
+      include-transitive-objc-interfaces<br><br>
+      include-transitive-objc-protocols
+    </td>
+    <td>
+      By default, Objective-C interfaces and protocols that are not directly
+      included by the inclusion rules, but are transitively depended on by
+      the inclusions, are not fully code genned. Transitively included
+      interfaces are generated as stubs, and transitive protocols are omitted.
+      <br>
+      If these flags are enabled, transitively included interfaces and protocols
+      are fully code genned.
+      <br>
+      <b>Default: false</b>
+    </td>
+    <td>
+
+```yaml
+include-transitive-objc-interfaces: true
+include-transitive-objc-protocols: true
+```
+  </td>
+  </tr>
 </tbody>
 </table>
 

pkgs/ffigen/ffigen.schema.json

@@ -406,6 +406,12 @@
     "include-unused-typedefs": {
       "type": "boolean"
     },
+    "include-transitive-objc-interfaces": {
+      "type": "boolean"
+    },
+    "include-transitive-objc-protocols": {
+      "type": "boolean"
+    },
     "generate-for-package-objective-c": {
       "type": "boolean"
     },

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

@@ -143,6 +143,8 @@ class ObjCBuiltInFunctions {
   // for float return types we need objc_msgSend_fpret.
   final _msgSendFuncs = <String, ObjCMsgSendFunc>{};
   ObjCMsgSendFunc getMsgSendFunc(Type returnType, List<Parameter> params) {
+    params = _methodSigParams(params);
+    returnType = _methodSigType(returnType);
     final id = _methodSigId(returnType, params);
     return _msgSendFuncs[id] ??= ObjCMsgSendFunc(
         '_objc_msgSend_${fnvHash32(id).toRadixString(36)}',
@@ -161,19 +163,50 @@ class ObjCBuiltInFunctions {
 
   String _methodSigId(Type returnType, List<Parameter> params) {
     final paramIds = <String>[];
-    for (final param in params) {
-      final retainFunc = param.type.generateRetain('');
-
+    for (final p in params) {
       // The trampoline ID is based on the getNativeType of the param. Objects
       // and blocks both have `id` as their native type, but need separate
       // trampolines since they have different retain functions. So add the
-      // retainFunc (if any) to all the param IDs.
-      paramIds.add('${param.getNativeType()}-${retainFunc ?? ''}');
+      // retain function (if any) to all the param IDs.
+      paramIds.add(p.getNativeType(varName: p.type.generateRetain('') ?? ''));
     }
-    final rt = '${returnType.getNativeType()}-${returnType.generateRetain('')}';
+    final rt =
+        returnType.getNativeType(varName: returnType.generateRetain('') ?? '');
     return '$rt,${paramIds.join(',')}';
   }
 
+  Type _methodSigType(Type t) {
+    if (t is FunctionType) {
+      return FunctionType(
+        returnType: _methodSigType(t.returnType),
+        parameters: _methodSigParams(t.parameters),
+        varArgParameters: _methodSigParams(t.varArgParameters),
+      );
+    } else if (t is ObjCBlock) {
+      return ObjCBlockPointer();
+    } else if (t is ObjCInterface) {
+      return ObjCObjectPointer();
+    } else if (t is ConstantArray) {
+      return ConstantArray(
+        t.length,
+        _methodSigType(t.child),
+        useArrayType: t.useArrayType,
+      );
+    } else if (t is PointerType) {
+      return PointerType(_methodSigType(t.child));
+    } else if (t is ObjCNullable) {
+      return _methodSigType(t.child);
+    } else if (t is Typealias) {
+      return _methodSigType(t.type);
+    }
+    return t;
+  }
+
+  List<Parameter> _methodSigParams(List<Parameter> params) => params
+      .map((p) =>
+          Parameter(type: _methodSigType(p.type), objCConsumed: p.objCConsumed))
+      .toList();
+
   final _blockTrampolines = <String, ObjCListenerBlockTrampoline>{};
   ObjCListenerBlockTrampoline? getListenerBlockTrampoline(ObjCBlock block) {
     final id = _methodSigId(block.returnType, block.params);

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

@@ -22,6 +22,9 @@ class ObjCInterface extends BindingType with ObjCMethods {
   @override
   final ObjCBuiltInFunctions builtInFunctions;
 
+  // Filled by ListBindingsVisitation.
+  bool generateAsStub = false;
+
   ObjCInterface({
     super.usr,
     required String super.originalName,
@@ -53,27 +56,23 @@ class ObjCInterface extends BindingType with ObjCMethods {
 
   @override
   BindingString toBindingString(Writer w) {
-    String paramsToString(List<Parameter> params) {
-      final stringParams = <String>[
-        for (final p in params)
-          '${_getConvertedType(p.type, w, name)} ${p.name}',
-      ];
-      return '(${stringParams.join(", ")})';
-    }
-
     final s = StringBuffer();
     s.write('\n');
+    if (generateAsStub) {
+      s.write('''
+/// WARNING: $name is a stub. To generate bindings for this class, include
+/// $name in your config's objc-interfaces list.
+///
+''');
+    }
     s.write(makeDartDoc(dartDoc ?? originalName));
 
-    final methodNamer = createMethodRenamer(w);
-
     final rawObjType = PointerType(objCObjectType).getCType(w);
     final wrapObjType = ObjCBuiltInFunctions.objectBase.gen(w);
-
     final superTypeIsInPkgObjc = superType == null;
 
-    // Class declaration.
-    s.write('''class $name extends ${superType?.getDartType(w) ?? wrapObjType} {
+    s.write('''
+class $name extends ${superType?.getDartType(w) ?? wrapObjType} {
   $name._($rawObjType pointer,
       {bool retain = false, bool release = false}) :
           ${superTypeIsInPkgObjc ? 'super' : 'super.castFromPointer'}
@@ -88,6 +87,30 @@ class ObjCInterface extends BindingType with ObjCMethods {
       {bool retain = false, bool release = false}) :
       this._(other, retain: retain, release: release);
 
+${generateAsStub ? '' : _generateMethods(w)}
+}
+
+''');
+
+    return BindingString(
+        type: BindingStringType.objcInterface, string: s.toString());
+  }
+
+  String _generateMethods(Writer w) {
+    String paramsToString(List<Parameter> params) {
+      final stringParams = <String>[
+        for (final p in params)
+          '${_getConvertedType(p.type, w, name)} ${p.name}',
+      ];
+      return '(${stringParams.join(", ")})';
+    }
+
+    final methodNamer = createMethodRenamer(w);
+    final wrapObjType = ObjCBuiltInFunctions.objectBase.gen(w);
+    final s = StringBuffer();
+
+    // Class declaration.
+    s.write('''
   /// Returns whether [obj] is an instance of [$name].
   static bool isInstance($wrapObjType obj) {
     return ${_isKindOfClassMsgSend.invoke(
@@ -215,10 +238,7 @@ class ObjCInterface extends BindingType with ObjCMethods {
       s.write('\n  }\n');
     }
 
-    s.write('}\n\n');
-
-    return BindingString(
-        type: BindingStringType.objcInterface, string: s.toString());
+    return s.toString();
   }
 
   @override

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

@@ -16,6 +16,8 @@ class PointerType extends Type {
   factory PointerType(Type child) {
     if (child == objCObjectType) {
       return ObjCObjectPointer();
+    } else if (child == objCBlockType) {
+      return ObjCBlockPointer();
     }
     return PointerType._(child);
   }
@@ -108,6 +110,7 @@ class ObjCObjectPointer extends PointerType {
   factory ObjCObjectPointer() => _inst;
 
   static final _inst = ObjCObjectPointer._();
+  ObjCObjectPointer.__(super.child) : super._();
   ObjCObjectPointer._() : super._(objCObjectType);
 
   @override
@@ -143,3 +146,17 @@ class ObjCObjectPointer extends PointerType {
   @override
   String? generateRetain(String value) => 'objc_retain($value)';
 }
+
+/// A pointer to an Objective C block.
+class ObjCBlockPointer extends ObjCObjectPointer {
+  factory ObjCBlockPointer() => _inst;
+
+  static final _inst = ObjCBlockPointer._();
+  ObjCBlockPointer._() : super.__(objCBlockType);
+
+  @override
+  String getDartType(Writer w) => '${w.objcPkgPrefix}.ObjCBlockBase';
+
+  @override
+  String? generateRetain(String value) => 'objc_retainBlock($value)';
+}

pkgs/ffigen/lib/src/config_provider/config.dart

@@ -78,6 +78,18 @@ abstract interface class Config {
   /// If enabled, unused typedefs will also be generated.
   bool get includeUnusedTypedefs;
 
+  /// If enabled, Objective C interfaces that are not explicitly included by
+  /// the [DeclarationFilters], but are transitively included by other bindings,
+  /// will be code-genned as if they were included. If disabled, these
+  /// transitively included interfaces will be generated as stubs instead.
+  bool get includeTransitiveObjCInterfaces;
+
+  /// If enabled, Objective C protocols that are not explicitly included by
+  /// the [DeclarationFilters], but are transitively included by other bindings,
+  /// will be code-genned as if they were included. If disabled, these
+  /// transitively included protocols will not be generated at all.
+  bool get includeTransitiveObjCProtocols;
+
   /// Undocumented option that changes code generation for package:objective_c.
   /// The main difference is whether NSObject etc are imported from
   /// package:objective_c (the default) or code genned like any other class.
@@ -195,6 +207,8 @@ abstract interface class Config {
     DeclarationFilters? objcInterfaces,
     DeclarationFilters? objcProtocols,
     bool includeUnusedTypedefs = false,
+    bool includeTransitiveObjCInterfaces = false,
+    bool includeTransitiveObjCProtocols = false,
     bool generateForPackageObjectiveC = false,
     bool sort = false,
     bool useSupportedTypedefs = true,
@@ -250,6 +264,8 @@ abstract interface class Config {
         objcInterfaces: objcInterfaces ?? DeclarationFilters.excludeAll,
         objcProtocols: objcProtocols ?? DeclarationFilters.excludeAll,
         includeUnusedTypedefs: includeUnusedTypedefs,
+        includeTransitiveObjCInterfaces: includeTransitiveObjCInterfaces,
+        includeTransitiveObjCProtocols: includeTransitiveObjCProtocols,
         generateForPackageObjectiveC: generateForPackageObjectiveC,
         sort: sort,
         useSupportedTypedefs: useSupportedTypedefs,

pkgs/ffigen/lib/src/config_provider/config_impl.dart

@@ -76,6 +76,12 @@ class ConfigImpl implements Config {
   @override
   final bool includeUnusedTypedefs;
 
+  @override
+  final bool includeTransitiveObjCInterfaces;
+
+  @override
+  final bool includeTransitiveObjCProtocols;
+
   @override
   final bool generateForPackageObjectiveC;
 
@@ -198,6 +204,8 @@ class ConfigImpl implements Config {
     required this.objcInterfaces,
     required this.objcProtocols,
     required this.includeUnusedTypedefs,
+    required this.includeTransitiveObjCInterfaces,
+    required this.includeTransitiveObjCProtocols,
     required this.generateForPackageObjectiveC,
     required this.sort,
     required this.useSupportedTypedefs,

pkgs/ffigen/lib/src/config_provider/yaml_config.dart

@@ -137,6 +137,22 @@ class YamlConfig implements Config {
   bool get includeUnusedTypedefs => _includeUnusedTypedefs;
   late bool _includeUnusedTypedefs;
 
+  /// If enabled, Objective C interfaces that are not explicitly included by
+  /// the [DeclarationFilters], but are transitively included by other bindings,
+  /// will be code-genned as if they were included. If disabled, these
+  /// transitively included interfaces will be generated as stubs instead.
+  @override
+  bool get includeTransitiveObjCInterfaces => _includeTransitiveObjCInterfaces;
+  late bool _includeTransitiveObjCInterfaces;
+
+  /// If enabled, Objective C protocols that are not explicitly included by
+  /// the [DeclarationFilters], but are transitively included by other bindings,
+  /// will be code-genned as if they were included. If disabled, these
+  /// transitively included protocols will not be generated at all.
+  @override
+  bool get includeTransitiveObjCProtocols => _includeTransitiveObjCProtocols;
+  late bool _includeTransitiveObjCProtocols;
+
   /// Undocumented option that changes code generation for package:objective_c.
   /// The main difference is whether NSObject etc are imported from
   /// package:objective_c (the default) or code genned like any other class.
@@ -753,6 +769,20 @@ class YamlConfig implements Config {
           resultOrDefault: (node) =>
               _includeUnusedTypedefs = node.value as bool,
         ),
+        HeterogeneousMapEntry(
+          key: strings.includeTransitiveObjCInterfaces,
+          valueConfigSpec: BoolConfigSpec(),
+          defaultValue: (node) => false,
+          resultOrDefault: (node) =>
+              _includeTransitiveObjCInterfaces = node.value as bool,
+        ),
+        HeterogeneousMapEntry(
+          key: strings.includeTransitiveObjCProtocols,
+          valueConfigSpec: BoolConfigSpec(),
+          defaultValue: (node) => false,
+          resultOrDefault: (node) =>
+              _includeTransitiveObjCProtocols = node.value as bool,
+        ),
         HeterogeneousMapEntry(
           key: strings.generateForPackageObjectiveC,
           valueConfigSpec: BoolConfigSpec(),