[cxx-interop] Assign correct owning module to class template specializations

When importing C++ class template specializations into Swift, we were assigning the owning module to the imported Swift structs inconsistently. For specializations that had a typedef (or a using-decl), we assumed the module that declares the typedef to be the owning module for the specialization. For specializations that do not have a typedef, we assumed the module that declares the class template itself to be the owning module. This changes the behavior to always assume the latter.

rdar://158589803

Author: egorzhdan

include/swift/AST/ClangModuleLoader.h

@@ -316,6 +316,8 @@ class ClangModuleLoader : public ModuleLoader {
   virtual SwiftLookupTable *
   findLookupTable(const clang::Module *clangModule) = 0;
 
+  virtual const clang::Module *getClangOwningModule(ClangNode Node) const = 0;
+
   virtual DeclName
   importName(const clang::NamedDecl *D,
              clang::DeclarationName givenName = clang::DeclarationName()) = 0;

include/swift/ClangImporter/ClangImporter.h

@@ -487,7 +487,7 @@ class ClangImporter final : public ClangModuleLoader {
   bool dumpPrecompiledModule(StringRef modulePath, StringRef outputPath);
 
   bool runPreprocessor(StringRef inputPath, StringRef outputPath);
-  const clang::Module *getClangOwningModule(ClangNode Node) const;
+  const clang::Module *getClangOwningModule(ClangNode Node) const override;
   bool hasTypedef(const clang::Decl *typeDecl) const;
 
   void verifyAllModules() override;

lib/AST/Decl.cpp

@@ -932,16 +932,18 @@ static ModuleDecl *getModuleContextForNameLookupForCxxDecl(const Decl *decl) {
   if (!ctx.LangOpts.EnableCXXInterop)
     return nullptr;
 
+  auto clangImporter = ctx.getClangModuleLoader();
+  ASSERT(clangImporter && "ClangImporter required");
+
   // When we clone members for base classes the cloned members have no
   // corresponding Clang nodes. Look up the original imported declaration to
   // figure out what Clang module does the cloned member originate from.
   bool isClonedMember = false;
   if (auto VD = dyn_cast<ValueDecl>(decl))
-    if (auto loader = ctx.getClangModuleLoader())
-      if (auto original = loader->getOriginalForClonedMember(VD)) {
-        isClonedMember = true;
-        decl = original;
-      }
+    if (auto original = clangImporter->getOriginalForClonedMember(VD)) {
+      isClonedMember = true;
+      decl = original;
+    }
 
   if (!decl->hasClangNode())
     return nullptr;
@@ -956,15 +958,15 @@ static ModuleDecl *getModuleContextForNameLookupForCxxDecl(const Decl *decl) {
     return nullptr;
   }
 
-  auto clangModule = decl->getClangDecl()->getOwningModule();
+  auto clangModule = clangImporter->getClangOwningModule(decl->getClangDecl());
   if (!clangModule)
     return nullptr;
 
   // Swift groups all submodules of a Clang module together, and imports them as
   // a single top-level module.
   clangModule = clangModule->getTopLevelModule();
 
-  return ctx.getClangModuleLoader()->getWrapperForModule(clangModule);
+  return clangImporter->getWrapperForModule(clangModule);
 }
 
 ModuleDecl *Decl::getModuleContextForNameLookup() const {

lib/ClangImporter/ClangImporter.cpp

@@ -3199,13 +3199,13 @@ getClangOwningModule(ClangNode Node, const clang::ASTContext &ClangCtx) {
         originalDecl = pattern;
       }
     }
-    if (!originalDecl->hasOwningModule()) {
-      if (auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(D)) {
-        if (auto pattern = cxxRecordDecl->getTemplateInstantiationPattern()) {
-          // Class template instantiations sometimes don't have an owning Clang
-          // module, if the instantiation is not typedef-ed.
-          originalDecl = pattern;
-        }
+    if (auto classTemplateSpecDecl =
+            dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {
+      if (auto pattern =
+              classTemplateSpecDecl->getTemplateInstantiationPattern()) {
+        // Class template instantiations sometimes don't have an owning Clang
+        // module, if the instantiation is not typedef-ed.
+        originalDecl = pattern;
       }
     }
 

test/Interop/Cxx/stdlib/Inputs/module.modulemap

@@ -16,6 +16,12 @@ module StdVector {
   export *
 }
 
+module StdVectorNoCPlusPlusRequirement {
+  header "std-vector-no-cplusplus-requirement.h"
+  // NO requires cplusplus
+  export *
+}
+
 module StdSpan {
   header "std-span.h"
   requires cplusplus

test/Interop/Cxx/stdlib/Inputs/std-vector-no-cplusplus-requirement.h

@@ -0,0 +1,3 @@
+#include <vector>
+
+using VectorOfFloat = std::vector<float>;

test/Interop/Cxx/stdlib/use-std-vector-typechecker.swift

@@ -2,6 +2,7 @@
 // XFAIL: OS=linux-androideabi
 
 import StdVector
+import StdVectorNoCPlusPlusRequirement
 import CxxStdlib
 
 func takeCopyable<T: Copyable>(_ x: T) {} 
@@ -20,3 +21,11 @@ let vecPointer = VectorOfPointer()
 takeCopyable(vecPointer)
 takeCxxVector(vecPointer)
 // CHECK-NOT: error
+
+// Make sure that a specialization of std::vector that is declared in a Clang
+// module which does not declare 'requires cplusplus' is still conformed to
+// CxxVector.
+let vecFloat = VectorOfFloat()
+takeCopyable(vecFloat)
+takeCxxVector(vecFloat)
+// CHECK-NOT: error