class ClangModuleLoader : public ModuleLoader {   /// based on subtleties like the target module interface format.   virtual bool isSerializable(const clang::Type *type,                               bool checkCanonical) const = 0;++  virtual clang::FunctionDecl *+  generateCXXFunctionTemplateSpecializations(ASTContext &ctx,+                                             clang::FunctionTemplateDecl *func,+                                             SubstitutionMap subst) = 0;+};++/// Used to describe an error when instanciated a template.

 We could ignore explicit specializations of function templates, because they don't affect the API. Explicit specializations of class templates can dramatically change the API of the type. +### Class templates: Importing full class template instantiations++A class template instantiation could be imported as a struct named+`__CxxTemplateInst` plus Itanium mangled type of the instantiation (see the

 nominal type descriptor symbol for ``CxxStruct`` while compiling the ``main`` mo .. code::    sSo9CxxStructVMn // -> nominal type descriptor for __C.CxxStruct++Importing C++ class template instantiations+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++A class template instantiation is imported as a struct named+``__CxxTemplateInst`` plus Itanium mangled type of the instantiation (see the+``type`` production in the Itanium specification). Note that Itanium mangling is+used on all platforms, regardless of the ABI of the C++ toolchain, to ensure+that the mangled name is a valid Swift type name (this is not the case for MSVC+mangled names). A prefix with a double underscore (to ensure we have a reserved+C++ identifier) is added to limit the possibility for conflicts with names of+user-defined structs. The struct is notionally defined in the ``__C`` module,+similarly to regular C and C++ structs and classes. Consider the following C+++module:++.. code-block:: c++++  template<class T>+  struct MagicWrapper {+    T t;+  };++  struct MagicNumber {};++  typedef MagicWrapper<MagicNumber> WrappedMagicNumber;++``WrappedMagicNumber`` will be imported as a typealias for a struct+``__CxxTemplateInst12MagicWrapperI11MagicNumberE``. Interface of the imported+module will look as follows:

+// RUN: %target-swift-frontend -enable-cxx-interop -I %S/Inputs %s -emit-ir | %FileCheck %s++import TypeClassification++// TODO: C++ objects with destructors should be tested here once we fully+// support them.++// CHECK-LABEL: define {{.*}}i1 @"$s4main37testStructWithCopyConstructorAndValueSbyF"

 public func testStructWithSubobjectDestructor() {   let d = StructWithSubobjectDestructor() } +// CHECK-LABLE: sil @$s4main37testStructWithCopyConstructorAndValueSbyF+// CHECK: [[OBJ:%.*]] = alloc_stack $StructWithCopyConstructorAndValue+// CHECK: [[IL_42:%.*]] = integer_literal $Builtin.Int32, 42+// CHECK: [[I_42:%.*]] = struct $Int32 ([[IL_42]] : $Builtin.Int32)+// CHECK: [[OBJ_VALUE:%.*]] = struct_element_addr [[OBJ]] : $*StructWithCopyConstructorAndValue, #StructWithCopyConstructorAndValue.value+// CHECK: store [[I_42]] to [[OBJ_VALUE]] : $*Int32+// CHECK: [[IL_FALSE:%.*]] = integer_literal $Builtin.Int1, -1

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not cover+Swift-specific symbols like Swift type metadata for foreign types, so Swift uses+its own mangling scheme for those symbols.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~~~~~~~~~++Types imported from C and C++ are imported as if they are located in the ``__C``+module, regardless of the actual Clang module that they are coming from. This+can be observed when mangling a Swift function that accepts a C/C++ struct as a+parameter:++CxxStructModule:++.. code-block:: c++++  struct CxxStruct {};++  inline void cxxFunction(CxxStruct s) {}++Swift ``main`` module importing ``CxxStructModule``:

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not cover+Swift-specific symbols like Swift type metadata for foreign types, so Swift uses+its own mangling scheme for those symbols.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~~~~~~~~~++Types imported from C and C++ are imported as if they are located in the ``__C``+module, regardless of the actual Clang module that they are coming from. This+can be observed when mangling a Swift function that accepts a C/C++ struct as a+parameter:++CxxStructModule:++.. code-block:: c++++  struct CxxStruct {};++  inline void cxxFunction(CxxStruct s) {}++Swift ``main`` module importing ``CxxStructModule``:++.. code-block:: swift++  import CxxStructModule++  public func swiftFunction(_ s: CxxStruct) {}++Resulting symbols (showing only Itanium-mangled C++ symbols for brevity):++.. code::++  _Z11cxxFunction9CxxStruct // -> cxxFunction(CxxStruct)+  s4main13swiftFunctionyySo9CxxStructVF // -> main.swiftFunction(__C.CxxStruct) -> ()++The C/C++ compiler does not generate Swift metadata symbols and value witness+tables for C and C++ types. To make a foreign type usable in Swift in the same+way as a native type, the Swift compiler must generate these symbols.+Specifically, each Swift module that uses a given C or C++ type generates the+necessary Swift symbols. For the example above Swift will generate following+nominal type descriptor symbol for ``CxxStruct``:

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not cover+Swift-specific symbols like Swift type metadata for foreign types, so Swift uses+its own mangling scheme for those symbols.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~~~~~~~~~++Types imported from C and C++ are imported as if they are located in the ``__C``+module, regardless of the actual Clang module that they are coming from. This+can be observed when mangling a Swift function that accepts a C/C++ struct as a+parameter:++CxxStructModule:

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not cover+Swift-specific symbols like Swift type metadata for foreign types, so Swift uses+its own mangling scheme for those symbols.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~~~~~~~~~++Types imported from C and C++ are imported as if they are located in the ``__C``+module, regardless of the actual Clang module that they are coming from. This+can be observed when mangling a Swift function that accepts a C/C++ struct as a+parameter:++CxxStructModule:++.. code-block:: c++++  struct CxxStruct {};++  inline void cxxFunction(CxxStruct s) {}++Swift ``main`` module importing ``CxxStructModule``:++.. code-block:: swift++  import CxxStructModule++  public func swiftFunction(_ s: CxxStruct) {}++Resulting symbols (showing only Itanium-mangled C++ symbols for brevity):++.. code::++  _Z11cxxFunction9CxxStruct // -> cxxFunction(CxxStruct)+  s4main13swiftFunctionyySo9CxxStructVF // -> main.swiftFunction(__C.CxxStruct) -> ()+

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITHOUT_DEFINITION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITHOUT_DEFINITION_H++template<class T>+struct MagicWrapper {+  T t;+  int getValuePlusArg(int arg) const { return t.getValue() + arg; }+};++struct IntWrapper {+  int value;+  int getValue() const { return value; }+};++// MagicWrapper<IntWrapper> ClassTemplateSpecializationDecl doesn't have a

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITHOUT_DEFINITION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITHOUT_DEFINITION_H++template<class T>+struct MagicWrapper {+  T t;+  int getValuePlusArg(int arg) const { return t.getValue() + arg; }+};++struct IntWrapper {+  int value;+  int getValue() const { return value; }+};++// MagicWrapper<IntWrapper> ClassTemplateSpecializationDecl doesn't have a+// definition in Clang because nothing in this header required the+// instantiation. Therefore we have to construct the definition on the swift+// side.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_LINKAGE_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_LINKAGE_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  // Swift runtime defines many value witness tables for common types.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_LINKAGE_H

+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop -Xcc -std=c++17)+//+// REQUIRES: executable_test++import CanonicalTypes+import StdlibUnittest++var TemplatesTestSuite = TestSuite("TemplatesTestSuite")++TemplatesTestSuite.test("canonical-types") {+  // multiple typedeffed types with the same canonical type are the same type+  // from the typechecking perspective.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_LINKAGE_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_LINKAGE_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  // Swift runtime defines many value witness tables for common types.+  // The struct's uncommon size forces creation of its own witness table.

+// RUN: %target-swift-emit-ir %s -I %S/Inputs -enable-cxx-interop | grep 'define.*swiftcc.*$' | grep -o '\$[[:alnum:]]\+__CxxTemplateInst[[:alnum:]]\+' | xargs %swift-demangle | %FileCheck %s++import Mangling++public func receiveInstantiation(_ i: inout WrappedMagicInt) {}++public func returnInstantiation() -> WrappedMagicInt {+  return WrappedMagicInt()+}++// CHECK: $s10demangling20receiveInstantiationyySo34__CxxTemplateInst12MagicWrapperIiEVzF ---> demangling.receiveInstantiation(inout __C.__CxxTemplateInst12MagicWrapperIiE) -> ()+// CHECK: $s10demangling19returnInstantiationSo34__CxxTemplateInst12MagicWrapperIiEVyF ---> demangling.returnInstantiation() -> __C.__CxxTemplateInst12MagicWrapperIiE

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H++template<class T>+struct MagicWrapper {+  T t;+  int getValuePlusArg(int arg) const { return t.getValue() + arg; }+};++struct IntWrapper {+  int value;+  int getValue() const { return value; }+};++inline int forceInstantiation() {+  auto t = MagicWrapper<IntWrapper>();+  return t.getValuePlusArg(14);+}++// MagicWrapper<IntWrapper> ClassTemplateSpecializationDecl has a definition

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H++template<class T>+struct MagicWrapper {+  T t;+  int getValuePlusArg(int arg) const { return t.getValue() + arg; }+};++struct IntWrapper {+  int value;+  int getValue() const { return value; }+};++inline MagicWrapper<IntWrapper> forceInstantiation() {+  return MagicWrapper<IntWrapper>();+}++// MagicWrapper<IntWrapper> ClassTemplateSpecializationDecl has a definition

 ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,     }   } +  if (auto classTemplateSpecDecl =+          dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {+    if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {++      auto &astContext = classTemplateSpecDecl->getASTContext();+      // Itanium mangler produces valid Swift identifiers, use it to generate a name for+      // this instantiation. This name will not appear in the native code.+      clang::MangleContext *mangler = clang::ItaniumMangleContext::create(+          astContext, astContext.getDiagnostics());+      llvm::SmallString<128> storage;+      llvm::raw_svector_ostream buffer(storage);+      mangler->mangleTypeName(astContext.getRecordType(classTemplateSpecDecl),+                              buffer);++      // We reuse mangleTypeName() which returns RTTI typeinfo name, to get the mangled type.

 ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,     }   } +  if (auto classTemplateSpecDecl =+          dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {+    if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {++      auto &astContext = classTemplateSpecDecl->getASTContext();+      // Itanium mangler produces valid Swift identifiers, use it to generate a name for+      // this instantiation. This name will not appear in the native code.+      clang::MangleContext *mangler = clang::ItaniumMangleContext::create(+          astContext, astContext.getDiagnostics());+      llvm::SmallString<128> storage;+      llvm::raw_svector_ostream buffer(storage);+      mangler->mangleTypeName(astContext.getRecordType(classTemplateSpecDecl),+                              buffer);++      // We reuse mangleTypeName() which returns RTTI typeinfo name, to get the mangled type.+      // Therefore we need to strip the '_ZTS' prefix, which we replace with '__CxxTemplateInst'+      // (a prefix reserved for C++ compiler usage).+      llvm::SmallString<128> mangledNameStorage;+      llvm::raw_svector_ostream mangledName(mangledNameStorage);+      mangledName << CXX_TEMPLATE_INST_PREFIX << buffer.str().drop_front(4);

 ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,     }   } +  if (auto classTemplateSpecDecl =+          dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {+    if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {++      auto &astContext = classTemplateSpecDecl->getASTContext();+      // Itanium mangler produces valid Swift identifiers, use it to generate a name for+      // this instantiation. This name will not appear in the native code.

 namespace {      Decl *VisitClassTemplateSpecializationDecl(                  const clang::ClassTemplateSpecializationDecl *decl) {-      // FIXME: We could import specializations, but perhaps only as unnamed-      // structural types.-      return nullptr;+      // `sema.isCompleteType` will try to instantiate the class template as a

 void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {       appendIdentifier(interface->getObjCRuntimeNameAsString());     } else if (UseObjCRuntimeNames && protocol) {       appendIdentifier(protocol->getObjCRuntimeNameAsString());+    } else if (auto ctsd = dyn_cast<clang::ClassTemplateSpecializationDecl>(namedDecl)) {+      // If this is a `ClassTemplateSpecializationDecl` it means the decl was

+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop -Xcc -std=c++17)+//+// REQUIRES: executable_test++import ExplicitSpecialization+import StdlibUnittest++var TemplatesTestSuite = TestSuite("TemplatesTestSuite")++TemplatesTestSuite.test("explicit-specialization") {+  // Specialization doubles the argument.

 void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {       appendIdentifier(interface->getObjCRuntimeNameAsString());     } else if (UseObjCRuntimeNames && protocol) {       appendIdentifier(protocol->getObjCRuntimeNameAsString());+    } else if (auto ctsd = dyn_cast<clang::ClassTemplateSpecializationDecl>(namedDecl)) {+      // If this is a `ClassTemplateSpecializationDecl` it means the decl was+      // imported as a Swift decl with `__CxxTemplateInst...` name.+      // `ClassTemplateSpecializationDecl`'s name does not include names of+      // template arguments, and in order to prevent name clashes we use the+      // name of the Swift decl which does includes template argument names.+      appendIdentifier(nominal->getName().str());

 namespace {      Decl *VisitClassTemplateSpecializationDecl(                  const clang::ClassTemplateSpecializationDecl *decl) {-      // FIXME: We could import specializations, but perhaps only as unnamed-      // structural types.-      return nullptr;+      // `sema.isCompleteType` will try to instantiate the class template as a+      // side-effect and we rely on this here. `decl->getDefinition()` can+      // return nullptr before the call to sema and return its definition+      // afterwards.+      if (!Impl.getClangSema().isCompleteType(+              decl->getLocation(),+              Impl.getClangASTContext().getRecordType(decl))) {+        // If we got nullptr definition now it means the type is not complete.+        // We don't import incomplete types.+        return nullptr;+      }+      auto def = dyn_cast<clang::ClassTemplateSpecializationDecl>(+          decl->getDefinition());+      assert(def && "Class template instantiation didn't have definition");+      // This will instantiate all members of the specialization (and detect

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for constructing names+----------------------------------++Swift is a language that integrates with multiple languages (C, C++, ObjC,+ObjC++). To achieve interoperability symbols from other languages have to be+adapted in order to be integrated into Swift.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~++C and C++ structs use their original names and their owning modules. Since Swift+metadata symbols and value-witness-tables are not generated by the C compiler,+Swift generates them when C/C++ module is imported and stores them in the `__C`+module. This can be observed when mangling a Swift function that accepts a C/C+++struct as a parameter.++Importing C++ template instantiations behind typedef+~~~~~~~~~~~~~~~~~~~++The template instantiation is imported as a struct named `__CxxTemplateInst`+plus Itanium mangled type of the instantiation. Double underscore (denoting a+reserved C++ identifier) is used to discourage direct usage. The struct is

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_EXPLICIT_SPECIALIZATION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_EXPLICIT_SPECIALIZATION_H++struct SpecializedIntWrapper {+  int value;+  int getValue() const { return value; }+};++struct NonSpecializedIntWrapper {+  int value;+  int getValue() const { return value; }+};++template <class T>+struct MagicWrapper {+  T t;+  int doubleIfSpecializedElseTripple() const { return 3 * t.getValue(); }

 We could ignore explicit specializations of function templates, because they don't affect the API. Explicit specializations of class templates can dramatically change the API of the type. +### Class templates: importing instantiation behind typedef++Typedefs having template instantiation as their underlying type could be+imported as a non-generit struct with the given name.++```c+++// C++ header.++template<typename T>+class ClassTemplate {};++typedef ClassTemplate<int> ClassTemplateOfInt;+```++```swift+// C++ header imported to Swift.++struct ClassTemplateOfInt {}+```++In C++, multiple distinct typedeffed instantiations must resolve to the same+canonical type. We could implement this by creating a hidden intermediate struct+that typedef aliasses.++The struct could be named as `__CxxTemplateInst` plus Itanium mangled type of+the instantiation. For the example above the name of the hidden struct is+`__CxxTemplateInst13ClassTemplateIiE`. Double underscore (denoting a reserved+C++ identifier) is used to discourage direct usage. We chose Itanium mangling

 We could ignore explicit specializations of function templates, because they don't affect the API. Explicit specializations of class templates can dramatically change the API of the type. +### Class templates: importing instantiation behind typedef++Typedefs having template instantiation as their underlying type could be

 We could ignore explicit specializations of function templates, because they don't affect the API. Explicit specializations of class templates can dramatically change the API of the type. +### Class templates: importing instantiation behind typedef

 We could ignore explicit specializations of function templates, because they don't affect the API. Explicit specializations of class templates can dramatically change the API of the type. +### Class templates: importing instantiation behind typedef++Typedefs having template instantiation as their underlying type could be+imported as a non-generit struct with the given name.

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for constructing names+----------------------------------++Swift is a language that integrates with multiple languages (C, C++, ObjC,+ObjC++). To achieve interoperability symbols from other languages have to be+adapted in order to be integrated into Swift.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~++C and C++ structs use their original names and their owning modules. Since Swift+metadata symbols and value-witness-tables are not generated by the C compiler,+Swift generates them when C/C++ module is imported and stores them in the `__C`+module. This can be observed when mangling a Swift function that accepts a C/C+++struct as a parameter.++Importing C++ template instantiations behind typedef+~~~~~~~~~~~~~~~~~~~++The template instantiation is imported as a struct named `__CxxTemplateInst`+plus Itanium mangled type of the instantiation. Double underscore (denoting a+reserved C++ identifier) is used to discourage direct usage. The struct is+stored in the `__C` module, similarly to plain C++ structs.+

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for constructing names+----------------------------------++Swift is a language that integrates with multiple languages (C, C++, ObjC,+ObjC++). To achieve interoperability symbols from other languages have to be+adapted in order to be integrated into Swift.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~++C and C++ structs use their original names and their owning modules. Since Swift+metadata symbols and value-witness-tables are not generated by the C compiler,+Swift generates them when C/C++ module is imported and stores them in the `__C`+module. This can be observed when mangling a Swift function that accepts a C/C+++struct as a parameter.++Importing C++ template instantiations behind typedef+~~~~~~~~~~~~~~~~~~~++The template instantiation is imported as a struct named `__CxxTemplateInst`+plus Itanium mangled type of the instantiation. Double underscore (denoting a+reserved C++ identifier) is used to discourage direct usage. The struct is+stored in the `__C` module, similarly to plain C++ structs.

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for constructing names+----------------------------------++Swift is a language that integrates with multiple languages (C, C++, ObjC,+ObjC++). To achieve interoperability symbols from other languages have to be+adapted in order to be integrated into Swift.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~++C and C++ structs use their original names and their owning modules. Since Swift+metadata symbols and value-witness-tables are not generated by the C compiler,+Swift generates them when C/C++ module is imported and stores them in the `__C`+module. This can be observed when mangling a Swift function that accepts a C/C+++struct as a parameter.++Importing C++ template instantiations behind typedef

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not+restrict Swift-specific constructs like Swift type metadata, so the Swift+language may impose its own conventions in these cases.++Importing C and C++ structs+~~~~~~~~~~~~~~~~~~~~~~~~~~~++We don't touch the mangling of the original symbol. Since Swift metadata symbols+and value-witness-tables are not generated by the C/C++ compiler, Swift generates+them when C/C++ module is imported and stores them in the ``__C`` module. This can

 Some kinds need arguments, which precede ``Tf``. If the first character of the string literal is a digit ``[0-9]`` or an underscore ``_``, the identifier for the string literal is prefixed with an additional underscore ``_``.++Conventions for foreign symbols+-------------------------------++Swift interoperates with multiple other languages - C, C++, Objective-C, and+Objective-C++. Each of these languages defines their own mangling conventions,+so Swift must take care to follow them. However, these conventions do not+restrict Swift-specific constructs like Swift type metadata, so the Swift+language may impose its own conventions in these cases.

 class alignas(1 << DeclAlignInBits) Decl {     IsIncompatibleWithWeakReferences : 1   ); -  SWIFT_INLINE_BITFIELD(StructDecl, NominalTypeDecl, 1+1,-    /// True if this struct has storage for fields that aren't accessible in-    /// Swift.-    HasUnreferenceableStorage : 1,-    /// True if this struct is imported from C++ and not trivially copyable.-    IsCxxNotTriviallyCopyable : 1-  );-  +  SWIFT_INLINE_BITFIELD(+      StructDecl, NominalTypeDecl, 1 + 1,+      /// True if this struct has storage for fields that aren't accessible in+      /// Swift.+      HasUnreferenceableStorage : 1,+      /// True if this struct is imported from C++ and not trivial (because of a

 class alignas(1 << DeclAlignInBits) Decl {     IsIncompatibleWithWeakReferences : 1   ); -  SWIFT_INLINE_BITFIELD(StructDecl, NominalTypeDecl, 1+1,-    /// True if this struct has storage for fields that aren't accessible in-    /// Swift.-    HasUnreferenceableStorage : 1,-    /// True if this struct is imported from C++ and not trivially copyable.-    IsCxxNotTriviallyCopyable : 1-  );-  +  SWIFT_INLINE_BITFIELD(+      StructDecl, NominalTypeDecl, 1 + 1,+      /// True if this struct has storage for fields that aren't accessible in+      /// Swift.+      HasUnreferenceableStorage : 1,+      /// True if this struct is imported from C++ and not trivial (because of a

 namespace {     }   }; +  class AddressOnlyClangRecordTypeInfo final+      : public StructTypeInfoBase<AddressOnlyClangRecordTypeInfo, FixedTypeInfo,+                                  ClangFieldInfo> {+    const clang::RecordDecl *ClangDecl;++  public:+    AddressOnlyClangRecordTypeInfo(ArrayRef<ClangFieldInfo> fields,+                                   llvm::Type *storageType, Size size,+                                   Alignment align,+                                   const clang::RecordDecl *clangDecl)+        : StructTypeInfoBase(StructTypeInfoKind::AddressOnlyClangRecordTypeInfo,+                             fields, storageType, size,+                             // An address only type shouldn't assume any spare+                             // bits. So, give it an empty vector.

 template <class FieldImpl> class RecordField {  protected:   explicit RecordField(const TypeInfo &elementTI)-    : Layout(ElementLayout::getIncomplete(elementTI)) {}+      : Layout(ElementLayout::getIncomplete(elementTI)), Begin(0XFFF),+        End(0XFFF) {}

+// RUN: %target-swift-frontend -I %S/Inputs -enable-cxx-interop -emit-sil %s | %FileCheck %s++import TypeClassification++// Make sure that "StructWithDestructor" is marked as non-trivial by checking for a+// "destroy_addr".+// CHECK-LABEL: @$s4main24testStructWithDestructoryyF+// CHECK: [[AS:%.*]] = alloc_stack $StructWithDestructor+// CHECK: destroy_addr [[AS]]+// CHECK-LABEL: end sil function '$s4main24testStructWithDestructoryyF'+public func testStructWithDestructor() {+  let d = StructWithDestructor()+}++// Make sure that "HasMemberWithDestructor" is marked as non-trivial by checking

 enum class TypeMatchFlags { }; using TypeMatchOptions = OptionSet<TypeMatchFlags>; -/// TypeBase - Base class for all types in Swift.+/// TypeBase - Base class for all types which describe the Swift and SIL ASTs.

+// RUN: %target-swift-emit-ir %s -I %S/Inputs -enable-cxx-interop | %FileCheck %s++import CanonicalTypes++public func testCanonicalTypes() -> Bool {+  // multiple typedeffed types with the same canonical type are the same type+  // from the typechecking perspective.+  let magicNumber = MagicNumber()+  var wrappedMagicNumberA = WrappedMagicNumberA(t: magicNumber)++  var wrappedMagicNumberB: WrappedMagicNumberA =+    WrappedMagicNumberB(t: magicNumber)+  return wrappedMagicNumberA.callGetInt() == wrappedMagicNumberB.callGetInt()+}++// CHECK_NOT: __CxxTemplateInst

 ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,     }   } +  if (auto classTemplateSpecDecl =+          dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {+    if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {++      auto &astContext = classTemplateSpecDecl->getASTContext();+      // Itanium mangler produces valid Swift identifiers, use it to generate a name for+      // this instantiation. This name will not appear in the native code.+      clang::MangleContext *mangler = clang::ItaniumMangleContext::create(+          astContext, astContext.getDiagnostics());+      llvm::SmallString<128> storage;+      llvm::raw_svector_ostream buffer(storage);+      mangler->mangleTypeName(astContext.getRecordType(classTemplateSpecDecl),+                              buffer);++      // We reuse mangleTypeName() which returns RTTI typeinfo name, to get the mangled type.+      // Therefore we need to strip the '_ZTS' prefix, which we replace with '__CxxTemplateInst'+      // (a prefix reserved for C++ compiler usage).

 namespace {      Decl *VisitClassTemplateSpecializationDecl(                  const clang::ClassTemplateSpecializationDecl *decl) {-      // FIXME: We could import specializations, but perhaps only as unnamed-      // structural types.-      return nullptr;+      if (!Impl.getClangSema().isCompleteType(

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  int getInt() const { return 48; }+};++inline int forceInstantiating() {+  auto t = MagicWrapper<MagicNumber>();+  return t.callGetInt();+}++// MagicWrapper<MagicNumber> ClassTemplateSpecializationDecl has definition+// because function above forced the instantiation. Its members are fully+// instantiated, so nothing needs to be explicitly instantiated in swift.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_CANONICAL_TYPES_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_CANONICAL_TYPES_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  int getInt() const { return 24; }

+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop -Xcc -std=c++17)+//+// REQUIRES: executable_test++import EagerInstantiationProblems+import StdlibUnittest++var TemplatesTestSuite = TestSuite("TemplatesTestSuite")++TemplatesTestSuite.test("eager-instantiation-of-members") {+  // This will fail with:+  //+  // error: type 'int' cannot be used prior to '::' because it has no members+  //   T::getIntDoesNotExist();+  //+  // whereas in C++ this compiles. This is caused by ClangImporter eagerly+  // instantiating typedeffed templates and also its members.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  int getInt() const { return 24; }+};++inline MagicWrapper<MagicNumber> forceInstantiating() {+  return MagicWrapper<MagicNumber>();+}++// MagicWrapper<MagicNumber> ClassTemplateSpecializationDecl has definition+// because function above forced the instantiation. Its members are not+// instantiated though, we need to instantiate them in Swift.

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  int getInt() const { return 24; }+};++inline MagicWrapper<MagicNumber> forceInstantiating() {

+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DECL_WITH_DEFINITION_INCLUDING_MEMBERS_H++template<class T>+struct MagicWrapper {+  T t;+  int callGetInt() const {+    return t.getInt() + 5;+  }+};++struct MagicNumber {+  int getInt() const { return 48; }+};++inline int forceInstantiating() {

+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop -Xcc -std=c++17)+//+// REQUIRES: executable_test++import CanonicalTypes+import StdlibUnittest++var TemplatesTestSuite = TestSuite("TemplatesTestSuite")++TemplatesTestSuite.test("canonical-types") {+  // multiple typedeffed types with the same canonical type are the same type+  // from the typechecking perspective.

 ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,     }   } +  if (auto classTemplateSpecDecl =+          dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {+    if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {++      auto &astContext = classTemplateSpecDecl->getASTContext();+      // Itanium mangler produces valid Swift identifiers, use it to generate a name for+      // this instantiation. This name will not appear in the native code.+      clang::MangleContext *mangler = clang::ItaniumMangleContext::create(+          astContext, astContext.getDiagnostics());+      llvm::SmallString<128> storage;+      llvm::raw_svector_ostream buffer(storage);+      mangler->mangleTypeName(astContext.getRecordType(classTemplateSpecDecl),+                              buffer);++      // We reuse mangleTypeName() which returns RTTI typeinfo name, to get the mangled type.+      // Therefore we need to strip the '_ZTS' prefix, which we replace with '__CxxTemplateInst'+      // (a prefix reserved for C++ compiler usage).+      llvm::SmallString<128> mangledNameStorage;+      llvm::raw_svector_ostream mangledName(mangledNameStorage);+      mangledName << "__CxxTemplateInst" << buffer.str().drop_front(4);

 namespace {      Decl *VisitClassTemplateSpecializationDecl(                  const clang::ClassTemplateSpecializationDecl *decl) {-      // FIXME: We could import specializations, but perhaps only as unnamed-      // structural types.-      return nullptr;+      if (!Impl.getClangSema().isCompleteType(+              decl->getLocation(),+              Impl.getClangASTContext().getRecordType(decl))) {+        // Not importing incomplete types+        return nullptr;+      }+      auto def = dyn_cast<clang::ClassTemplateSpecializationDecl>(+          decl->getDefinition());+      assert(def && "Class template instantiation didn't have definition");+      Impl.getClangSema().InstantiateClassTemplateSpecializationMembers(

+// RUN: %empty-directory(%t)+// RUN: %target-build-swift %s -I %S/Inputs -o %t/address_only -Xfrontend -enable-cxx-interop+// RUN: %target-codesign %t/address_only+// RUN: %target-run %t/address_only 2&>1++// REQUIRES: executable_test++import TypeClassification+import StdlibUnittest++var AddressOnlyTestSuite = TestSuite("Address Only Types")++AddressOnlyTestSuite.test("Test struct with copy constructor") {+  let obj = StructWithCopyConstructorAndValue(value: 42)+  expectEqual(obj.value, 42)+}++AddressOnlyTestSuite.test("Test struct with member with copy constructor") {+  let member = StructWithCopyConstructorAndValue(value: 42)+  let obj = StructWithMemberWithCopyConstructor(member: member)+  expectEqual(obj.member.value, 42)+}++AddressOnlyTestSuite.test(+  "Test struct with copy constructor and member with copy constructor"+) {+  let member = StructWithCopyConstructorAndValue(value: 42)+  let obj = StructWithCopyConstructorAndMemberWithCopyConstructor(+    member: member+  )+  expectEqual(obj.member.value, 42)+}

+// RUN: %empty-directory(%t)

 struct StructDeletedDestructor {   ~StructDeletedDestructor() = delete; }; +struct StructWithCopyConstructorAndValue {+  int value;+  StructWithCopyConstructorAndValue(+      const StructWithCopyConstructorAndValue &other)+      : value(other.value) {}+};++struct StructWithMemberWithCopyConstructor {+  StructWithCopyConstructorAndValue member;+};++struct StructWithCopyConstructorAndMemberWithCopyConstructor {

 struct StructDeletedDestructor {   ~StructDeletedDestructor() = delete; }; +struct StructWithCopyConstructorAndValue {+  int value;+  StructWithCopyConstructorAndValue(+      const StructWithCopyConstructorAndValue &other)+      : value(other.value) {}+};++struct StructWithMemberWithCopyConstructor {

 class ClangRecordLowering {   }    /// Add information to track a value field at the current offset.-  void addFieldInfo(VarDecl *swiftField, const LoadableTypeInfo &fieldType) {-    unsigned explosionSize = fieldType.getExplosionSize();+  void addFieldInfo(VarDecl *swiftField, const FixedTypeInfo &fieldType) {+    unsigned explosionSize = SwiftDecl->getStoredProperties().size();

 namespace {     }   }; +  class AddressOnlyClangRecordTypeInfo final+      : public StructTypeInfoBase<AddressOnlyClangRecordTypeInfo, FixedTypeInfo,+                                  ClangFieldInfo> {+    const clang::RecordDecl *ClangDecl;++  public:+    AddressOnlyClangRecordTypeInfo(ArrayRef<ClangFieldInfo> fields,+                                   llvm::Type *storageType, Size size,+                                   Alignment align,+                                   const clang::RecordDecl *clangDecl)+        : StructTypeInfoBase(StructTypeInfoKind::AddressOnlyClangRecordTypeInfo,+                             fields, storageType, size,+                             // Create an empty SpareBitVector with a width of

 namespace {       }     }   };-  ++  class ClangRecordAddressOnlyTypeInfo final+      : public StructTypeInfoBase<ClangRecordAddressOnlyTypeInfo, FixedTypeInfo,+                                  ClangFieldInfo> {+    const clang::RecordDecl *ClangDecl;++  public:+    ClangRecordAddressOnlyTypeInfo(ArrayRef<ClangFieldInfo> fields,+                                   llvm::Type *storageType, Size size,+                                   SpareBitVector &&spareBits, Alignment align,+                                   const clang::RecordDecl *clangDecl)+        : StructTypeInfoBase(StructTypeInfoKind::ClangRecordAddressOnlyTypeInfo,+                             fields, storageType, size, std::move(spareBits),+                             align, IsPOD, IsNotBitwiseTakable, IsFixedSize),+          ClangDecl(clangDecl) {+      (void)ClangDecl;

 class ClangRecordLowering {    const TypeInfo *createTypeInfo(llvm::StructType *llvmType) {     llvmType->setBody(LLVMFields, /*packed*/ true);+    if (SwiftType.getStructOrBoundGenericStruct()+            ->isCxxNotTriviallyCopyable()) {+      return ClangRecordAddressOnlyTypeInfo::create(+          FieldInfos, llvmType, TotalStride, std::move(SpareBits),

 class ClangRecordLowering {    const TypeInfo *createTypeInfo(llvm::StructType *llvmType) {     llvmType->setBody(LLVMFields, /*packed*/ true);+    if (SwiftType.getStructOrBoundGenericStruct()+            ->isCxxNotTriviallyCopyable()) {+      return ClangRecordAddressOnlyTypeInfo::create(+          FieldInfos, llvmType, TotalStride, std::move(SpareBits),

 class ClangRecordLowering {    const TypeInfo *createTypeInfo(llvm::StructType *llvmType) {     llvmType->setBody(LLVMFields, /*packed*/ true);+    if (SwiftType.getStructOrBoundGenericStruct()+            ->isCxxNotTriviallyCopyable()) {+      return ClangRecordAddressOnlyTypeInfo::create(+          FieldInfos, llvmType, TotalStride, std::move(SpareBits),

 class ClangRecordLowering {    const TypeInfo *createTypeInfo(llvm::StructType *llvmType) {     llvmType->setBody(LLVMFields, /*packed*/ true);+    if (SwiftType.getStructOrBoundGenericStruct()+            ->isCxxNotTriviallyCopyable()) {+      return ClangRecordAddressOnlyTypeInfo::create(+          FieldInfos, llvmType, TotalStride, std::move(SpareBits),

 namespace {       }     }   };-  ++  class ClangRecordAddressOnlyTypeInfo final+      : public StructTypeInfoBase<ClangRecordAddressOnlyTypeInfo, FixedTypeInfo,+                                  ClangFieldInfo> {+    const clang::RecordDecl *ClangDecl;++  public:+    ClangRecordAddressOnlyTypeInfo(ArrayRef<ClangFieldInfo> fields,+                                   llvm::Type *storageType, Size size,+                                   SpareBitVector &&spareBits, Alignment align,+                                   const clang::RecordDecl *clangDecl)+        : StructTypeInfoBase(StructTypeInfoKind::ClangRecordAddressOnlyTypeInfo,+                             fields, storageType, size, std::move(spareBits),+                             align, IsPOD, IsNotBitwiseTakable, IsFixedSize),+          ClangDecl(clangDecl) {+      (void)ClangDecl;+    }++    TypeLayoutEntry *buildTypeLayoutEntry(IRGenModule &IGM,+                                          SILType T) const override {+      return IGM.typeLayoutCache.getOrCreateScalarEntry(*this, T);+    }++    void initializeFromParams(IRGenFunction &IGF, Explosion &params,+                              Address addr, SILType T,+                              bool isOutlined) const override {+      llvm_unreachable("Cannot initialize address-only type from params.");

 namespace {       }     }   };-  ++  class ClangRecordAddressOnlyTypeInfo final+      : public StructTypeInfoBase<ClangRecordAddressOnlyTypeInfo, FixedTypeInfo,

 namespace {       }     }   };-  ++  class ClangRecordAddressOnlyTypeInfo final