[jnigen] filter out Kotlin DefaultConstructorMarker from Dart bindings

pkgs/jnigen/CHANGELOG.md

@@ -3,6 +3,8 @@
 - Add docs about debugging.
 - Add support for Kotlin interfaces with suspend functions. These can now be
   implemented using Dart functions that return a `Future`.
+- Fixed a bug where Kotlin's `DefaultConstructorMarker` was exposed in the
+  generated bindings.
 - Namespace primitive types to avoid collisions with generated API names, eg
   `bool`.
 - Kotlin suspend functions with no result (a return type of `Unit`) now return

pkgs/jnigen/lib/src/bindings/dart_generator.dart

@@ -864,6 +864,10 @@ class _TypeGenerator extends TypeVisitor<String> {
       },
     );
 
+    if (!node.classDecl.isRenamed) {
+      // The class is not generated, fall back to `JObject`.
+      return super.visitDeclaredType(node);
+    }
     final typeParams = allTypeParams.join(', ').encloseIfNotEmpty('<', '>');
     final prefix = resolver?.resolvePrefix(node.classDecl) ?? '';
     return '$prefix${node.classDecl.finalName}$typeParams$nullable';
@@ -1393,7 +1397,9 @@ ${modifier}final _$name = $_protectedExtension
     } else {
       s.writeAll(node.modifiers.map((m) => '$m '));
       s.write('${node.returnType} ${node.name}(');
-      s.writeAll(node.params.map((p) => '${p.type} ${p.name}'), ', ');
+      // Filter out Kotlin synthetic params from documentation.
+      final docParams = node.params.where((p) => !p.isKotlinSynthetic);
+      s.writeAll(docParams.map((p) => '${p.type} ${p.name}'), ', ');
       s.writeln(')`');
     }
     if (node.returnType is! PrimitiveType || node.isConstructor) {
@@ -1402,7 +1408,9 @@ ${modifier}final _$name = $_protectedExtension
     node.javadoc?.accept(_DocGenerator(s, depth: 1));
 
     // Used for inferring the type parameter from the given parameters.
+    // Exclude Kotlin synthetic params since they're not part of the Dart API.
     final typeLocators = node.params
+        .where((p) => !p.isKotlinSynthetic)
         .accept(_ParamTypeLocator(resolver: resolver))
         .fold(<String, List<String>>{}, _mergeMapValues).map(
       (key, value) =>
@@ -1424,15 +1432,22 @@ ${modifier}final _$name = $_protectedExtension
             .join(_newLine(depth: 2));
     // This is needed to keep the references alive in the scope while waiting
     // for the FFI call.
+    // Filter out Kotlin synthetic params from local references since they're
+    // not part of the Dart API.
     final localReferences = node.params
+        .where((p) => !p.isKotlinSynthetic)
         .accept(const _ParamReference())
         .where((ref) => ref.isNotEmpty)
         .toList();
     if (node.isConstructor) {
       final className = node.classDecl.finalName;
       final name = node.finalName;
       final ctorName = name == 'new\$' ? className : '$className.$name';
-      final paramsDef = node.params.accept(_ParamDef(resolver)).delimited(', ');
+      // Filter out Kotlin synthetic params from the Dart API signature.
+      final dartApiParams =
+          node.params.where((p) => !p.isKotlinSynthetic).toList();
+      final paramsDef =
+          dartApiParams.accept(_ParamDef(resolver)).delimited(', ');
       final typeParamsCall = node.classDecl.allTypeParams
           .map((typeParam) => '$_typeParamPrefix${typeParam.name}')
           .join(', ')
@@ -1705,6 +1720,12 @@ class _ParamCall extends Visitor<Param, String> {
 
   @override
   String visit(Param node) {
+    // Kotlin synthetic parameters (e.g., DefaultConstructorMarker) should
+    // always receive jNullReference in JNI calls.
+    if (node.isKotlinSynthetic) {
+      return '$_jni.jNullReference.pointer';
+    }
+
     final nativeSuffix = node.type.accept(const _ToNativeSuffix());
     final nonPrimitive = node.type is PrimitiveType ? '' : r'_$';
     final paramCall = '$nonPrimitive${node.finalName}$nativeSuffix';

pkgs/jnigen/lib/src/bindings/excluder.dart

@@ -67,8 +67,19 @@ class _ClassExcluder extends Visitor<ClassDecl, void> {
       final isPrivate = method.isPrivate;
       final isAbstractCtor = method.isConstructor && node.isAbstract;
       final isBridgeMethod = method.isSynthetic && method.isBridge;
-      final excluded =
-          isPrivate || isAbstractCtor || isBridgeMethod || isExcluded;
+
+      // Exclude synthetic Kotlin constructors with DefaultConstructorMarker.
+      // These are compiler-generated overloads for default parameters and
+      // should not be exposed in the Dart API.
+      final isSyntheticDefaultCtorMarker = method.isConstructor &&
+          method.isSynthetic &&
+          method.params.any((param) => param.isKotlinSynthetic);
+
+      final excluded = isPrivate ||
+          isAbstractCtor ||
+          isBridgeMethod ||
+          isSyntheticDefaultCtorMarker ||
+          isExcluded;
       if (excluded) {
         log.fine('Excluded method ${node.binaryName}#${method.name}');
       }

pkgs/jnigen/lib/src/bindings/kotlin_processor.dart

@@ -116,6 +116,17 @@ class _KotlinClassProcessor extends Visitor<ClassDecl, void> {
         method.accept(_KotlinGetterProcessor(getter));
       } else if (setters[signature] case final setter?) {
         method.accept(_KotlinSetterProcessor(setter));
+      } else {
+        if (method.isConstructor && method.isSynthetic) {
+          for (final param in method.params) {
+            if (param.type case final DeclaredType type) {
+              if (type.binaryName ==
+                  'kotlin.jvm.internal.DefaultConstructorMarker') {
+                param.isKotlinSynthetic = true;
+              }
+            }
+          }
+        }
       }
     }
   }
@@ -179,6 +190,17 @@ class _KotlinConstructorProcessor extends Visitor<Method, void> {
   @override
   void visit(Method node) {
     _processParams(node.params, constructor.valueParameters);
+
+    // Mark DefaultConstructorMarker parameters as Kotlin synthetic.
+    // These are compiler-generated parameters for constructors with default
+    // values and should not be exposed in the Dart API.
+    for (final param in node.params) {
+      if (param.type case final DeclaredType type) {
+        if (type.binaryName == 'kotlin.jvm.internal.DefaultConstructorMarker') {
+          param.isKotlinSynthetic = true;
+        }
+      }
+    }
   }
 }
 

pkgs/jnigen/lib/src/bindings/renamer.dart

@@ -165,11 +165,16 @@ class _ClassRenamer implements Visitor<ClassDecl, void> {
 
   _ClassRenamer(
     this.config,
-  ) : renamed = {...config.importedClasses.values};
+  ) : renamed = {...config.importedClasses.values} {
+    for (final node in renamed) {
+      node.isRenamed = true;
+    }
+  }
 
   @override
   void visit(ClassDecl node) {
     if (renamed.contains(node)) return;
+    node.isRenamed = true;
     log.finest('Renaming ${node.binaryName}.');
     renamed.add(node);
 

pkgs/jnigen/lib/src/elements/elements.dart

@@ -20,9 +20,9 @@ enum GenerationStage {
   // `../generate_bindings.dart`.
   unprocessed,
   userVisitors,
-  excluder,
   kotlinProcessor,
   linker,
+  excluder,
   renamer,
   dartGenerator;
 
@@ -141,10 +141,12 @@ class ClassDecl with ClassMember, Annotated implements Element<ClassDecl> {
   /// Final name of this class.
   ///
   /// Populated by [Renamer].
-  @JsonKey(includeFromJson: false)
   @override
   late String finalName;
 
+  @JsonKey(includeFromJson: false)
+  bool isRenamed = false;
+
   /// Name of the type class.
   @JsonKey(includeFromJson: false)
   String get typeClassName => '\$$finalName\$Type\$';
@@ -830,6 +832,16 @@ class Param with Annotated implements Element<Param> {
   @JsonKey(includeFromJson: false)
   late String finalName;
 
+  /// Whether this parameter is a Kotlin synthetic parameter
+  /// (e.g., DefaultConstructorMarker).
+  ///
+  /// These parameters should be hidden from the generated Dart API but still
+  /// passed to the JNI constructor (as jNullReference).
+  ///
+  /// Populated by [KotlinProcessor].
+  @JsonKey(includeFromJson: false)
+  bool isKotlinSynthetic = false;
+
   factory Param.fromJson(Map<String, dynamic> json) => _$ParamFromJson(json);
 
   Param clone({GenerationStage until = GenerationStage.userVisitors}) {
@@ -842,6 +854,9 @@ class Param with Annotated implements Element<Param> {
     if (GenerationStage.linker <= until) {
       cloned.method = method;
     }
+    if (GenerationStage.kotlinProcessor <= until) {
+      cloned.isKotlinSynthetic = isKotlinSynthetic;
+    }
     if (GenerationStage.renamer <= until) {
       cloned.finalName = finalName;
     }

pkgs/jnigen/lib/src/generate_bindings.dart

@@ -51,9 +51,9 @@ Future<void> generateJniBindings(Config config) async {
     return classes.accept(visitor);
   }
 
-  runStage(Excluder(config));
   runStage(KotlinProcessor());
   await runStage(Linker(config));
+  runStage(Excluder(config));
   runStage(Renamer(config));
   // classes.accept(const Printer());