Add support for calling C++ constructors.

Because C++ constructors always take a `this` pointer to the object to
be initialized, we mark the SIL function return type with the `@out`
attribute.

On the IRGen side, we retrofit support for formal indirect return values as
well as thin metatypes.

Author: martinboehme

lib/ClangImporter/ClangImporter.cpp

@@ -3589,7 +3589,11 @@ void ClangImporter::getMangledName(raw_ostream &os,
   if (!Impl.Mangler)
     Impl.Mangler.reset(Impl.getClangASTContext().createMangleContext());
 
-  Impl.Mangler->mangleName(clangDecl, os);
+  if (auto ctor = dyn_cast<clang::CXXConstructorDecl>(clangDecl)) {
+    Impl.Mangler->mangleCXXCtor(ctor, clang::Ctor_Complete, os);
+  } else {
+    Impl.Mangler->mangleName(clangDecl, os);
+  }
 }
 
 // ---------------------------------------------------------------------------

lib/ClangImporter/ImportDecl.cpp

@@ -3378,6 +3378,11 @@ namespace {
           continue;
         }
 
+        if (auto CD = dyn_cast<ConstructorDecl>(member)) {
+          ctors.push_back(CD);
+          continue;
+        }
+
         if (auto MD = dyn_cast<FuncDecl>(member)) {
           methods.push_back(MD);
           continue;
@@ -3434,12 +3439,14 @@ namespace {
 
       bool hasReferenceableFields = !members.empty();
 
-      if (hasZeroInitializableStorage) {
+      if (hasZeroInitializableStorage &&
+          !Impl.SwiftContext.LangOpts.EnableCXXInterop) {
         // Add constructors for the struct.
         ctors.push_back(createDefaultConstructor(Impl, result));
       }
 
-      if (hasReferenceableFields && hasMemberwiseInitializer) {
+      if (hasReferenceableFields && hasMemberwiseInitializer &&
+          !Impl.SwiftContext.LangOpts.EnableCXXInterop) {
         // The default zero initializer suppresses the implicit value
         // constructor that would normally be formed, so we have to add that
         // explicitly as well.
@@ -3491,6 +3498,28 @@ namespace {
       return result;
     }
 
+    Decl *VisitCXXRecordDecl(const clang::CXXRecordDecl *decl) {
+      auto &clangSema = Impl.getClangSema();
+      // Make Clang define the implicit default constructor if the class needs
+      // it. Make sure we only do this if the class has been fully defined and
+      // we're not in a dependent context (this is equivalent to the logic in
+      // CanDeclareSpecialMemberFunction in Clang's SemaLookup.cpp).
+      if (decl->getDefinition() && !decl->isBeingDefined() &&
+          !decl->isDependentContext() &&
+          decl->needsImplicitDefaultConstructor()) {
+        // Casting away const here should be OK because
+        // SwiftDeclConverter::Visit() is in practice called with a non-const
+        // argument.
+        clang::CXXConstructorDecl *ctor =
+            clangSema.DeclareImplicitDefaultConstructor(
+                const_cast<clang::CXXRecordDecl *>(decl));
+        clangSema.DefineImplicitDefaultConstructor(clang::SourceLocation(),
+                                                   ctor);
+      }
+
+      return VisitRecordDecl(decl);
+    }
+
     Decl *VisitClassTemplateSpecializationDecl(
                  const clang::ClassTemplateSpecializationDecl *decl) {
       // `Sema::isCompleteType` will try to instantiate the class template as a
@@ -3745,6 +3774,9 @@ namespace {
                              ImportedName importedName,
                              Optional<ImportedName> correctSwiftName,
                              Optional<AccessorInfo> accessorInfo) {
+      if (decl->isDeleted())
+        return nullptr;
+
       auto dc =
           Impl.importDeclContextOf(decl, importedName.getEffectiveContext());
       if (!dc)
@@ -3753,7 +3785,6 @@ namespace {
       DeclName name = accessorInfo ? DeclName() : importedName.getDeclName();
       auto selfIdx = importedName.getSelfIndex();
 
-      FuncDecl *result = nullptr;
       ImportedType importedType;
       bool selfIsInOut = false;
       ParameterList *bodyParams = nullptr;
@@ -3855,27 +3886,44 @@ namespace {
       if (!importedType)
         return nullptr;
 
-      auto resultTy = importedType.getType();
       auto loc = Impl.importSourceLoc(decl->getLocation());
 
       // FIXME: Poor location info.
       auto nameLoc = Impl.importSourceLoc(decl->getLocation());
-      result = createFuncOrAccessor(
-          Impl.SwiftContext, loc, accessorInfo, name,
-          nameLoc, bodyParams, resultTy,
-          /*async*/ false, /*throws*/ false, dc, decl);
-
-      if (!dc->isModuleScopeContext()) {
-        if (selfIsInOut)
-          result->setSelfAccessKind(SelfAccessKind::Mutating);
-        else
-          result->setSelfAccessKind(SelfAccessKind::NonMutating);
-        if (selfIdx) {
-          result->setSelfIndex(selfIdx.getValue());
-        } else {
-          result->setStatic();
-          result->setImportAsStaticMember();
+
+      AbstractFunctionDecl *result = nullptr;
+      if (auto *ctordecl = dyn_cast<clang::CXXConstructorDecl>(decl)) {
+        // TODO: Is failable, throws etc. correct?
+        DeclName ctorName(Impl.SwiftContext, DeclBaseName::createConstructor(),
+                          bodyParams);
+        result = Impl.createDeclWithClangNode<ConstructorDecl>(
+            decl, AccessLevel::Public, ctorName, loc, /*failable=*/false,
+            /*FailabilityLoc=*/SourceLoc(), /*Throws=*/false,
+            /*ThrowsLoc=*/SourceLoc(), bodyParams, /*GenericParams=*/nullptr,
+            dc);
+      } else {
+        auto resultTy = importedType.getType();
+
+        FuncDecl *func = createFuncOrAccessor(
+            Impl.SwiftContext, loc, accessorInfo, name,
+            nameLoc, bodyParams, resultTy,
+            /*async*/ false, /*throws*/ false, dc, decl);
+        result = func;
+
+        if (!dc->isModuleScopeContext()) {
+          if (selfIsInOut)
+            func->setSelfAccessKind(SelfAccessKind::Mutating);
+          else
+            func->setSelfAccessKind(SelfAccessKind::NonMutating);
+          if (selfIdx) {
+            func->setSelfIndex(selfIdx.getValue());
+          } else {
+            func->setStatic();
+            func->setImportAsStaticMember();
+          }
         }
+        // Someday, maybe this will need to be 'open' for C++ virtual methods.
+        func->setAccess(AccessLevel::Public);
       }
 
       result->setIsObjC(false);
@@ -3889,8 +3937,6 @@ namespace {
         result->getAttrs().add(new (Impl.SwiftContext)
                                    FinalAttr(/*IsImplicit=*/true));
 
-      // Someday, maybe this will need to be 'open' for C++ virtual methods.
-      result->setAccess(AccessLevel::Public);
       finishFuncDecl(decl, result);
 
       // If this is a compatibility stub, mark it as such.

lib/ClangImporter/ImportName.cpp

@@ -1600,6 +1600,20 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
   ArrayRef<const clang::ParmVarDecl *> params;
   switch (D->getDeclName().getNameKind()) {
   case clang::DeclarationName::CXXConstructorName:
+    isInitializer = true;
+    isFunction = true;
+    result.info.initKind = CtorInitializerKind::Designated;
+    baseName = "init";
+    // Add empty argument names.
+    if (auto ctor = dyn_cast<clang::CXXConstructorDecl>(D)) {
+      for (size_t i = 0; i < ctor->param_size(); ++i) {
+        argumentNames.push_back(StringRef());
+      }
+      if (ctor->isVariadic())
+        argumentNames.push_back(StringRef());
+    }
+    break;
+
   case clang::DeclarationName::CXXConversionFunctionName:
   case clang::DeclarationName::CXXDestructorName:
   case clang::DeclarationName::CXXLiteralOperatorName:

lib/IRGen/GenCall.cpp

@@ -338,10 +338,12 @@ llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
 
 static void addIndirectResultAttributes(IRGenModule &IGM,
                                         llvm::AttributeList &attrs,
-                                        unsigned paramIndex, bool allowSRet) {
+                                        unsigned paramIndex, bool allowSRet,
+                                        bool noCapture = true) {
   llvm::AttrBuilder b;
   b.addAttribute(llvm::Attribute::NoAlias);
-  b.addAttribute(llvm::Attribute::NoCapture);
+  if (noCapture)
+    b.addAttribute(llvm::Attribute::NoCapture);
   if (allowSRet)
     b.addAttribute(llvm::Attribute::StructRet);
   attrs = attrs.addAttributes(IGM.getLLVMContext(),
@@ -428,7 +430,7 @@ namespace {
 
   private:
     void expand(SILParameterInfo param);
-    llvm::Type *addIndirectResult();
+    llvm::Type *addIndirectResult(bool noCapture = true);
 
     SILFunctionConventions getSILFuncConventions() const {
       return SILFunctionConventions(FnType, IGM.getSILModule());
@@ -482,7 +484,8 @@ llvm::Type *SignatureExpansion::addIndirectResult() {
   auto resultType = getSILFuncConventions().getSILResultType(
       IGM.getMaximalTypeExpansionContext());
   const TypeInfo &resultTI = IGM.getTypeInfo(resultType);
-  addIndirectResultAttributes(IGM, Attrs, ParamIRTypes.size(), claimSRet());
+  addIndirectResultAttributes(IGM, Attrs, ParamIRTypes.size(), claimSRet(),
+                              noCapture);
   addPointerParameter(resultTI.getStorageType());
   return IGM.VoidTy;
 }
@@ -1306,6 +1309,9 @@ void SignatureExpansion::expandExternalSignatureTypes() {
   // Convert each parameter to a Clang type.
   for (auto param : params) {
     auto clangTy = IGM.getClangType(param, FnType);
+    if (clangTy->isVoidType()) {
+      continue;
+    }
     paramTys.push_back(clangTy);
   }
 
@@ -1330,8 +1336,17 @@ void SignatureExpansion::expandExternalSignatureTypes() {
   }
 
   // If we return indirectly, that is the first parameter type.
-  if (returnInfo.isIndirect()) {
-    addIndirectResult();
+  bool formalIndirect = FnType->getNumResults() > 0 &&
+                        FnType->getSingleResult().isFormalIndirect();
+  if (formalIndirect || returnInfo.isIndirect()) {
+    // Specify "nocapture" if we're returning the result indirectly for
+    // low-level ABI reasons, as the called function never sees the implicit
+    // output parameter.
+    // On the other hand, if the result is a formal indirect result in SIL, that
+    // means that the Clang function has an explicit output parameter (e.g. it's
+    // a C++ constructor), which it might capture -- so don't specify
+    // "nocapture" in that case.
+    addIndirectResult(/* noCapture = */ returnInfo.isIndirect());
   }
 
   size_t firstParamToLowerNormally = 0;

lib/IRGen/GenClangType.cpp

@@ -403,7 +403,19 @@ clang::CanQualType GenClangType::visitProtocolType(CanProtocolType type) {
 }
 
 clang::CanQualType GenClangType::visitMetatypeType(CanMetatypeType type) {
-  return getClangMetatypeType(getClangASTContext());
+  assert(type->hasRepresentation() &&
+         "metatype should have been assigned a representation by SIL");
+  switch (type->getRepresentation()) {
+  case MetatypeRepresentation::Thin:
+    return getClangASTContext().VoidTy;
+
+  case MetatypeRepresentation::Thick:
+    llvm_unreachable("thick metatypes don't have a corresponding Clang type");
+
+  case MetatypeRepresentation::ObjC:
+    return getClangMetatypeType(getClangASTContext());
+  }
+  llvm_unreachable("bad representation");
 }
 
 clang::CanQualType

lib/SIL/IR/SILFunctionType.cpp

@@ -2788,6 +2788,27 @@ class CXXMethodConventions : public CFunctionTypeConventions {
       return ParameterConvention::Indirect_In_Guaranteed;
     return ParameterConvention::Indirect_Inout;
   }
+  ResultConvention getResult(const TypeLowering &resultTL) const override {
+    if (isa<clang::CXXConstructorDecl>(TheDecl)) {
+      // Represent the `this` pointer as an indirectly returned result.
+      // This gets us most of the way towards representing the ABI of a
+      // constructor correctly, but it's not guaranteed to be entirely correct.
+      // C++ constructor ABIs are complicated and can require passing additional
+      // "implicit" arguments that depend not only on the signature of the
+      // constructor but on the class on which it's defined (e.g. whether that
+      // class has a virtual base class).
+      // Effectively, we're making an assumption here that there are no implicit
+      // arguments and that the return type of the constructor ABI is void (and
+      // indeed we have no way to represent anything else here). If this assumed
+      // ABI doesn't match the actual ABI, we insert a thunk in IRGen. On some
+      // ABIs (e.g. Itanium x64), we get lucky and the ABI for a complete
+      // constructor call always matches the ABI we assume here. Even if the
+      // actual ABI doesn't match the assumed ABI, we try to get as close as
+      // possible to make it easy for LLVM to optimize away the thunk.
+      return ResultConvention::Indirect;
+     }
+     return CFunctionTypeConventions::getResult(resultTL);
+   }
   static bool classof(const Conventions *C) {
     return C->getKind() == ConventionsKind::CXXMethod;
   }