[Clang][ASTImporter] Added visibility check for ClassTemplateDecl.

[balazske]

Summary

ASTImporter makes now difference between class templates with same
name in different translation units if these are not visible outside.

[balazske]

Ping

clang/lib/AST/ASTImporter.cpp

if (!DC->isFunctionOrMethod()) {
     for (auto *FoundDecl : FoundDecls) {
       if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary |
                                               Decl::IDNS_TagFriend))
         continue;
 
       Decl *Found = FoundDecl;
       auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
       if (FoundTemplate) {
+        if (!hasSameVisibilityContext(FoundTemplate, D))
+          continue;
 
         if (IsStructuralMatch(D, FoundTemplate)) {
           ClassTemplateDecl *TemplateWithDef =
               getTemplateDefinition(FoundTemplate);
           if (D->isThisDeclarationADefinition() && TemplateWithDef)
             return Importer.MapImported(D, TemplateWithDef);
           if (!FoundByLookup)
             FoundByLookup = FoundTemplate;

clang/unittests/AST/ASTImporterVisibilityTest.cpp

struct GetTypedefNamePattern {
   BindableMatcher<Decl> operator()() { return typedefNameDecl(hasName("T")); }
 };
 struct GetFunTemplPattern {
   using DeclTy = FunctionTemplateDecl;
   BindableMatcher<Decl> operator()() {
     return functionTemplateDecl(hasName("f"));
   }
 };
+struct GetClassTemplPattern {
+  using DeclTy = ClassTemplateDecl;
+  BindableMatcher<Decl> operator()() { return classTemplateDecl(hasName("X")); }
+};
 
 // Values for the value-parameterized test fixtures.
 // FunctionDecl:
 const auto *ExternF = "void f();";
 const auto *StaticF = "static void f();";
 const auto *AnonF = "namespace { void f(); }";
 // VarDecl:
 const auto *ExternV = "extern int v;";

 const auto *ExternTypedef = "typedef int T;";
 const auto *AnonTypedef = "namespace { typedef int T; }";
 const auto *ExternUsing = "using T = int;";
 const auto *AnonUsing = "namespace { using T = int; }";
 // FunctionTemplateDecl:
 const auto *ExternFT = "template <class> void f();";
 const auto *StaticFT = "template <class> static void f();";
 const auto *AnonFT = "namespace { template <class> void f(); }";
+// ClassTemplateDecl:
+const auto *ExternCT = "template <class> class X;";
+const auto *AnonCT = "namespace { template <class> class X; }";
 
 // First value in tuple: Compile options.
 // Second value in tuple: Source code to be used in the test.
 using ImportVisibilityChainParams =
     ::testing::WithParamInterface<std::tuple<ArgVector, const char *>>;
 // Fixture to test the redecl chain of Decls with the same visibility. Gtest
 // makes it possible to have either value-parameterized or type-parameterized
 // fixtures. However, we cannot have both value- and type-parameterized test

 };
 
 // Manual instantiation of the fixture with each type.
 using ImportFunctionsVisibilityChain = ImportVisibilityChain<GetFunPattern>;
 using ImportVariablesVisibilityChain = ImportVisibilityChain<GetVarPattern>;
 using ImportClassesVisibilityChain = ImportVisibilityChain<GetClassPattern>;
 using ImportFunctionTemplatesVisibilityChain =
     ImportVisibilityChain<GetFunTemplPattern>;
+using ImportClassTemplatesVisibilityChain =
+    ImportVisibilityChain<GetClassTemplPattern>;
 
 // Value-parameterized test for functions.
 TEST_P(ImportFunctionsVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
 // Value-parameterized test for variables.
 TEST_P(ImportVariablesVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
 // Value-parameterized test for classes.
 TEST_P(ImportClassesVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
 // Value-parameterized test for function templates.
 TEST_P(ImportFunctionTemplatesVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
+// Value-parameterized test for class templates.
+TEST_P(ImportClassTemplatesVisibilityChain, ImportChain) {
+  TypedTest_ImportChain();
+}
 
 // Automatic instantiation of the value-parameterized tests.
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctionsVisibilityChain,
                         ::testing::Combine(
                            DefaultTestValuesForRunOptions,
                            ::testing::Values(ExternF, StaticF, AnonF)), );
 INSTANTIATE_TEST_CASE_P(
     ParameterizedTests, ImportVariablesVisibilityChain,
INSTANTIATE_TEST_CASE_P(
     ::testing::Combine(
         DefaultTestValuesForRunOptions,
         ::testing::Values(ExternC, AnonC)), );
 INSTANTIATE_TEST_CASE_P(ParameterizedTests,
                         ImportFunctionTemplatesVisibilityChain,
                         ::testing::Combine(DefaultTestValuesForRunOptions,
                                            ::testing::Values(ExternFT, StaticFT,
                                                              AnonFT)), );
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClassTemplatesVisibilityChain,
+                        ::testing::Combine(DefaultTestValuesForRunOptions,
+                                           ::testing::Values(ExternCT,
+                                                             AnonCT)), );
 
 // First value in tuple: Compile options.
 // Second value in tuple: Tuple with informations for the test.
 // Code for first import (or initial code), code to import, whether the `f`
 // functions are expected to be linked in a declaration chain.
 // One value of this tuple is combined with every value of compile options.
 // The test can have a single tuple as parameter only.
 using ImportVisibilityParams = ::testing::WithParamInterface<
protected:
   }
 };
 using ImportFunctionsVisibility = ImportVisibility<GetFunPattern>;
 using ImportVariablesVisibility = ImportVisibility<GetVarPattern>;
 using ImportClassesVisibility = ImportVisibility<GetClassPattern>;
 using ImportEnumsVisibility = ImportVisibility<GetEnumPattern>;
 using ImportTypedefNameVisibility = ImportVisibility<GetTypedefNamePattern>;
 using ImportFunctionTemplatesVisibility = ImportVisibility<GetFunTemplPattern>;
+using ImportClassTemplatesVisibility = ImportVisibility<GetClassTemplPattern>;
 
 // FunctionDecl.
 TEST_P(ImportFunctionsVisibility, ImportAfter) {
   TypedTest_ImportAfter();
 }
 TEST_P(ImportFunctionsVisibility, ImportAfterImport) {
   TypedTest_ImportAfterImport();
 }

 }
 // FunctionTemplateDecl.
 TEST_P(ImportFunctionTemplatesVisibility, ImportAfter) {
   TypedTest_ImportAfter();
 }
 TEST_P(ImportFunctionTemplatesVisibility, ImportAfterImport) {
   TypedTest_ImportAfterImport();
 }
+// ClassTemplateDecl.
+TEST_P(ImportClassTemplatesVisibility, ImportAfter) { TypedTest_ImportAfter(); }
+TEST_P(ImportClassTemplatesVisibility, ImportAfterImport) {
+  TypedTest_ImportAfterImport();
+}
 
 const bool ExpectLinkedDeclChain = true;
 const bool ExpectUnlinkedDeclChain = false;
 
 INSTANTIATE_TEST_CASE_P(
     ParameterizedTests, ImportFunctionsVisibility,
     ::testing::Combine(
         DefaultTestValuesForRunOptions,
::testing::Combine(
             std::make_tuple(ExternFT, StaticFT, ExpectUnlinkedDeclChain),
             std::make_tuple(ExternFT, AnonFT, ExpectUnlinkedDeclChain),
             std::make_tuple(StaticFT, ExternFT, ExpectUnlinkedDeclChain),
             std::make_tuple(StaticFT, StaticFT, ExpectUnlinkedDeclChain),
             std::make_tuple(StaticFT, AnonFT, ExpectUnlinkedDeclChain),
             std::make_tuple(AnonFT, ExternFT, ExpectUnlinkedDeclChain),
             std::make_tuple(AnonFT, StaticFT, ExpectUnlinkedDeclChain),
             std::make_tuple(AnonFT, AnonFT, ExpectUnlinkedDeclChain))), );
-
+INSTANTIATE_TEST_CASE_P(
+    ParameterizedTests, ImportClassTemplatesVisibility,
+    ::testing::Combine(
+        DefaultTestValuesForRunOptions,
+        ::testing::Values(std::make_tuple(ExternCT, ExternCT, ExpectLinkedDeclChain),
+                          std::make_tuple(ExternCT, AnonCT, ExpectUnlinkedDeclChain),
+                          std::make_tuple(AnonCT, ExternCT, ExpectUnlinkedDeclChain),
+                          std::make_tuple(AnonCT, AnonCT, ExpectUnlinkedDeclChain))), );
 } // end namespace ast_matchers
 } // end namespace clang