[ffigen] feat: generate cpp class constructor bindings (#3395)

Author: Hassnaa9

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

@@ -16,7 +16,7 @@ enum CppMethodKind { constructor, destructor, method }
 
 /// A method or constructor belonging to a C++ class.
 class CppMethod extends AstNode with HasLocalScope {
-  final String name;
+  final Symbol name;
   final String originalName;
   final Type returnType;
   final List<Parameter> parameters;
@@ -34,15 +34,16 @@ class CppMethod extends AstNode with HasLocalScope {
     this.kind = CppMethodKind.method,
   });
 
-  bool get isConstructor => kind == CppMethodKind.constructor;
-  bool get isDestructor => kind == CppMethodKind.destructor;
+  bool get isConstructor => kind == .constructor;
+  bool get isDestructor => kind == .destructor;
 
   @override
   void visit(Visitation visitation) => visitation.visitCppMethod(this);
 
   @override
   void visitChildren(Visitor visitor) {
     super.visitChildren(visitor);
+    visitor.visit(name);
     visitor.visit(returnType);
     visitor.visitAll(parameters);
   }
@@ -100,9 +101,12 @@ class CppClass extends BindingType with HasLocalScope {
 
     final ptrVoid = '$ffiPrefix.Pointer<$ffiPrefix.Void>';
 
-    final classMethods = methods
-        .where((m) => m.kind == CppMethodKind.method)
-        .toList();
+    // Helper to build a comma-separated Dart parameter list.
+    String dartParamList(Iterable<Parameter> params) =>
+        params.map((p) => '${p.type.getDartType(ctx)} ${p.name}').join(', ');
+
+    final classMethods = methods.where((m) => m.kind == .method).toList();
+    final constructors = methods.where((m) => m.kind == .constructor).toList();
 
     s.write(makeDartDoc(dartDoc));
     s.write('''
@@ -113,12 +117,39 @@ class $name {
   $name._(this._ptr);
 ''');
 
+    for (final ctor in constructors) {
+      final glueName = ctor.name.name;
+      final privateName = '_$glueName';
+
+      final dartParams = dartParamList(ctor.parameters);
+
+      final localVars = LocalVariables(ctor.localScope);
+      final callArgs = ctor.parameters
+          .map(
+            (p) => p.type.sameDartAndFfiDartType
+                ? p.name
+                : p.type.convertDartTypeToFfiDartType(
+                    ctx,
+                    p.name,
+                    objCRetain: false,
+                    objCAutorelease: false,
+                    localVariables: localVars,
+                  ),
+          )
+          .join(', ');
+
+      s.write('''
+  factory $name($dartParams) {
+    ${localVars.generateDeclarations()}
+    return $name._($privateName($callArgs));
+  }
+''');
+    }
+
     for (final method in classMethods) {
-      final glue = '_${name}_${method.name}';
+      final glue = '_${method.name.name}';
       final dartReturn = method.returnType.getDartType(ctx);
-      final dartParams = method.parameters
-          .map((p) => '${p.type.getDartType(ctx)} ${p.name}')
-          .join(', ');
+      final dartParams = dartParamList(method.parameters);
 
       final callArgs = [
         if (!method.isStatic) '_ptr',
@@ -127,14 +158,14 @@ class $name {
 
       final staticKeyword = method.isStatic ? 'static ' : '';
       s.write(
-        '  $staticKeyword$dartReturn ${method.name}($dartParams)'
+        '  $staticKeyword$dartReturn ${method.originalName}($dartParams)'
         ' => $glue($callArgs);\n',
       );
     }
     s.write('}\n');
 
     for (final method in classMethods) {
-      final symbol = '${name}_${method.name}';
+      final symbol = method.name.name;
       final glue = '_$symbol';
 
       final cReturn = method.returnType.getCType(ctx);
@@ -157,12 +188,36 @@ class $name {
           w,
           nativeType: cType,
           dartName: glue,
-          nativeSymbolName: symbol,
+          nativeSymbolName: Namer.cSafeName(symbol),
         ),
       );
       s.write('\nexternal $ffiReturn $glue($ffiParams);\n\n');
     }
 
+    for (final ctor in constructors) {
+      final symbol = ctor.name.name;
+      final glue = '_$symbol';
+
+      final paramCTypes = ctor.parameters
+          .map((p) => p.type.getCType(ctx))
+          .join(', ');
+      final cType = '$ptrVoid Function($paramCTypes)';
+
+      final ffiParams = ctor.parameters
+          .map((p) => '${p.type.getFfiDartType(ctx)} ${p.name}')
+          .join(', ');
+
+      s.write(
+        makeNativeAnnotation(
+          w,
+          nativeType: cType,
+          dartName: glue,
+          nativeSymbolName: Namer.cSafeName(symbol),
+        ),
+      );
+      s.write('\nexternal $ptrVoid $glue($ffiParams);\n\n');
+    }
+
     return BindingString(
       type: BindingStringType.cppClass,
       string: s.toString(),

pkgs/ffigen/lib/src/header_parser/sub_parsers/classdecl_parser.dart

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import '../../code_generator.dart';
+import '../../code_generator/scope.dart';
 import '../../config_provider/config_types.dart';
 import '../../context.dart';
 import '../clang_bindings/clang_bindings.dart' as clang_types;
@@ -29,7 +30,7 @@ CppClass? parseClassDeclaration(Context context, clang_types.CXCursor cursor) {
   // Use the libclang API to detect anonymous classes reliably.
   final String className;
   if (clang.clang_Cursor_isAnonymous(cursor) == 0) {
-    className = usr.split('@').last;
+    className = cursor.spelling();
   } else {
     logger.fine('Skipping anonymous C++ class.');
     return null;
@@ -58,6 +59,8 @@ CppClass? parseClassDeclaration(Context context, clang_types.CXCursor cursor) {
     final kind = clang.clang_getCursorKind(child);
     if (kind == clang_types.CXCursorKind.CXCursor_CXXMethod) {
       _parseMethod(context, child, decl, methods);
+    } else if (kind == clang_types.CXCursorKind.CXCursor_Constructor) {
+      _parseConstructor(context, child, decl, methods);
     }
   });
 
@@ -105,9 +108,11 @@ void _parseMethod(
   }
 
   logger.fine('  ++++ Method: $methodName (const=$isConst)');
+  final cppClasses = context.config.cpp!.classes;
+  final className = cppClasses.rename(classDecl);
   methods.add(
     CppMethod(
-      name: methodName,
+      name: Symbol('${className}_$methodName', SymbolKind.method),
       originalName: methodName,
       returnType: returnType,
       parameters: parameters,
@@ -136,3 +141,30 @@ List<Parameter>? _parseParameters(
   }
   return parsed.parameters;
 }
+
+void _parseConstructor(
+  Context context,
+  clang_types.CXCursor cursor,
+  Declaration classDecl,
+  List<CppMethod> methods,
+) {
+  final constructorName = cursor.spelling();
+  final returnType = clang
+      .clang_getCursorResultType(cursor)
+      .toCodeGenType(context);
+  final parameters = _parseParameters(context, cursor, classDecl);
+  if (parameters == null) return;
+  final cppClasses = context.config.cpp!.classes;
+  final className = cppClasses.rename(classDecl);
+  methods.add(
+    CppMethod(
+      name: Symbol('${className}_new', SymbolKind.method),
+      originalName: constructorName,
+      returnType: returnType,
+      parameters: parameters,
+      isConstant: false,
+      isStatic: false,
+      kind: CppMethodKind.constructor,
+    ),
+  );
+}

pkgs/ffigen/lib/src/visitor/create_scopes.dart

@@ -74,7 +74,8 @@ class CreateScopesVisitation extends Visitation {
       visitHasLocalScope(node, 'objc_msgSend');
 
   @override
-  void visitCppMethod(CppMethod node) => visitHasLocalScope(node, node.name);
+  void visitCppMethod(CppMethod node) =>
+      visitHasLocalScope(node, node.name.oldName);
 
   static const objCReservedMethods = {
     'ref',

pkgs/ffigen/lib/src/visitor/find_symbols.dart

@@ -84,8 +84,10 @@ class FindSymbolsVisitation extends Visitation {
       visitInsideScope(node, node.localScope);
 
   @override
-  void visitCppMethod(CppMethod node) =>
-      visitInsideScope(node, node.localScope);
+  void visitCppMethod(CppMethod node) {
+    currentScope.add(node.name);
+    visitInsideScope(node, node.localScope);
+  }
 
   @override
   void visitObjCMethod(ObjCMethod node) => insideScope(

pkgs/ffigen/test/native_cpp_test/cpp_class_test_bindings.dart

@@ -9,6 +9,9 @@ class Animal {
   final ffi.Pointer<ffi.Void> _ptr;
 
   Animal._(this._ptr);
+  factory Animal(int age) {
+    return Animal._(_Animal_new(age));
+  }
   void speak() => _Animal_speak(_ptr);
   int getAge() => _Animal_getAge(_ptr);
   static int getCount() => _Animal_getCount();
@@ -22,3 +25,6 @@ external int _Animal_getAge(ffi.Pointer<ffi.Void> self);
 
 @ffi.Native<ffi.Int Function()>(symbol: 'Animal_getCount')
 external int _Animal_getCount();
+
+@ffi.Native<ffi.Pointer<ffi.Void> Function(ffi.Int)>(symbol: 'Animal_new')
+external ffi.Pointer<ffi.Void> _Animal_new(int age);