[cxx-interop] Instantiate C++ class templates from Swift (#33284)

This PR makes it possible to instantiate C++ class templates from Swift. Given a C++ header:

```c++
// C++ module `ClassTemplates`
template<class T>
struct MagicWrapper {
  T t;
};

struct MagicNumber {};
```

it is now possible to write in Swift:

```swift
import ClassTemplates

func x() -> MagicWrapper<MagicNumber> {
  return MagicWrapper<MagicNumber>()
}
```

This is achieved by importing C++ class templates as generic structs, and then when Swift type checker calls `applyGenericArguments` we detect when the generic struct is backed by the C++ class template and call Clang to instantiate the template. In order to make it possible to put class instantiations such as `MagicWrapper<MagicNumber>` into Swift signatures, we have created a new field in `StructDecl` named `TemplateInstantiationType` where the typechecker stores the `BoundGenericType` which we serialize. Deserializer then notices that the `BoundGenericType` is actually a C++ class template and performs the instantiation logic.

Depends on #33420.
Progress towards https://bugs.swift.org/browse/SR-13261.
Fixes https://bugs.swift.org/browse/SR-13775.

Co-authored-by: Dmitri Gribenko <[email protected]>
Co-authored-by: Rosica Dejanovska <[email protected]>

Author: 3 people

include/swift/AST/ClangModuleLoader.h

@@ -177,6 +177,16 @@ class ClangModuleLoader : public ModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
 
+  /// Instantiate and import class template using given arguments.
+  ///
+  /// This method will find the clang::ClassTemplateSpecialization decl if
+  /// it already exists, or it will create one. Then it will import this
+  /// decl the same way as we import typedeffed class templates - using
+  /// the hidden struct prefixed with `__CxxTemplateInst`.
+  virtual StructDecl *
+  instantiateCXXClassTemplate(clang::ClassTemplateDecl *decl,
+                      ArrayRef<clang::TemplateArgument> arguments) = 0;
+
   /// Try to parse the string as a Clang function type.
   ///
   /// Returns null if there was a parsing failure.

include/swift/AST/Decl.h

@@ -3402,6 +3402,42 @@ class EnumDecl final : public NominalTypeDecl {
 class StructDecl final : public NominalTypeDecl {
   SourceLoc StructLoc;
 
+  // We import C++ class templates as generic structs. Then when in Swift code
+  // we want to substitude generic parameters with actual arguments, we
+  // convert the arguments to C++ equivalents and ask Clang to instantiate the
+  // C++ template. Then we import the C++ class template instantiation
+  // as a non-generic structs with a name prefixed with `__CxxTemplateInst`.
+  //
+  // To reiterate:
+  // 1) We need to have a C++ class template declaration in the Clang AST. This
+  //    declaration is simply imported from a Clang module.
+  // 2) We need a Swift generic struct in the Swift AST. This will provide
+  //    template arguments to Clang.
+  // 3) We produce a C++ class template instantiation in the Clang AST
+  //    using 1) and 2). This declaration does not exist in the Clang module
+  //    AST initially in the general case, it's added there on instantiation.
+  // 4) We import the instantiation as a Swift struct, with the name prefixed
+  //    with `__CxxTemplateInst`.
+  //
+  // This causes a problem for serialization/deserialization of the Swift
+  // module. Imagine the Swift struct from 4) is used in the function return
+  // type. We cannot just serialize the non generic Swift struct, because on
+  // deserialization we would need to find its backing Clang declaration
+  // (the C++ class template instantiation), and it won't be found in the
+  // general case. Only the C++ class template from step 1) is in the Clang
+  // AST.
+  //
+  // What we need is to serialize enough information to be
+  // able to instantiate C++ class template on deserialization. It turns out
+  // that all that information is conveniently covered by the BoundGenericType,
+  // which we store in this field. The field is set during the typechecking at
+  // the time when we instantiate the C++ class template.
+  //
+  // Alternative, and likely better solution long term, is to serialize the
+  // C++ class template instantiation into a synthetic Clang module, and load
+  // this Clang module on deserialization.
+  Type TemplateInstantiationType = Type();
+
 public:
   StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
              ArrayRef<TypeLoc> Inherited,
@@ -3445,6 +3481,9 @@ class StructDecl final : public NominalTypeDecl {
   bool isCxxNonTrivial() const { return Bits.StructDecl.IsCxxNonTrivial; }
 
   void setIsCxxNonTrivial(bool v) { Bits.StructDecl.IsCxxNonTrivial = v; }
+
+  Type getTemplateInstantiationType() const { return TemplateInstantiationType; }
+  void setTemplateInstantiationType(Type t) { TemplateInstantiationType = t; }
 };
 
 /// This is the base type for AncestryOptions. Each flag describes possible

include/swift/AST/DiagnosticsSema.def

@@ -2788,6 +2788,10 @@ ERROR(unexportable_clang_function_type,none,
       "it may use anonymous types or types defined outside of a module",
       (Type))
 
+ERROR(cxx_class_instantiation_failed,none,
+      "couldn't instantiate a C++ class template",
+      ())
+
 WARNING(warn_implementation_only_conflict,none,
         "%0 inconsistently imported as implementation-only",
         (Identifier))

include/swift/ClangImporter/ClangImporter.h

@@ -240,6 +240,10 @@ class ClangImporter final : public ClangModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) override;
 
+  StructDecl *
+  instantiateCXXClassTemplate(clang::ClassTemplateDecl *decl,
+                      ArrayRef<clang::TemplateArgument> arguments) override;
+
   /// Just like Decl::getClangNode() except we look through to the 'Code'
   /// enum of an error wrapper struct.
   ClangNode getEffectiveClangNode(const Decl *decl) const;

lib/ClangImporter/ClangImporter.cpp

@@ -4150,3 +4150,25 @@ clang::FunctionDecl *ClangImporter::instantiateCXXFunctionTemplate(
   sema.InstantiateFunctionDefinition(clang::SourceLocation(), spec);
   return spec;
 }
+
+StructDecl *
+ClangImporter::instantiateCXXClassTemplate(
+    clang::ClassTemplateDecl *decl,
+    ArrayRef<clang::TemplateArgument> arguments) {
+  void *InsertPos = nullptr;
+  auto *ctsd = decl->findSpecialization(arguments, InsertPos);
+  if (!ctsd) {
+    ctsd = clang::ClassTemplateSpecializationDecl::Create(
+        decl->getASTContext(), decl->getTemplatedDecl()->getTagKind(),
+        decl->getDeclContext(), decl->getTemplatedDecl()->getBeginLoc(),
+        decl->getLocation(), decl, arguments, nullptr);
+    decl->AddSpecialization(ctsd, InsertPos);
+  }
+
+  auto CanonType = decl->getASTContext().getTypeDeclType(ctsd);
+  assert(isa<clang::RecordType>(CanonType) &&
+          "type of non-dependent specialization is not a RecordType");
+
+  return dyn_cast_or_null<StructDecl>(
+      Impl.importDecl(ctsd, Impl.CurrentVersion));
+}

lib/ClangImporter/ImportDecl.cpp

@@ -3575,13 +3575,6 @@ namespace {
           decl->getDefinition());
       assert(def && "Class template instantiation didn't have definition");
 
-      // If this type is fully specialized (i.e. "Foo<>" or "Foo<int, int>"),
-      // bail to prevent a crash.
-      // TODO: we should be able to support fully specialized class templates.
-      // See SR-13775 for more info.
-      if (def->getTypeAsWritten())
-        return nullptr;
-
       // FIXME: This will instantiate all members of the specialization (and detect
       // instantiation failures in them), which can be more than is necessary
       // and is more than what Clang does. As a result we reject some C++
@@ -3592,19 +3585,6 @@ namespace {
       return VisitCXXRecordDecl(def);
     }
 
-    Decl *VisitClassTemplateDecl(const clang::ClassTemplateDecl *decl) {
-      // When loading a namespace's sub-decls, we won't add template
-      // specilizations, so make sure to do that here.
-      for (auto spec : decl->specializations()) {
-        if (auto importedSpec = Impl.importDecl(spec, getVersion())) {
-          if (auto namespaceDecl =
-                  dyn_cast<EnumDecl>(importedSpec->getDeclContext()))
-            namespaceDecl->addMember(importedSpec);
-        }
-      }
-      return nullptr;
-    }
-
     Decl *VisitClassTemplatePartialSpecializationDecl(
         const clang::ClassTemplatePartialSpecializationDecl *decl) {
       // Note: partial template specializations are not imported.
@@ -4256,6 +4236,43 @@ namespace {
                                 correctSwiftName, None, decl);
     }
 
+    Decl *VisitClassTemplateDecl(const clang::ClassTemplateDecl *decl) {
+      // When loading a namespace's sub-decls, we won't add template
+      // specilizations, so make sure to do that here.
+      for (auto spec : decl->specializations()) {
+        if (auto importedSpec = Impl.importDecl(spec, getVersion())) {
+          if (auto namespaceDecl =
+                  dyn_cast<EnumDecl>(importedSpec->getDeclContext()))
+            namespaceDecl->addMember(importedSpec);
+        }
+      }
+
+      Optional<ImportedName> correctSwiftName;
+      auto importedName = importFullName(decl, correctSwiftName);
+      auto name = importedName.getDeclName().getBaseIdentifier();
+      if (name.empty())
+        return nullptr;
+      auto loc = Impl.importSourceLoc(decl->getLocation());
+      auto dc = Impl.importDeclContextOf(
+          decl, importedName.getEffectiveContext());
+
+      SmallVector<GenericTypeParamDecl *, 4> genericParams;
+      for (auto &param : *decl->getTemplateParameters()) {
+        auto genericParamDecl = Impl.createDeclWithClangNode<GenericTypeParamDecl>(
+            param, AccessLevel::Public, dc,
+            Impl.SwiftContext.getIdentifier(param->getName()),
+            Impl.importSourceLoc(param->getLocation()),
+            /*depth*/ 0, /*index*/ genericParams.size());
+        genericParams.push_back(genericParamDecl);
+      }
+      auto genericParamList = GenericParamList::create(
+          Impl.SwiftContext, loc, genericParams, loc);
+
+      auto structDecl = Impl.createDeclWithClangNode<StructDecl>(
+        decl, AccessLevel::Public, loc, name, loc, None, genericParamList, dc);
+      return structDecl;
+    }
+
     Decl *VisitUsingDecl(const clang::UsingDecl *decl) {
       // Using declarations are not imported.
       return nullptr;

lib/Sema/TypeCheckType.cpp

@@ -44,6 +44,9 @@
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/Strings.h"
 #include "swift/Subsystems.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclTemplate.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
@@ -834,6 +837,46 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
       diags.diagnose(loc, diag::use_of_void_pointer, "").
         fixItReplace(generic->getSourceRange(), "UnsafeRawPointer");
   }
+
+  if (auto clangDecl = decl->getClangDecl()) {
+    if (auto classTemplateDecl =
+            dyn_cast<clang::ClassTemplateDecl>(clangDecl)) {
+      SmallVector<Type, 2> typesOfGenericArgs;
+      for (auto typeRepr : generic->getGenericArgs()) {
+        typesOfGenericArgs.push_back(resolution.resolveType(typeRepr));
+      }
+
+      SmallVector<clang::TemplateArgument, 2> templateArguments;
+      std::unique_ptr<TemplateInstantiationError> error =
+          ctx.getClangTemplateArguments(
+              classTemplateDecl->getTemplateParameters(), typesOfGenericArgs,
+              templateArguments);
+
+      if (error) {
+        std::string failedTypesStr;
+        llvm::raw_string_ostream failedTypesStrStream(failedTypesStr);
+        llvm::interleaveComma(error->failedTypes, failedTypesStrStream);
+        // TODO: This error message should not reference implementation details.
+        // See: https://github.com/apple/swift/pull/33053#discussion_r477003350
+        ctx.Diags.diagnose(
+            loc, diag::unable_to_convert_generic_swift_types.ID,
+            {classTemplateDecl->getName(), StringRef(failedTypesStr)});
+        return ErrorType::get(ctx);
+      }
+
+      auto *clangModuleLoader = decl->getASTContext().getClangModuleLoader();
+      auto instantiatedDecl = clangModuleLoader->instantiateCXXClassTemplate(
+          const_cast<clang::ClassTemplateDecl *>(classTemplateDecl),
+          templateArguments);
+      if (instantiatedDecl) {
+        instantiatedDecl->setTemplateInstantiationType(result);
+        return instantiatedDecl->getDeclaredInterfaceType();
+      } else {
+        diags.diagnose(loc, diag::cxx_class_instantiation_failed);
+        return ErrorType::get(ctx);
+      }
+    }
+  }
   return result;
 }
 

lib/Serialization/Deserialization.cpp

@@ -34,6 +34,7 @@
 #include "swift/Serialization/SerializedModuleLoader.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/Statistic.h"
+#include "clang/AST/DeclTemplate.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
@@ -5353,6 +5354,31 @@ class TypeDeserializer {
       genericArgs.push_back(argTy.get());
     }
 
+    if (auto clangDecl = nominal->getClangDecl()) {
+      if (auto ctd = dyn_cast<clang::ClassTemplateDecl>(clangDecl)) {
+        auto clangImporter = static_cast<ClangImporter *>(
+            nominal->getASTContext().getClangModuleLoader());
+
+        SmallVector<Type, 2> typesOfGenericArgs;
+        for (auto arg : genericArgs) {
+          typesOfGenericArgs.push_back(arg);
+        }
+
+        SmallVector<clang::TemplateArgument, 2> templateArguments;
+        std::unique_ptr<TemplateInstantiationError> error =
+            ctx.getClangTemplateArguments(ctd->getTemplateParameters(),
+                                          typesOfGenericArgs,
+                                          templateArguments);
+
+        auto instantiation = clangImporter->instantiateCXXClassTemplate(
+            const_cast<clang::ClassTemplateDecl *>(ctd), templateArguments);
+
+        instantiation->setTemplateInstantiationType(
+            BoundGenericType::get(nominal, parentTy, genericArgs));
+        return instantiation->getDeclaredInterfaceType();
+      }
+    }
+
     return BoundGenericType::get(nominal, parentTy, genericArgs);
   }
 

lib/Serialization/Serialization.cpp

@@ -47,6 +47,7 @@
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Serialization/SerializationOptions.h"
 #include "swift/Strings.h"
+#include "clang/AST/DeclTemplate.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
@@ -73,6 +74,7 @@ using namespace llvm::support;
 using swift::version::Version;
 using llvm::BCBlockRAII;
 
+
 ASTContext &SerializerBase::getASTContext() {
   return M->getASTContext();
 }
@@ -626,13 +628,25 @@ DeclID Serializer::addDeclRef(const Decl *D, bool allowTypeAliasXRef) {
 }
 
 serialization::TypeID Serializer::addTypeRef(Type ty) {
+  Type typeToSerialize = ty;
+  if (ty) {
+    if (auto nominalDecl = ty->getAnyNominal()) {
+      if (auto structDecl = dyn_cast<StructDecl>(nominalDecl)) {
+        if (auto templateInstantiationType =
+                structDecl->getTemplateInstantiationType()) {
+          typeToSerialize = templateInstantiationType;
+        }
+      }
+    }
+  }
+
 #ifndef NDEBUG
-  PrettyStackTraceType trace(M->getASTContext(), "serializing", ty);
+  PrettyStackTraceType trace(M->getASTContext(), "serializing", typeToSerialize);
   assert(M->getASTContext().LangOpts.AllowModuleWithCompilerErrors ||
-         !ty || !ty->hasError() && "serializing type with an error");
+         !typeToSerialize || !typeToSerialize->hasError() && "serializing type with an error");
 #endif
 
-  return TypesToSerialize.addRef(ty);
+  return TypesToSerialize.addRef(typeToSerialize);
 }
 
 serialization::ClangTypeID Serializer::addClangTypeRef(const clang::Type *ty) {

test/Interop/Cxx/templates/Inputs/SwiftClassInstantiationModule.swift

@@ -0,0 +1,10 @@
+import ClassTemplateForSwiftModule
+
+public func makeWrappedMagicNumber() -> MagicWrapper<IntWrapper> {
+  let t = IntWrapper(value: 42)
+  return MagicWrapper<IntWrapper>(t: t)
+}
+
+public func readWrappedMagicNumber(_ i: inout MagicWrapper<IntWrapper>) -> CInt {
+  return i.getValuePlusArg(13)
+}

test/Interop/Cxx/templates/Inputs/SwiftClassTemplateInNamespaceModule.swift

@@ -0,0 +1,13 @@
+import ClassTemplateInNamespaceForSwiftModule
+
+public func receiveShip(_ i: inout Space.Ship<Bool>) {}
+
+public func returnShip() -> Space.Ship<Bool> {
+  return Space.Ship<Bool>()
+}
+
+public func receiveShipWithEngine(_ i: inout Space.Ship<Engine.Turbojet>) {}
+
+public func returnShipWithEngine() -> Space.Ship<Engine.Turbojet> {
+  return Space.Ship<Engine.Turbojet>()
+}

test/Interop/Cxx/templates/Inputs/SwiftClassTemplateNestedTypeModule.swift

@@ -0,0 +1,7 @@
+import ClassTemplateNestedTypeForSwiftModule
+
+public func receiveShipEngine(_ i: inout Ship<Bool>.Engine) {}
+
+public func returnShipEngine() -> Ship<Bool>.Engine {
+  return Ship<Bool>.Engine()
+}

test/Interop/Cxx/templates/Inputs/class-template-for-swift-module.h

@@ -0,0 +1,15 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_FOR_SWIFT_MODULE_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_FOR_SWIFT_MODULE_H
+
+struct IntWrapper {
+  int value;
+  int getValue() const { return value; }
+};
+
+template<class T>
+struct MagicWrapper {
+  T t;
+  int getValuePlusArg(int arg) const { return t.getValue() + arg; }
+};
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_FOR_SWIFT_MODULE_H

test/Interop/Cxx/templates/Inputs/class-template-in-namespace-for-swift-module.h

@@ -0,0 +1,12 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_IN_NAMESPACE_FOR_SWIFT_MODULE_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_IN_NAMESPACE_FOR_SWIFT_MODULE_H
+
+namespace Space {
+template <class T> struct Ship { T t; };
+} // namespace Space
+
+namespace Engine {
+struct Turbojet {};
+} // namespace Engine
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_CLASS_TEMPLATE_IN_NAMESPACE_FOR_SWIFT_MODULE_H