[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,43 @@ 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 as it cannot be a StructDecl");
+          // When we add full support for C foreign reference types then we
+          // should synthesize static factories for them as well
+          if (auto *cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(decl)) {
+            bool hasUserProvidedStaticFactory =
+                llvm::any_of(cxxRecordDecl->methods(), [](const auto *method) {
+                  return method->isStatic() &&
+                         llvm::any_of(method->template specific_attrs<
+                                          clang::SwiftNameAttr>(),
+                                      [](const auto *attr) {
+                                        return attr->getName().str().find(
+                                                   "init") != std::string::npos;
+                                      });
+                });
+            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,128 @@ SwiftDeclSynthesizer::makeDefaultArgument(const clang::ParmVarDecl *param,
 
   return callExpr;
 }
+
+// MARK: C++ foreign reference type constructors
+
+clang::CXXMethodDecl *
+SwiftDeclSynthesizer::synthesizeStaticFactoryForCXXForeignRef(
+    const clang::CXXRecordDecl *cxxRecordDecl, clang::ASTContext &clangCtx,
+    clang::Sema &clangSema) {
+
+  clang::QualType cxxRecordTy = clangCtx.getRecordType(cxxRecordDecl);
+
+  clang::CXXConstructorDecl *defaultCtorDecl = nullptr;
+  for (clang::CXXConstructorDecl *ctor : cxxRecordDecl->ctors()) {
+    if (ctor->parameters().empty() && !ctor->isDeleted() &&
+        ctor->getAccess() != clang::AS_private &&
+        ctor->getAccess() != clang::AS_protected) {
+      defaultCtorDecl = ctor;
+      break;
+    }
+  }
+  if (!defaultCtorDecl)
+    return nullptr;
+
+  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::QualType cxxRecordPtrTy = clangCtx.getPointerType(cxxRecordTy);
+  // Adding `_Nonnull` to the return type of synthesized static factory
+  bool nullabilityCannotBeAdded =
+      clangSema.CheckImplicitNullabilityTypeSpecifier(
+          cxxRecordPtrTy, clang::NullabilityKind::NonNull,
+          cxxRecordDecl->getLocation(),
+          /*isParam=*/false,
+          /*OverrideExisting=*/true);
+  assert(!nullabilityCannotBeAdded &&
+         "Failed to add _Nonnull specifier to synthesized "
+         "static factory's return type");
+
+  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, const_cast<clang::CXXRecordDecl *>(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,13 @@ 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(
+      const clang::CXXRecordDecl *cxxRecordDecl, clang::ASTContext &clangCtx,
+      clang::Sema &clangSema);
+
 private:
   Type getConstantLiteralType(Type type, ConstantConvertKind convertKind);
 };