[cxx-interop] Support first non default ctor of c++ foreign reference types

Author: fahadnayyar

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2538,29 +2538,29 @@ SwiftDeclSynthesizer::synthesizeStaticFactoryForCXXForeignRef(
 
   clang::ASTContext &clangCtx = cxxRecordDecl->getASTContext();
   clang::Sema &clangSema = ImporterImpl.getClangSema();
+  clang::SourceLocation cxxRecordDeclLoc = cxxRecordDecl->getLocation();
 
   clang::QualType cxxRecordTy = clangCtx.getRecordType(cxxRecordDecl);
 
-  clang::CXXConstructorDecl *defaultCtorDecl = nullptr;
+  // Todo: synthesize static factories for all available ctors
+  clang::CXXConstructorDecl *selectedCtorDecl = nullptr;
   for (clang::CXXConstructorDecl *ctor : cxxRecordDecl->ctors()) {
-    if (ctor->parameters().empty() && !ctor->isDeleted() &&
-        ctor->getAccess() != clang::AS_private &&
+    if (!ctor->isDeleted() && ctor->getAccess() != clang::AS_private &&
         ctor->getAccess() != clang::AS_protected) {
-      defaultCtorDecl = ctor;
+      selectedCtorDecl = ctor;
       break;
     }
   }
-  if (!defaultCtorDecl)
+  if (!selectedCtorDecl)
     return nullptr;
 
   clang::FunctionDecl *operatorNew = nullptr;
   clang::FunctionDecl *operatorDelete = nullptr;
   bool passAlignment = false;
   bool findingAllocFuncFailed = clangSema.FindAllocationFunctions(
-      cxxRecordDecl->getLocation(), clang::SourceRange(), clang::Sema::AFS_Both,
-      clang::Sema::AFS_Both, cxxRecordTy,
-      /*IsArray*/ false, passAlignment, clang::MultiExprArg(), operatorNew,
-      operatorDelete, /*Diagnose*/ false);
+      cxxRecordDeclLoc, clang::SourceRange(), clang::Sema::AFS_Both,
+      clang::Sema::AFS_Both, cxxRecordTy, /*IsArray=*/false, passAlignment,
+      clang::MultiExprArg(), operatorNew, operatorDelete, /*Diagnose=*/false);
   if (findingAllocFuncFailed || !operatorNew || operatorNew->isDeleted() ||
       operatorNew->getAccess() == clang::AS_private ||
       operatorNew->getAccess() == clang::AS_protected)
@@ -2570,81 +2570,111 @@ SwiftDeclSynthesizer::synthesizeStaticFactoryForCXXForeignRef(
   // Adding `_Nonnull` to the return type of synthesized static factory
   bool nullabilityCannotBeAdded =
       clangSema.CheckImplicitNullabilityTypeSpecifier(
-          cxxRecordPtrTy, clang::NullabilityKind::NonNull,
-          cxxRecordDecl->getLocation(),
-          /*isParam=*/false,
-          /*OverrideExisting=*/true);
+          cxxRecordPtrTy, clang::NullabilityKind::NonNull, cxxRecordDeclLoc,
+          /*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());
+
+  llvm::SmallVector<clang::QualType, 4> paramTypes;
+  for (const auto *param : selectedCtorDecl->parameters())
+    paramTypes.push_back(param->getType());
   clang::FunctionProtoType::ExtProtoInfo EPI;
   clang::QualType funcTypeToSynthesize =
-      clangCtx.getFunctionType(cxxRecordPtrTy, {}, EPI);
+      clangCtx.getFunctionType(cxxRecordPtrTy, paramTypes, EPI);
 
   clang::CXXMethodDecl *synthesizedCxxMethodDecl = clang::CXXMethodDecl::Create(
       clangCtx, const_cast<clang::CXXRecordDecl *>(cxxRecordDecl),
-      cxxRecordDecl->getLocation(),
-      clang::DeclarationNameInfo(funcNameToSynthesize,
-                                 cxxRecordDecl->getLocation()),
+      cxxRecordDeclLoc,
+      clang::DeclarationNameInfo(funcNameToSynthesize, cxxRecordDeclLoc),
       funcTypeToSynthesize,
       clangCtx.getTrivialTypeSourceInfo(funcTypeToSynthesize), clang::SC_Static,
       /*UsesFPIntrin=*/false, /*isInline=*/true,
-      clang::ConstexprSpecKind::Unspecified, cxxRecordDecl->getLocation());
-  assert(synthesizedCxxMethodDecl &&
-         "Unable to synthesize static factory for c++ foreign reference type");
+      clang::ConstexprSpecKind::Unspecified, cxxRecordDeclLoc);
   synthesizedCxxMethodDecl->setAccess(clang::AccessSpecifier::AS_public);
 
+  llvm::SmallVector<clang::ParmVarDecl *, 4> synthesizedParams;
+  for (unsigned int i = 0; i < selectedCtorDecl->getNumParams(); ++i) {
+    auto *origParam = selectedCtorDecl->getParamDecl(i);
+    auto *param = clang::ParmVarDecl::Create(
+        clangCtx, synthesizedCxxMethodDecl, cxxRecordDeclLoc, cxxRecordDeclLoc,
+        origParam->getIdentifier(), origParam->getType(),
+        clangCtx.getTrivialTypeSourceInfo(origParam->getType()), clang::SC_None,
+        nullptr);
+    synthesizedParams.push_back(param);
+  }
+  synthesizedCxxMethodDecl->setParams(synthesizedParams);
+
   if (!hasImmortalAttrs(cxxRecordDecl)) {
     clang::SwiftAttrAttr *returnsRetainedAttrForSynthesizedCxxMethodDecl =
         clang::SwiftAttrAttr::Create(clangCtx, "returns_retained");
     synthesizedCxxMethodDecl->addAttr(
         returnsRetainedAttrForSynthesizedCxxMethodDecl);
   }
 
-  clang::SwiftNameAttr *swiftNameInitAttrForSynthesizedCxxMethodDecl =
-      clang::SwiftNameAttr::Create(clangCtx, "init()");
-  synthesizedCxxMethodDecl->addAttr(
-      swiftNameInitAttrForSynthesizedCxxMethodDecl);
+  std::string swiftInitSig = "init(";
+  bool first = true;
+  for (auto *param : selectedCtorDecl->parameters()) {
+    if (!first)
+      swiftInitSig += ":_";
+    swiftInitSig += ")";
+    first = false;
+  }
+  clang::SwiftNameAttr *swiftNameAttr =
+      clang::SwiftNameAttr::Create(clangCtx, swiftInitSig);
+  synthesizedCxxMethodDecl->addAttr(swiftNameAttr);
+
+  llvm::SmallVector<clang::Expr *, 8> ctorArgs;
+  for (auto *param : synthesizedParams) {
+    ctorArgs.push_back(clang::DeclRefExpr::Create(
+        clangCtx, clang::NestedNameSpecifierLoc(), clang::SourceLocation(),
+        param,
+        /*RefersToEnclosingVariableOrCapture=*/false, clang::SourceLocation(),
+        param->getType(), clang::VK_LValue));
+  }
+
+  llvm::SmallVector<clang::Expr *, 8> convertedCtorArgs;
+  if (clangSema.CompleteConstructorCall(selectedCtorDecl, cxxRecordTy, ctorArgs,
+                                        cxxRecordDeclLoc, convertedCtorArgs))
+    return nullptr;
 
   clang::ExprResult synthesizedConstructExprResult =
       clangSema.BuildCXXConstructExpr(
-          clang::SourceLocation(), cxxRecordTy, defaultCtorDecl,
-          /*Elidable=*/false, clang::MultiExprArg(),
+          cxxRecordDeclLoc, cxxRecordTy, selectedCtorDecl,
+          /*Elidable=*/false, convertedCtorArgs,
           /*HadMultipleCandidates=*/false,
           /*IsListInitialization=*/false,
           /*IsStdInitListInitialization=*/false,
           /*RequiresZeroInit=*/false, clang::CXXConstructionKind::Complete,
-          clang::SourceRange());
+          clang::SourceRange(cxxRecordDeclLoc, cxxRecordDeclLoc));
   assert(!synthesizedConstructExprResult.isInvalid() &&
          "Unable to synthesize constructor expression for c++ foreign "
          "reference type");
-  clang::CXXConstructExpr *synthesizedConstructExpr =
-      cast<clang::CXXConstructExpr>(synthesizedConstructExprResult.get());
+  clang::Expr *synthesizedConstructExpr = 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);
+      clang::SourceRange(cxxRecordDeclLoc, cxxRecordDeclLoc),
+      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);
+  clang::ReturnStmt *synthesizedRetStmt = clang::ReturnStmt::Create(
+      clangCtx, cxxRecordDeclLoc, synthesizedNewExpr, 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());
+      cxxRecordDeclLoc, cxxRecordDeclLoc);
   assert(synthesizedRetStmt && "Unable to synthesize function body for static "
                                "factory of c++ foreign reference type");
 

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

@@ -23,5 +23,5 @@ let _ = SwiftInitSynthesisForCXXRefTypes.DefaulltAndNonDefaultCtors()
 // TODO: change the error message when we start supporting parameterised ctors
 let _ = SwiftInitSynthesisForCXXRefTypes.DefaulltAndNonDefaultCtors(2)  // expected-error {{argument passed to call that takes no arguments}}
 
-let _ = SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor()  // expected-error {{'SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor' cannot be constructed because it has no accessible initializers}}
-let _ = SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor(3)  // expected-error {{'SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor' cannot be constructed because it has no accessible initializers}}
+// TODO: fix the error message in this case
+let _ = SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor()  // expected-error {{missing argument for parameter #1 in call}}

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

@@ -113,6 +113,11 @@ CxxConstructorTestSuite.test("SynthesizeAndImportStaticFactoryAsInitializer") {
 
   let x6 = SwiftInitSynthesisForCXXRefTypes.UserProvidedStaticFactory(3)
   expectEqual(x6.val, 3)
+
+  let x7 = SwiftInitSynthesisForCXXRefTypes.ParameterizedCtor(2)
+  expectEqual(x7.val, 2)
+  x7.val = 3
+  expectEqual(x7.val, 3)
 }
 
 runAllTests()