[cxx-interop] Import default ctor of C++ foreign ref types as Swift Initializer

rdar://147529406

Author: fahadnayyar

include/swift/Basic/Features.def

@@ -464,6 +464,10 @@ EXPERIMENTAL_FEATURE(AssumeResilientCxxTypes, true)
 /// Import inherited non-public members when importing C++ classes.
 EXPERIMENTAL_FEATURE(ImportNonPublicCxxMembers, true)
 
+/// Synthesize static factory methods for C++ foreign reference types and import
+/// them as Swift initializers.
+EXPERIMENTAL_FEATURE(CXXForeignReferenceTypeInitializers, true)
+
 // Isolated deinit
 SUPPRESSIBLE_LANGUAGE_FEATURE(IsolatedDeinit, 371, "isolated deinit")
 

lib/AST/FeatureSet.cpp

@@ -392,6 +392,7 @@ UNINTERESTING_FEATURE(StrictMemorySafety)
 UNINTERESTING_FEATURE(SafeInteropWrappers)
 UNINTERESTING_FEATURE(AssumeResilientCxxTypes)
 UNINTERESTING_FEATURE(ImportNonPublicCxxMembers)
+UNINTERESTING_FEATURE(CXXForeignReferenceTypeInitializers)
 UNINTERESTING_FEATURE(CoroutineAccessorsUnwindOnCallerError)
 
 static bool usesFeatureSwiftSettings(const Decl *decl) {

lib/ClangImporter/ImportDecl.cpp

@@ -2472,14 +2472,48 @@ 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 {
+        if (Impl.SwiftContext.LangOpts.hasFeature(
+                Feature::CXXForeignReferenceTypeInitializers)) {
+          assert(isa<ClassDecl>(result) && "Expected result to be a ClassDecl "
+                                           "for C/C++ foreign reference types");
+          // When we add full support for C foreign reference types then we
+          // should synthesize static factories for them as well
+          if (auto *cxxRecordDecl = const_cast<clang::CXXRecordDecl *>(
+                  dyn_cast<clang::CXXRecordDecl>(decl))) {
+            bool hasUserProvidedStaticFactory = false;
+            for (const auto *method : cxxRecordDecl->methods()) {
+              if (method->isStatic()) {
+                for (const auto *attr :
+                     method->specific_attrs<clang::SwiftNameAttr>()) {
+                  std::string attributeName = attr->getName().str();
+                  if (attributeName.find("init") != std::string::npos) {
+                    hasUserProvidedStaticFactory = true;
+                    break;
+                  }
+                }
+              }
+              if (hasUserProvidedStaticFactory)
+                break;
+            }
+            if (!hasUserProvidedStaticFactory) {
+              if (auto generatedCxxMethodDecl = SwiftDeclSynthesizer::
+                      synthesizeStaticFactoryForCXXForeignRef(
+                          cxxRecordDecl, cxxRecordDecl->getASTContext(),
+                          Impl.getClangSema())) {
+                if (Decl *importedInitDecl =
+                        VisitCXXMethodDecl(generatedCxxMethodDecl))
+                  result->addMember(importedInitDecl);
+              }
+            }
+          }
+        }
       }
 
       if (auto structResult = dyn_cast<StructDecl>(result)) {

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2529,3 +2529,131 @@ SwiftDeclSynthesizer::makeDefaultArgument(const clang::ParmVarDecl *param,
 
   return callExpr;
 }
+
+// MARK: C++ foreign reference type constructors
+
+clang::CXXMethodDecl *
+SwiftDeclSynthesizer::synthesizeStaticFactoryForCXXForeignRef(
+    clang::CXXRecordDecl *cxxRecordDecl, clang::ASTContext &clangCtx,
+    clang::Sema &clangSema) {
+
+  clang::QualType cxxRecordTy = clangCtx.getRecordType(cxxRecordDecl);
+
+  clang::FunctionDecl *operatorNew = nullptr;
+  clang::FunctionDecl *operatorDelete = nullptr;
+  bool passAlignment = false;
+  clangSema.FindAllocationFunctions(
+      cxxRecordDecl->getLocation(), clang::SourceRange(), clang::Sema::AFS_Both,
+      clang::Sema::AFS_Both, cxxRecordTy,
+      /*IsArray*/ false, passAlignment, clang::MultiExprArg(), operatorNew,
+      operatorDelete);
+  if (!operatorNew || operatorNew->isDeleted() ||
+      operatorNew->getAccess() == clang::AS_private ||
+      operatorNew->getAccess() == clang::AS_protected)
+    return nullptr;
+
+  clang::CXXConstructorDecl *defaultCtorDecl = nullptr;
+  for (clang::CXXConstructorDecl *ctor : cxxRecordDecl->ctors()) {
+    if (ctor->isDefaultConstructor() && !ctor->isDeleted() &&
+        ctor->getAccess() != clang::AS_private &&
+        ctor->getAccess() != clang::AS_protected) {
+      bool ctorHasDefaultArgs = false;
+      for (const clang::ParmVarDecl *ctorParam : ctor->parameters()) {
+        if (ctorParam->hasDefaultArg()) {
+          ctorHasDefaultArgs = true;
+        }
+      }
+      if (!ctorHasDefaultArgs) {
+        defaultCtorDecl = ctor;
+        break;
+      }
+    }
+  }
+  if (!defaultCtorDecl)
+    return nullptr;
+
+  clang::QualType cxxRecordPtrTy = clangCtx.getPointerType(cxxRecordTy);
+  // Adding `_Nonnull` to the return type of synthesized static factory
+  clangSema.CheckImplicitNullabilityTypeSpecifier(
+      cxxRecordPtrTy, clang::NullabilityKind::NonNull,
+      cxxRecordDecl->getLocation(),
+      /*isParam=*/false,
+      /*OverrideExisting=*/true);
+
+  clang::IdentifierTable &clangIdents = clangCtx.Idents;
+  clang::IdentifierInfo *funcNameToSynthesize = &clangIdents.get(
+      ("__returns_" + cxxRecordDecl->getNameAsString()).c_str());
+  clang::FunctionProtoType::ExtProtoInfo EPI;
+  clang::QualType funcTypeToSynthesize =
+      clangCtx.getFunctionType(cxxRecordPtrTy, {}, EPI);
+
+  clang::CXXMethodDecl *synthesizedCxxMethodDecl = clang::CXXMethodDecl::Create(
+      clangCtx, cxxRecordDecl, cxxRecordDecl->getLocation(),
+      clang::DeclarationNameInfo(funcNameToSynthesize,
+                                 cxxRecordDecl->getLocation()),
+      funcTypeToSynthesize, clangCtx.getTrivialTypeSourceInfo(cxxRecordTy),
+      clang::SC_Static,
+      /*UsesFPIntrin=*/false, /*isInline=*/true,
+      clang::ConstexprSpecKind::Unspecified, cxxRecordDecl->getLocation());
+  assert(synthesizedCxxMethodDecl &&
+         "Unable to synthesize static factory for c++ foreign reference type");
+  synthesizedCxxMethodDecl->setAccess(clang::AccessSpecifier::AS_public);
+
+  clang::SwiftAttrAttr *returnsRetainedAttrForSynthesizedCxxMethodDecl =
+      clang::SwiftAttrAttr::Create(clangCtx, "returns_retained");
+  synthesizedCxxMethodDecl->addAttr(
+      returnsRetainedAttrForSynthesizedCxxMethodDecl);
+  clang::SwiftNameAttr *swiftNameInitAttrForSynthesizedCxxMethodDecl =
+      clang::SwiftNameAttr::Create(clangCtx, "init()");
+  synthesizedCxxMethodDecl->addAttr(
+      swiftNameInitAttrForSynthesizedCxxMethodDecl);
+
+  clang::ExprResult synthesizedConstructExprResult =
+      clangSema.BuildCXXConstructExpr(
+          clang::SourceLocation(), cxxRecordTy, defaultCtorDecl,
+          /*Elidable=*/false, clang::MultiExprArg(),
+          /*HadMultipleCandidates=*/false,
+          /*IsListInitialization=*/false,
+          /*IsStdInitListInitialization=*/false,
+          /*RequiresZeroInit=*/false, clang::CXXConstructionKind::Complete,
+          clang::SourceRange());
+  assert(!synthesizedConstructExprResult.isInvalid() &&
+         "Unable to synthesize constructor expression for c++ foreign "
+         "reference type");
+  clang::CXXConstructExpr *synthesizedConstructExpr =
+      cast<clang::CXXConstructExpr>(synthesizedConstructExprResult.get());
+
+  clang::ExprResult synthesizedNewExprResult = clangSema.BuildCXXNew(
+      clang::SourceRange(), /*UseGlobal=*/false, clang::SourceLocation(), {},
+      clang::SourceLocation(), clang::SourceRange(), cxxRecordTy,
+      clangCtx.getTrivialTypeSourceInfo(cxxRecordTy), std::nullopt,
+      clang::SourceRange(), synthesizedConstructExpr);
+  assert(
+      !synthesizedNewExprResult.isInvalid() &&
+      "Unable to synthesize `new` expression for c++ foreign reference type");
+  clang::CXXNewExpr *synthesizedNewExpr =
+      cast<clang::CXXNewExpr>(synthesizedNewExprResult.get());
+
+  clang::ReturnStmt *synthesizedRetStmt =
+      clang::ReturnStmt::Create(clangCtx, clang::SourceLocation(),
+                                synthesizedNewExpr, /*VarDecl=*/nullptr);
+  assert(synthesizedRetStmt && "Unable to synthesize return statement for "
+                               "static factory of c++ foreign reference type");
+
+  clang::CompoundStmt *synthesizedFuncBody = clang::CompoundStmt::Create(
+      clangCtx, {synthesizedRetStmt}, clang::FPOptionsOverride(),
+      clang::SourceLocation(), clang::SourceLocation());
+  assert(synthesizedRetStmt && "Unable to synthesize function body for static "
+                               "factory of c++ foreign reference type");
+
+  synthesizedCxxMethodDecl->setBody(synthesizedFuncBody);
+  synthesizedCxxMethodDecl->addAttr(
+      clang::NoDebugAttr::CreateImplicit(clangCtx));
+
+  // Marking the synthesized factory as implicit and implicitly inline
+  synthesizedCxxMethodDecl->setImplicit();
+  synthesizedCxxMethodDecl->addAttr(
+      clang::AlwaysInlineAttr::CreateImplicit(clangCtx));
+
+  return synthesizedCxxMethodDecl;
+}

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -334,6 +334,14 @@ class SwiftDeclSynthesizer {
                                 const swift::Type &swiftParamTy,
                                 SourceLoc paramLoc);
 
+  /// Synthesize a static factory method for a C++ foreign reference type,
+  /// returning a `CXXMethodDecl*` or `nullptr` if the required constructor or
+  /// allocation function is not found.
+  static clang::CXXMethodDecl *
+  synthesizeStaticFactoryForCXXForeignRef(clang::CXXRecordDecl *cxxRecordDecl,
+                                          clang::ASTContext &clangCtx,
+                                          clang::Sema &clangSema);
+
 private:
   Type getConstantLiteralType(Type type, ConstantConvertKind convertKind);
 };

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

@@ -176,4 +176,16 @@ class Value {
   int x;
 };
 
+namespace SynthesizeDefaultCtorFactoryForCxxRefTy {
+struct __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:Retain")))
+__attribute__((swift_attr("release:Release"))) CxxRefTy {
+public:
+  int val = 2;
+};
+} // namespace SynthesizeDefaultCtorFactoryForCxxRefTy
+
+void Retain(SynthesizeDefaultCtorFactoryForCxxRefTy::CxxRefTy *_Nonnull v) {};
+void Release(SynthesizeDefaultCtorFactoryForCxxRefTy::CxxRefTy *_Nonnull v) {};
+
 #endif // TEST_INTEROP_CXX_CLASS_INPUTS_CONSTRUCTORS_H

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

@@ -1,9 +1,9 @@
-// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -enable-experimental-cxx-interop -Xfrontend -disable-availability-checking)
+// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -cxx-interoperability-mode=default -enable-experimental-feature CXXForeignReferenceTypeInitializers -Xfrontend -disable-availability-checking)
 //
 // REQUIRES: executable_test
 
-import StdlibUnittest
 import Constructors
+import StdlibUnittest
 
 var CxxConstructorTestSuite = TestSuite("CxxConstructors")
 
@@ -88,4 +88,11 @@ CxxConstructorTestSuite.test("ImportStaticFactoryAsInitializer") {
   expectEqual(v.getX(), 2)
 }
 
+CxxConstructorTestSuite.test("SynthesizeAndImportStaticFactoryAsInitializer") {
+  let x = SynthesizeDefaultCtorFactoryForCxxRefTy.CxxRefTy()
+  expectEqual(x.val, 2)
+  x.val = 3
+  expectEqual(x.val, 3)
+}
+
 runAllTests()