[cxx-interop] Re-implement template mangling.

Instead of mangling class template specializations with the prefix "__CxxTemplateInst," simply set the decl name as the class templates plus the types that it is specialized on (so `vector<Int>` rather than `__CxxTemplateInstNSt3__16vectorIi...`).

This is mainly to improve diagnostics. As a side effect of this change, if anyone copies the name of a class template specializaiton from an error/warning and uses it in source code, the compiler will error (that class templates aren't available in swift) rather than silently passing only to cause serailization failures down the road.

Author: zoecarver

include/swift/AST/ASTContext.h

@@ -1455,6 +1455,8 @@ class ASTContext final {
   /// Finds the address of the given symbol. If `libraryHandleHint` is non-null,
   /// search within the library.
   void *getAddressOfSymbol(const char *name, void *libraryHandleHint = nullptr);
+  
+  Type getNamedSwiftType(ModuleDecl *module, StringRef name);
 
 private:
   friend Decl;

lib/AST/ASTContext.cpp

@@ -55,6 +55,7 @@
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/StringExtras.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Strings.h"
 #include "swift/Subsystems.h"
 #include "swift/SymbolGraphGen/SymbolGraphOptions.h"
@@ -5306,8 +5307,6 @@ ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
     }
 
     // Pull SIMD types of size 2...4 from the SIMD module, if it exists.
-    // FIXME: Layering violation to use the ClangImporter's define.
-    const unsigned SWIFT_MAX_IMPORTED_SIMD_ELEMENTS = 4;
     if (auto simd = getLoadedModule(Id_simd)) {
 #define MAP_SIMD_TYPE(BASENAME, _, __)                                  \
       {                                                                 \
@@ -5354,7 +5353,6 @@ ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
   conditionallyAddTrivial(nominal, getSwiftId(KnownFoundationEntity::NSZone), Id_ObjectiveC, true);
   conditionallyAddTrivial(nominal, Id_CGFloat, getIdentifier("CoreGraphics"));
   conditionallyAddTrivial(nominal, Id_CGFloat, getIdentifier("CoreFoundation"));
-  const unsigned SWIFT_MAX_IMPORTED_SIMD_ELEMENTS = 4;
 #define MAP_SIMD_TYPE(BASENAME, _, __)                                         \
   {                                                                            \
     char name[] = #BASENAME "0";                                               \
@@ -6252,3 +6250,39 @@ void *ASTContext::getAddressOfSymbol(const char *name,
 #endif
   return address;
 }
+
+Type ASTContext::getNamedSwiftType(ModuleDecl *module, StringRef name) {
+  if (!module)
+    return Type();
+
+  // Look for the type.
+  Identifier identifier = getIdentifier(name);
+  SmallVector<ValueDecl *, 2> results;
+
+  // Check if the lookup we're about to perform a lookup within is
+  // a Clang module.
+  for (auto *file : module->getFiles()) {
+    if (auto clangUnit = dyn_cast<ClangModuleUnit>(file)) {
+      // If we have an overlay, look in the overlay. Otherwise, skip
+      // the lookup to avoid infinite recursion.
+      if (auto module = clangUnit->getOverlayModule())
+        module->lookupValue(identifier, NLKind::UnqualifiedLookup, results);
+    } else {
+      file->lookupValue(identifier, NLKind::UnqualifiedLookup, results);
+    }
+  }
+
+  if (results.size() != 1)
+    return Type();
+
+  auto decl = dyn_cast<TypeDecl>(results.front());
+  if (!decl)
+    return Type();
+
+  assert(!decl->hasClangNode() && "picked up the original type?");
+
+  if (auto *nominalDecl = dyn_cast<NominalTypeDecl>(decl))
+    return nominalDecl->getDeclaredType();
+  return decl->getDeclaredInterfaceType();
+}
+

lib/AST/ClangTypeConverter.cpp

@@ -43,22 +43,7 @@ using namespace swift;
 namespace {
 
 static Type getNamedSwiftType(ModuleDecl *stdlib, StringRef name) {
-  auto &ctx = stdlib->getASTContext();
-  SmallVector<ValueDecl*, 1> results;
-  stdlib->lookupValue(ctx.getIdentifier(name), NLKind::QualifiedLookup,
-                      results);
-
-  // If we have one single type decl, and that decl has been
-  // type-checked, return its declared type.
-  //
-  // ...non-type-checked types should only ever show up here because
-  // of test cases using -enable-source-import, but unfortunately
-  // that's a real thing.
-  if (results.size() == 1) {
-    if (auto typeDecl = dyn_cast<TypeDecl>(results[0]))
-      return typeDecl->getDeclaredInterfaceType();
-  }
-  return Type();
+  return stdlib->getASTContext().getNamedSwiftType(stdlib, name);
 }
 
 static clang::QualType

lib/ClangImporter/ImportName.cpp

@@ -2179,29 +2179,58 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
       return importNameImpl(classTemplateSpecDecl->getSpecializedTemplate(),
                             version, givenName);
     if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {
-
-      auto &astContext = classTemplateSpecDecl->getASTContext();
-      // Itanium mangler produces valid Swift identifiers, use it to generate a name for
-      // this instantiation.
-      std::unique_ptr<clang::MangleContext> mangler{
-          clang::ItaniumMangleContext::create(astContext,
-                                              astContext.getDiagnostics())};
+      // When constructing the name of a C++ template, don't expand all the
+      // template, only expand one layer. Here we want to prioritize
+      // readability over total completeness.
       llvm::SmallString<128> storage;
       llvm::raw_svector_ostream buffer(storage);
-      mangler->mangleTypeName(astContext.getRecordType(classTemplateSpecDecl),
-                              buffer);
-
-      // The Itanium mangler does not provide a way to get the mangled
-      // representation of a type. Instead, we call mangleTypeName() that
-      // returns the name of the RTTI typeinfo symbol, and remove the _ZTS
-      // prefix. Then we prepend __CxxTemplateInst to reduce chances of conflict
-      // with regular C and C++ structs.
-      llvm::SmallString<128> mangledNameStorage;
-      llvm::raw_svector_ostream mangledName(mangledNameStorage);
-      assert(buffer.str().take_front(4) == "_ZTS");
-      mangledName << CXX_TEMPLATE_INST_PREFIX << buffer.str().drop_front(4);
-
-      baseName = swiftCtx.getIdentifier(mangledName.str()).get();
+      D->printName(buffer);
+      buffer << "<";
+      llvm::interleaveComma(classTemplateSpecDecl->getTemplateArgs().asArray(),
+                            buffer,
+                            [&buffer, this, version](const clang::TemplateArgument& arg) {
+        // Use import name here so builtin types such as "int" map to their
+        // Swift equivalent ("Int32").
+        if (arg.getKind() == clang::TemplateArgument::Type) {
+          auto ty = arg.getAsType().getTypePtr();
+          if (auto builtin = dyn_cast<clang::BuiltinType>(ty)) {
+            auto &ctx = swiftCtx;
+            Type swiftType = nullptr;
+            switch (builtin->getKind()) {
+            case clang::BuiltinType::Void:
+              swiftType = ctx.getNamedSwiftType(ctx.getStdlibModule(), "Void");
+              break;
+      #define MAP_BUILTIN_TYPE(CLANG_BUILTIN_KIND, SWIFT_TYPE_NAME)            \
+            case clang::BuiltinType::CLANG_BUILTIN_KIND:                       \
+              swiftType = ctx.getNamedSwiftType(ctx.getStdlibModule(),         \
+                                                #SWIFT_TYPE_NAME);             \
+              break;
+      #define MAP_BUILTIN_CCHAR_TYPE(CLANG_BUILTIN_KIND, SWIFT_TYPE_NAME)      \
+            case clang::BuiltinType::CLANG_BUILTIN_KIND:                       \
+              swiftType = ctx.getNamedSwiftType(ctx.getStdlibModule(),         \
+                                                #SWIFT_TYPE_NAME);             \
+              break;
+      #include "swift/ClangImporter/BuiltinMappedTypes.def"
+              default:
+                break;
+            }
+            
+            if (swiftType) {
+              if (auto nominal = dyn_cast<NominalType>(swiftType->getCanonicalType())) {
+                buffer << nominal->getDecl()->getNameStr();
+                return;
+              }
+            }
+          } else if (auto namedArg = dyn_cast_or_null<clang::NamedDecl>(ty->getAsTagDecl())) {
+            importNameImpl(namedArg, version, clang::DeclarationName()).getDeclName().print(buffer);
+            return;
+          }
+        }
+        buffer << "_";
+      });
+      buffer << ">";
+
+      baseName = swiftCtx.getIdentifier(buffer.str()).get();
     }
   }
 

lib/ClangImporter/ImportType.cpp

@@ -3251,38 +3251,7 @@ bool ClangImporter::Implementation::canImportFoundationModule() {
 
 Type ClangImporter::Implementation::getNamedSwiftType(ModuleDecl *module,
                                                       StringRef name) {
-  if (!module)
-    return Type();
-
-  // Look for the type.
-  Identifier identifier = SwiftContext.getIdentifier(name);
-  SmallVector<ValueDecl *, 2> results;
-
-  // Check if the lookup we're about to perform a lookup within is
-  // a Clang module.
-  for (auto *file : module->getFiles()) {
-    if (auto clangUnit = dyn_cast<ClangModuleUnit>(file)) {
-      // If we have an overlay, look in the overlay. Otherwise, skip
-      // the lookup to avoid infinite recursion.
-      if (auto module = clangUnit->getOverlayModule())
-        module->lookupValue(identifier, NLKind::UnqualifiedLookup, results);
-    } else {
-      file->lookupValue(identifier, NLKind::UnqualifiedLookup, results);
-    }
-  }
-
-  if (results.size() != 1)
-    return Type();
-
-  auto decl = dyn_cast<TypeDecl>(results.front());
-  if (!decl)
-    return Type();
-
-  assert(!decl->hasClangNode() && "picked up the original type?");
-
-  if (auto *nominalDecl = dyn_cast<NominalTypeDecl>(decl))
-    return nominalDecl->getDeclaredType();
-  return decl->getDeclaredInterfaceType();
+  return SwiftContext.getNamedSwiftType(module, name);
 }
 
 Type ClangImporter::Implementation::getNamedSwiftType(StringRef moduleName,

lib/Parse/Parser.cpp

@@ -1360,8 +1360,8 @@ DeclNameRef swift::formDeclNameRef(ASTContext &ctx,
   // We cannot import when the base name is not an identifier.
   if (baseName.empty())
     return DeclNameRef();
-  if (!Lexer::isIdentifier(baseName) && !Lexer::isOperator(baseName))
-    return DeclNameRef();
+//  if (!Lexer::isIdentifier(baseName) && !Lexer::isOperator(baseName))
+//    return DeclNameRef();
 
   // Get the identifier for the base name. Special-case `init`.
   DeclBaseName baseNameId;