[WIP] [cxx-interop] Import default/trivial ctors of C++ foreign ref types as Swift Initializer

Author: fahadnayyar

lib/ClangImporter/ImportDecl.cpp

@@ -2041,6 +2041,101 @@ namespace {
       fd->getAttrs().add(new (Impl.SwiftContext) UnsafeAttr(/*Implicit=*/true));
     }
 
+    void
+    generateStaticFactoryForCXXForeignRef(clang::ASTContext &clangCtx,
+                                          ClassDecl *result,
+                                          clang::CXXRecordDecl *cxxRecordDecl,
+                                          ClangImporter::Implementation &Impl) {
+
+      // Creating a name for the new synthesized function
+      clang::IdentifierTable &idents = clangCtx.Idents;
+      clang::IdentifierInfo *generatedFuncName =
+          &idents.get(("__returns" + cxxRecordDecl->getNameAsString()).c_str());
+
+      // Creating the return type for the synthesized function to be the
+      // pointe to cxxRecordDecl
+      const clang::Type *cxxRecordDeclTypePtr = cxxRecordDecl->getTypeForDecl();
+      clang::QualType cxxRecordTy(cxxRecordDeclTypePtr, 0);
+      clang::QualType cxxRecordPtrTy = clangCtx.getPointerType(cxxRecordTy);
+      // TODO/DOUBT: How to add `_Nonnull` as a qualifier on cxxRecordPtrTy
+      // return type ??
+
+      // Creating the type for the synthesized function
+      clang::FunctionProtoType::ExtProtoInfo EPI;
+      clang::QualType generatedFuncTy =
+          clangCtx.getFunctionType(cxxRecordPtrTy, {}, EPI);
+
+      clang::CXXMethodDecl *generatedCxxMethodDecl =
+          clang::CXXMethodDecl::Create(
+              clangCtx, cxxRecordDecl, cxxRecordDecl->getLocation(),
+              clang::DeclarationNameInfo(generatedFuncName,
+                                         clang::SourceLocation()),
+              generatedFuncTy, nullptr, clang::SC_Static, false, true,
+              clang::ConstexprSpecKind::Unspecified, clang::SourceLocation());
+
+      // Create and attach "returns_retained" attribute to synthesized method
+      clang::SwiftAttrAttr *returnsRetainedAttr =
+          clang::SwiftAttrAttr::Create(clangCtx, "returns_retained");
+      generatedCxxMethodDecl->addAttr(returnsRetainedAttr);
+
+      // Create and attach "swift_name("init()")" attribute to synthesized
+      // method
+      clang::SwiftNameAttr *swiftNameInitAttr =
+          clang::SwiftNameAttr::Create(clangCtx, "init()");
+      generatedCxxMethodDecl->addAttr(swiftNameInitAttr);
+
+      // Set the access specifier of the generated factory method to public
+      generatedCxxMethodDecl->setAccess(clang::AccessSpecifier::AS_public);
+
+      // Getting the default constructor
+      clang::CXXConstructorDecl *ctorDecl = nullptr;
+      for (clang::CXXConstructorDecl *ctor : cxxRecordDecl->ctors()) {
+        if (ctor->isDefaultConstructor() && !ctor->isDeleted()) {
+          ctorDecl = ctor;
+          break;
+        }
+      }
+
+      if (ctorDecl) {
+        // Build the constructor expression using the default constructor decl
+        clang::ExprResult generatedConstructExpr =
+            Impl.getClangSema().BuildCXXConstructExpr(
+                clang::SourceLocation(), cxxRecordTy, ctorDecl, false,
+                clang::MultiExprArg(), false, false, false,
+                true, // TODO: fix the propagation of this zeroinit flag to
+                      // BuildCXXNew
+                clang::CXXConstructionKind::Complete, clang::SourceRange());
+
+        if (!generatedConstructExpr.isInvalid()) {
+          // Build the new expr by passing the constructor expression as an
+          // initializer
+          clang::ExprResult generatedNewExprResult =
+              Impl.getClangSema().BuildCXXNew(
+                  clang::SourceRange(), false, clang::SourceLocation(), {},
+                  clang::SourceLocation(), clang::SourceRange(), cxxRecordTy,
+                  clangCtx.getTrivialTypeSourceInfo(cxxRecordTy), std::nullopt,
+                  clang::SourceRange(), generatedConstructExpr.get());
+
+          if (!generatedNewExprResult.isInvalid()) {
+            // synthesizing the body of the generatedCxxMethodDecl
+            clang::CXXNewExpr *generatedNewExpr =
+                cast<clang::CXXNewExpr>(generatedNewExprResult.get());
+            clang::ReturnStmt *generatedRetStmt = clang::ReturnStmt::Create(
+                clangCtx, clang::SourceLocation(), generatedNewExpr, nullptr);
+            clang::CompoundStmt *generatedFuncBody =
+                clang::CompoundStmt::Create(
+                    clangCtx, {generatedRetStmt}, clang::FPOptionsOverride(),
+                    clang::SourceLocation(), clang::SourceLocation());
+            generatedCxxMethodDecl->setBody(generatedFuncBody);
+            // generatedCxxMethodDecl->dump();
+            if (Decl *importedInitDecl =
+                    VisitCXXMethodDecl(generatedCxxMethodDecl))
+              result->addMember(importedInitDecl);
+          }
+        }
+      }
+    }
+
     Decl *VisitRecordDecl(const clang::RecordDecl *decl) {
       // Track whether this record contains fields we can't reference in Swift
       // as stored properties.
@@ -2472,14 +2567,25 @@ namespace {
         ctors.push_back(valueCtor);
       }
 
-      // Do not allow Swift to construct foreign reference types (at least, not
-      // yet).
       if (isa<StructDecl>(result)) {
         for (auto ctor : ctors) {
           // Add ctors directly as they cannot always be looked up from the
           // clang decl (some are synthesized by Swift).
           result->addMember(ctor);
         }
+      } else {
+        assert(isa<ClassDecl>(result) && "Expected result to be a ClassDecl "
+                                         "for C/C++ foreign reference types");
+        if (auto *cxxRecordDecl = const_cast<clang::CXXRecordDecl *>(
+                dyn_cast<clang::CXXRecordDecl>(decl))) {
+          // For C++ foreign reference types, generate a static factory method
+          // to construct the object and import it as a Swift initializer.
+          generateStaticFactoryForCXXForeignRef(cxxRecordDecl->getASTContext(),
+              cast<ClassDecl>(result), cxxRecordDecl, Impl);
+        } else {
+          // TODO: Should we synthesize the factories for C foreign reference
+          // types as well?
+        }
       }
 
       if (auto structResult = dyn_cast<StructDecl>(result)) {

test/Interop/Cxx/class/Inputs/constructors.h

@@ -176,4 +176,24 @@ class Value {
   int x;
 };
 
+namespace DefaultCtor {
+  struct 
+    __attribute__((swift_attr("import_reference")))
+    __attribute__((swift_attr("retain:retain")))
+    __attribute__((swift_attr("release:release")))
+  CxxRefTy{
+    public:
+    int val = 2;
+    // TODO: resolve the conflict b/w swift_name("init()") and synthesized function
+    // __attribute__((swift_name("init()")))
+    // __attribute__((swift_attr("returns_retained")))
+    // static CxxRefTy * _Nonnull returnsCxxRefTy() {
+    //   return new CxxRefTy{};
+    // }
+  };
+}
+
+void retain(DefaultCtor::CxxRefTy * _Nonnull v) {};
+void release(DefaultCtor::CxxRefTy * _Nonnull v) {};
+
 #endif // TEST_INTEROP_CXX_CLASS_INPUTS_CONSTRUCTORS_H

test/Interop/Cxx/class/constructors-executable.swift

@@ -88,4 +88,10 @@ CxxConstructorTestSuite.test("ImportStaticFactoryAsInitializer") {
   expectEqual(v.getX(), 2)
 }
 
+ForeignRefCtorSuite.test("SynthesizeAndImportStaticFactoryAsInitializer") {
+  let x = DefaultCtor.CxxRefTy()
+  // TODO: make this non optional   
+  expectEqual(x!.val, 2)
+}
+
 runAllTests()