[cxx-interop] serialize x-refs for class template specializations

Author: hyp

lib/ClangImporter/ClangImporter.cpp

@@ -4837,13 +4837,19 @@ TinyPtrVector<ValueDecl *> CXXNamespaceMemberLookup::evaluate(
   auto &ctx = namespaceDecl->getASTContext();
 
   TinyPtrVector<ValueDecl *> result;
+  llvm::SmallPtrSet<clang::NamedDecl *, 8> importedDecls;
   for (auto redecl : clangNamespaceDecl->redecls()) {
     auto allResults = evaluateOrDefault(
         ctx.evaluator, ClangDirectLookupRequest({namespaceDecl, redecl, name}),
         {});
 
     for (auto found : allResults) {
       auto clangMember = found.get<clang::NamedDecl *>();
+      auto it = importedDecls.insert(clangMember);
+      // Skip over members already found during lookup in
+      // prior redeclarations.
+      if (!it.second)
+        continue;
       if (auto import =
               ctx.getClangModuleLoader()->importDeclDirectly(clangMember))
         result.push_back(cast<ValueDecl>(import));

lib/Serialization/Deserialization.cpp

@@ -43,6 +43,7 @@
 #include "clang/AST/Attr.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/AttributeCommonInfo.h"
+#include "clang/Index/USRGeneration.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
@@ -2424,7 +2425,28 @@ ModuleFile::resolveCrossReference(ModuleID MID, uint32_t pathLen) {
         break;
       }
 
-      if (!privateDiscriminator.empty()) {
+      if (importedFromClang &&
+          !privateDiscriminator.empty()) {
+        // This is a clang imported class template, that's
+        // serialized using original template name, and
+        // its USR that denotes the specific specialization.
+        auto members = nominal->lookupDirect(memberName);
+        for (const auto &m: members) {
+          if (!m->hasClangNode())
+            continue;
+          if (auto *ctd = dyn_cast<clang::ClassTemplateDecl>(m->getClangDecl())) {
+            for (const auto *spec: ctd->specializations()) {
+              llvm::SmallString<128> buffer;
+              clang::index::generateUSRForDecl(spec, buffer);
+              if (privateDiscriminator.str() == buffer) {
+                if (auto import =
+                  getContext().getClangModuleLoader()->importDeclDirectly(spec))
+                  values.push_back(cast<ValueDecl>(import));
+              }
+            }
+          }
+        }
+      } else if (!privateDiscriminator.empty()) {
         ModuleDecl *searchModule = M;
         if (!searchModule)
           searchModule = nominal->getModuleContext();

lib/Serialization/Serialization.cpp

@@ -55,6 +55,7 @@
 #include "swift/Strings.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/Index/USRGeneration.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
@@ -2116,8 +2117,25 @@ void Serializer::writeCrossReference(const DeclContext *DC, uint32_t pathLen) {
 
     bool isProtocolExt = DC->getParent()->getExtendedProtocolDecl();
 
+    Identifier name = generic->getName();
+    if (generic->hasClangNode()) {
+      if (auto *ctsd = dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(generic->getClangDecl())) {
+        auto it = name.str().find("<");
+        if (it != StringRef::npos) {
+          // Serialize a C++ class template specialization name as original
+          // class template name, and use its USR as the discriminator, that
+          // will let Swift find the correct specialization when this cross
+          // reference is deserialized.
+          name = getASTContext().getIdentifier(name.str().substr(0, it));
+          assert(discriminator.empty());
+          llvm::SmallString<128> buffer;
+          clang::index::generateUSRForDecl(ctsd, buffer);
+          discriminator = getASTContext().getIdentifier(buffer.str());
+        }
+      }
+    }
     XRefTypePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
-                                        addDeclBaseNameRef(generic->getName()),
+                                        addDeclBaseNameRef(name),
                                         addDeclBaseNameRef(discriminator),
                                         isProtocolExt,
                                         generic->hasClangNode());
@@ -2290,8 +2308,26 @@ void Serializer::writeCrossReference(const Decl *D) {
       discriminator = containingFile->getDiscriminatorForPrivateDecl(type);
     }
 
+    Identifier name = type->getName();
+    if (type->hasClangNode()) {
+      if (auto *ctsd = dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(type->getClangDecl())) {
+        auto it = name.str().find("<");
+        if (it != StringRef::npos) {
+          // Serialize a C++ class template specialization name as original
+          // class template name, and use its USR as the discriminator, that
+          // will let Swift find the correct specialization when this cross
+          // reference is deserialized.
+          name = getASTContext().getIdentifier(name.str().substr(0, it));
+          assert(discriminator.empty());
+          llvm::SmallString<128> buffer;
+          clang::index::generateUSRForDecl(ctsd, buffer);
+          discriminator = getASTContext().getIdentifier(buffer.str());
+        }
+      }
+    }
+
     XRefTypePathPieceLayout::emitRecord(Out, ScratchRecord, abbrCode,
-                                        addDeclBaseNameRef(type->getName()),
+                                        addDeclBaseNameRef(name),
                                         addDeclBaseNameRef(discriminator),
                                         isProtocolExt, D->hasClangNode());
     return;