[ASTImporter] Added visibility check for variable templates.

[balazske]

Summary

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

[a_sidorin]

LGTM!

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   SmallVector<NamedDecl *, 4> ConflictingDecls;
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   VarTemplateDecl *FoundByLookup = nullptr;
   for (auto *FoundDecl : FoundDecls) {
     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
       continue;
 
     if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
+      // Use the templated decl, some linkage flags are set only there.
+      if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
+                                              D->getTemplatedDecl()))
+        continue;
       if (IsStructuralMatch(D, FoundTemplate)) {
         // The Decl in the "From" context has a definition, but in the
         // "To" context we already have a definition.
         VarTemplateDecl *FoundDef = getTemplateDefinition(FoundTemplate);
         if (D->isThisDeclarationADefinition() && FoundDef)
           // FIXME Check for ODR error if the two definitions have
           // different initializers?
           return Importer.MapImported(D, FoundDef);

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 GetVarTemplPattern {
+  using DeclTy = VarTemplateDecl;
+  BindableMatcher<Decl> operator()() {
+    return namedDecl(hasName("v"), has(templateTypeParmDecl()));
+  }
+};
 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 *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(); }";
+// VarTemplateDecl:
+const auto *ExternVT = "template <class> extern int v;";
+const auto *StaticVT = "template <class> static int v;";
+const auto *AnonVT = "namespace { template <class> extern int v; }";
 // 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 *>>;

 
 // Manual instantiation of the fixture with each type.
 using ImportFunctionsVisibilityChain = ImportVisibilityChain<GetFunPattern>;
 using ImportVariablesVisibilityChain = ImportVisibilityChain<GetVarPattern>;
 using ImportClassesVisibilityChain = ImportVisibilityChain<GetClassPattern>;
 using ImportScopedEnumsVisibilityChain = ImportVisibilityChain<GetEnumPattern>;
 using ImportFunctionTemplatesVisibilityChain =
     ImportVisibilityChain<GetFunTemplPattern>;
+using ImportVariableTemplatesVisibilityChain =
+    ImportVisibilityChain<GetVarTemplPattern>;
 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 scoped enums.
 TEST_P(ImportScopedEnumsVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
 // Value-parameterized test for function templates.
 TEST_P(ImportFunctionTemplatesVisibilityChain, ImportChain) {
   TypedTest_ImportChain();
 }
+// Value-parameterized test for variable templates.
+TEST_P(ImportVariableTemplatesVisibilityChain, 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(
INSTANTIATE_TEST_CASE_P(
     ::testing::Combine(
         DefaultTestValuesForRunOptions,
         ::testing::Values(ExternEC, AnonEC)), );
 INSTANTIATE_TEST_CASE_P(ParameterizedTests,
                         ImportFunctionTemplatesVisibilityChain,
                         ::testing::Combine(DefaultTestValuesForRunOptions,
                                            ::testing::Values(ExternFT, StaticFT,
                                                              AnonFT)), );
+INSTANTIATE_TEST_CASE_P(ParameterizedTests,
+                        ImportVariableTemplatesVisibilityChain,
+                        ::testing::Combine(DefaultTestValuesForRunOptions,
+                                           ::testing::Values(ExternVT,
+                                                             AnonVT)), );
 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`

 };
 using ImportFunctionsVisibility = ImportVisibility<GetFunPattern>;
 using ImportVariablesVisibility = ImportVisibility<GetVarPattern>;
 using ImportClassesVisibility = ImportVisibility<GetClassPattern>;
 using ImportEnumsVisibility = ImportVisibility<GetEnumPattern>;
 using ImportScopedEnumsVisibility = ImportVisibility<GetEnumPattern>;
 using ImportTypedefNameVisibility = ImportVisibility<GetTypedefNamePattern>;
 using ImportFunctionTemplatesVisibility = ImportVisibility<GetFunTemplPattern>;
+using ImportVariableTemplatesVisibility = ImportVisibility<GetVarTemplPattern>;
 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();
 }
+// VarTemplateDecl.
+TEST_P(ImportVariableTemplatesVisibility, ImportAfter) {
+  TypedTest_ImportAfter();
+}
+TEST_P(ImportVariableTemplatesVisibility, ImportAfterImport) {
+  TypedTest_ImportAfterImport();
+}
 // ClassTemplateDecl.
 TEST_P(ImportClassTemplatesVisibility, ImportAfter) { TypedTest_ImportAfter(); }
 TEST_P(ImportClassTemplatesVisibility, ImportAfterImport) {
   TypedTest_ImportAfterImport();
 }
 
 const bool ExpectLinkedDeclChain = true;
 const bool ExpectUnlinkedDeclChain = false;
::testing::Combine(
             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, ImportVariableTemplatesVisibility,
+    ::testing::Combine(
+        DefaultTestValuesForRunOptions,
+        ::testing::Values(
+            std::make_tuple(ExternVT, ExternVT, ExpectLinkedDeclChain),
+            std::make_tuple(ExternVT, StaticVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(ExternVT, AnonVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(StaticVT, ExternVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(StaticVT, StaticVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(StaticVT, AnonVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(AnonVT, ExternVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(AnonVT, StaticVT, ExpectUnlinkedDeclChain),
+            std::make_tuple(AnonVT, AnonVT, 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