1 //===- unittest/AST/ASTImporterTest.cpp - AST node import test ------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Type-parameterized tests for the correct import of Decls with different
10 // visibility.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 // Define this to have ::testing::Combine available.
15 // FIXME: Better solution for this?
16 #define GTEST_HAS_COMBINE 1
17 
18 #include "ASTImporterFixtures.h"
19 
20 namespace clang {
21 namespace ast_matchers {
22 
23 using internal::BindableMatcher;
24 
25 // Type parameters for type-parameterized test fixtures.
26 struct GetFunPattern {
27   using DeclTy = FunctionDecl;
28   BindableMatcher<Decl> operator()() { return functionDecl(hasName("f")); }
29 };
30 struct GetVarPattern {
31   using DeclTy = VarDecl;
32   BindableMatcher<Decl> operator()() { return varDecl(hasName("v")); }
33 };
34 struct GetClassPattern {
35   using DeclTy = CXXRecordDecl;
36   BindableMatcher<Decl> operator()() { return cxxRecordDecl(hasName("X")); }
37 };
38 struct GetEnumPattern {
39   using DeclTy = EnumDecl;
40   BindableMatcher<Decl> operator()() { return enumDecl(hasName("E")); }
41 };
42 struct GetTypedefNamePattern {
43   using DeclTy = TypedefNameDecl;
44   BindableMatcher<Decl> operator()() { return typedefNameDecl(hasName("T")); }
45 };
46 struct GetFunTemplPattern {
47   using DeclTy = FunctionTemplateDecl;
48   BindableMatcher<Decl> operator()() {
49     return functionTemplateDecl(hasName("f"));
50   }
51 };
52 struct GetVarTemplPattern {
53   using DeclTy = VarTemplateDecl;
54   BindableMatcher<Decl> operator()() {
55     return namedDecl(hasName("v"), has(templateTypeParmDecl()));
56   }
57 };
58 struct GetClassTemplPattern {
59   using DeclTy = ClassTemplateDecl;
60   BindableMatcher<Decl> operator()() { return classTemplateDecl(hasName("X")); }
61 };
62 
63 // Values for the value-parameterized test fixtures.
64 // FunctionDecl:
65 const auto *ExternF = "void f();";
66 const auto *StaticF = "static void f();";
67 const auto *AnonF = "namespace { void f(); }";
68 // VarDecl:
69 const auto *ExternV = "extern int v;";
70 const auto *StaticV = "static int v;";
71 const auto *AnonV = "namespace { extern int v; }";
72 // CXXRecordDecl:
73 const auto *ExternC = "class X;";
74 const auto *AnonC = "namespace { class X; }";
75 // EnumDecl:
76 const auto *ExternE = "enum E {};";
77 const auto *AnonE = "namespace { enum E {}; }";
78 const auto *ExternEC = "enum class E;";
79 const auto *AnonEC = "namespace { enum class E; }";
80 // TypedefNameDecl:
81 const auto *ExternTypedef = "typedef int T;";
82 const auto *AnonTypedef = "namespace { typedef int T; }";
83 const auto *ExternUsing = "using T = int;";
84 const auto *AnonUsing = "namespace { using T = int; }";
85 // FunctionTemplateDecl:
86 const auto *ExternFT = "template <class> void f();";
87 const auto *StaticFT = "template <class> static void f();";
88 const auto *AnonFT = "namespace { template <class> void f(); }";
89 // VarTemplateDecl:
90 const auto *ExternVT = "template <class> extern int v;";
91 const auto *StaticVT = "template <class> static int v;";
92 const auto *AnonVT = "namespace { template <class> extern int v; }";
93 // ClassTemplateDecl:
94 const auto *ExternCT = "template <class> class X;";
95 const auto *AnonCT = "namespace { template <class> class X; }";
96 
97 // First value in tuple: Compile options.
98 // Second value in tuple: Source code to be used in the test.
99 using ImportVisibilityChainParams = ::testing::WithParamInterface<
100     std::tuple<std::vector<std::string>, const char *>>;
101 // Fixture to test the redecl chain of Decls with the same visibility. Gtest
102 // makes it possible to have either value-parameterized or type-parameterized
103 // fixtures. However, we cannot have both value- and type-parameterized test
104 // fixtures. This is a value-parameterized test fixture in the gtest sense. We
105 // intend to mimic gtest's type-parameters via the PatternFactory template
106 // parameter. We manually instantiate the different tests with the each types.
107 template <typename PatternFactory>
108 class ImportVisibilityChain
109     : public ASTImporterTestBase, public ImportVisibilityChainParams {
110 protected:
111   using DeclTy = typename PatternFactory::DeclTy;
112   std::vector<std::string> getExtraArgs() const override {
113     return std::get<0>(GetParam());
114   }
115   std::string getCode() const { return std::get<1>(GetParam()); }
116   BindableMatcher<Decl> getPattern() const { return PatternFactory()(); }
117 
118   // Type-parameterized test.
119   void TypedTest_ImportChain() {
120     std::string Code = getCode() + getCode();
121     auto Pattern = getPattern();
122 
123     TranslationUnitDecl *FromTu = getTuDecl(Code, Lang_CXX14, "input0.cc");
124 
125     auto *FromD0 = FirstDeclMatcher<DeclTy>().match(FromTu, Pattern);
126     auto *FromD1 = LastDeclMatcher<DeclTy>().match(FromTu, Pattern);
127 
128     auto *ToD0 = Import(FromD0, Lang_CXX14);
129     auto *ToD1 = Import(FromD1, Lang_CXX14);
130 
131     EXPECT_TRUE(ToD0);
132     ASSERT_TRUE(ToD1);
133     EXPECT_NE(ToD0, ToD1);
134     EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
135   }
136 };
137 
138 // Manual instantiation of the fixture with each type.
139 using ImportFunctionsVisibilityChain = ImportVisibilityChain<GetFunPattern>;
140 using ImportVariablesVisibilityChain = ImportVisibilityChain<GetVarPattern>;
141 using ImportClassesVisibilityChain = ImportVisibilityChain<GetClassPattern>;
142 using ImportScopedEnumsVisibilityChain = ImportVisibilityChain<GetEnumPattern>;
143 using ImportFunctionTemplatesVisibilityChain =
144     ImportVisibilityChain<GetFunTemplPattern>;
145 using ImportVariableTemplatesVisibilityChain =
146     ImportVisibilityChain<GetVarTemplPattern>;
147 using ImportClassTemplatesVisibilityChain =
148     ImportVisibilityChain<GetClassTemplPattern>;
149 
150 // Value-parameterized test for functions.
151 TEST_P(ImportFunctionsVisibilityChain, ImportChain) {
152   TypedTest_ImportChain();
153 }
154 // Value-parameterized test for variables.
155 TEST_P(ImportVariablesVisibilityChain, ImportChain) {
156   TypedTest_ImportChain();
157 }
158 // Value-parameterized test for classes.
159 TEST_P(ImportClassesVisibilityChain, ImportChain) {
160   TypedTest_ImportChain();
161 }
162 // Value-parameterized test for scoped enums.
163 TEST_P(ImportScopedEnumsVisibilityChain, ImportChain) {
164   TypedTest_ImportChain();
165 }
166 // Value-parameterized test for function templates.
167 TEST_P(ImportFunctionTemplatesVisibilityChain, ImportChain) {
168   TypedTest_ImportChain();
169 }
170 // Value-parameterized test for variable templates.
171 TEST_P(ImportVariableTemplatesVisibilityChain, ImportChain) {
172   TypedTest_ImportChain();
173 }
174 // Value-parameterized test for class templates.
175 TEST_P(ImportClassTemplatesVisibilityChain, ImportChain) {
176   TypedTest_ImportChain();
177 }
178 
179 // Automatic instantiation of the value-parameterized tests.
180 INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFunctionsVisibilityChain,
181                          ::testing::Combine(DefaultTestValuesForRunOptions,
182                                             ::testing::Values(ExternF, StaticF,
183                                                               AnonF)));
184 INSTANTIATE_TEST_SUITE_P(
185     ParameterizedTests, ImportVariablesVisibilityChain,
186     ::testing::Combine(
187         DefaultTestValuesForRunOptions,
188         // There is no point to instantiate with StaticV, because in C++ we can
189         // forward declare a variable only with the 'extern' keyword.
190         // Consequently, each fwd declared variable has external linkage.  This
191         // is different in the C language where any declaration without an
192         // initializer is a tentative definition, subsequent definitions may be
193         // provided but they must have the same linkage.  See also the test
194         // ImportVariableChainInC which test for this special C Lang case.
195         ::testing::Values(ExternV, AnonV)) );
196 INSTANTIATE_TEST_SUITE_P(
197     ParameterizedTests, ImportClassesVisibilityChain,
198     ::testing::Combine(
199         DefaultTestValuesForRunOptions,
200         ::testing::Values(ExternC, AnonC)) );
201 INSTANTIATE_TEST_SUITE_P(
202     ParameterizedTests, ImportScopedEnumsVisibilityChain,
203     ::testing::Combine(
204         DefaultTestValuesForRunOptions,
205         ::testing::Values(ExternEC, AnonEC)) );
206 INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
207                         ImportFunctionTemplatesVisibilityChain,
208                         ::testing::Combine(DefaultTestValuesForRunOptions,
209                                            ::testing::Values(ExternFT, StaticFT,
210                                                              AnonFT)) );
211 INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
212                         ImportVariableTemplatesVisibilityChain,
213                         ::testing::Combine(DefaultTestValuesForRunOptions,
214                                            ::testing::Values(ExternVT,
215                                                              AnonVT)) );
216 INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportClassTemplatesVisibilityChain,
217                         ::testing::Combine(DefaultTestValuesForRunOptions,
218                                            ::testing::Values(ExternCT,
219                                                              AnonCT)) );
220 
221 // First value in tuple: Compile options.
222 // Second value in tuple: Tuple with informations for the test.
223 // Code for first import (or initial code), code to import, whether the `f`
224 // functions are expected to be linked in a declaration chain.
225 // One value of this tuple is combined with every value of compile options.
226 // The test can have a single tuple as parameter only.
227 using ImportVisibilityParams = ::testing::WithParamInterface<std::tuple<
228     std::vector<std::string>, std::tuple<const char *, const char *, bool>>>;
229 
230 template <typename PatternFactory>
231 class ImportVisibility
232     : public ASTImporterTestBase,
233       public ImportVisibilityParams {
234 protected:
235   using DeclTy = typename PatternFactory::DeclTy;
236   std::vector<std::string> getExtraArgs() const override {
237     return std::get<0>(GetParam());
238   }
239   std::string getCode0() const { return std::get<0>(std::get<1>(GetParam())); }
240   std::string getCode1() const { return std::get<1>(std::get<1>(GetParam())); }
241   bool shouldBeLinked() const { return std::get<2>(std::get<1>(GetParam())); }
242   BindableMatcher<Decl> getPattern() const { return PatternFactory()(); }
243 
244   void TypedTest_ImportAfter() {
245     TranslationUnitDecl *ToTu = getToTuDecl(getCode0(), Lang_CXX14);
246     TranslationUnitDecl *FromTu =
247         getTuDecl(getCode1(), Lang_CXX14, "input1.cc");
248 
249     auto *ToD0 = FirstDeclMatcher<DeclTy>().match(ToTu, getPattern());
250     auto *FromD1 = FirstDeclMatcher<DeclTy>().match(FromTu, getPattern());
251 
252     auto *ToD1 = Import(FromD1, Lang_CXX14);
253 
254     ASSERT_TRUE(ToD0);
255     ASSERT_TRUE(ToD1);
256     EXPECT_NE(ToD0, ToD1);
257 
258     if (shouldBeLinked())
259       EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
260     else
261       EXPECT_FALSE(ToD1->getPreviousDecl());
262   }
263 
264   void TypedTest_ImportAfterImport() {
265     TranslationUnitDecl *FromTu0 =
266         getTuDecl(getCode0(), Lang_CXX14, "input0.cc");
267     TranslationUnitDecl *FromTu1 =
268         getTuDecl(getCode1(), Lang_CXX14, "input1.cc");
269     auto *FromD0 = FirstDeclMatcher<DeclTy>().match(FromTu0, getPattern());
270     auto *FromD1 = FirstDeclMatcher<DeclTy>().match(FromTu1, getPattern());
271     auto *ToD0 = Import(FromD0, Lang_CXX14);
272     auto *ToD1 = Import(FromD1, Lang_CXX14);
273     ASSERT_TRUE(ToD0);
274     ASSERT_TRUE(ToD1);
275     EXPECT_NE(ToD0, ToD1);
276     if (shouldBeLinked())
277       EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
278     else
279       EXPECT_FALSE(ToD1->getPreviousDecl());
280   }
281 
282   void TypedTest_ImportAfterWithMerge() {
283     TranslationUnitDecl *ToTu = getToTuDecl(getCode0(), Lang_CXX14);
284     TranslationUnitDecl *FromTu =
285         getTuDecl(getCode1(), Lang_CXX14, "input1.cc");
286 
287     auto *ToF0 = FirstDeclMatcher<DeclTy>().match(ToTu, getPattern());
288     auto *FromF1 = FirstDeclMatcher<DeclTy>().match(FromTu, getPattern());
289 
290     auto *ToF1 = Import(FromF1, Lang_CXX14);
291 
292     ASSERT_TRUE(ToF0);
293     ASSERT_TRUE(ToF1);
294 
295     if (shouldBeLinked())
296       EXPECT_EQ(ToF0, ToF1);
297     else
298       EXPECT_NE(ToF0, ToF1);
299 
300     // We expect no (ODR) warning during the import.
301     EXPECT_EQ(0u, ToTu->getASTContext().getDiagnostics().getNumWarnings());
302   }
303 
304   void TypedTest_ImportAfterImportWithMerge() {
305     TranslationUnitDecl *FromTu0 =
306         getTuDecl(getCode0(), Lang_CXX14, "input0.cc");
307     TranslationUnitDecl *FromTu1 =
308         getTuDecl(getCode1(), Lang_CXX14, "input1.cc");
309     auto *FromF0 = FirstDeclMatcher<DeclTy>().match(FromTu0, getPattern());
310     auto *FromF1 = FirstDeclMatcher<DeclTy>().match(FromTu1, getPattern());
311     auto *ToF0 = Import(FromF0, Lang_CXX14);
312     auto *ToF1 = Import(FromF1, Lang_CXX14);
313     ASSERT_TRUE(ToF0);
314     ASSERT_TRUE(ToF1);
315     if (shouldBeLinked())
316       EXPECT_EQ(ToF0, ToF1);
317     else
318       EXPECT_NE(ToF0, ToF1);
319 
320     // We expect no (ODR) warning during the import.
321     EXPECT_EQ(0u, ToF0->getTranslationUnitDecl()
322                       ->getASTContext()
323                       .getDiagnostics()
324                       .getNumWarnings());
325   }
326 };
327 using ImportFunctionsVisibility = ImportVisibility<GetFunPattern>;
328 using ImportVariablesVisibility = ImportVisibility<GetVarPattern>;
329 using ImportClassesVisibility = ImportVisibility<GetClassPattern>;
330 using ImportEnumsVisibility = ImportVisibility<GetEnumPattern>;
331 using ImportScopedEnumsVisibility = ImportVisibility<GetEnumPattern>;
332 using ImportTypedefNameVisibility = ImportVisibility<GetTypedefNamePattern>;
333 using ImportFunctionTemplatesVisibility = ImportVisibility<GetFunTemplPattern>;
334 using ImportVariableTemplatesVisibility = ImportVisibility<GetVarTemplPattern>;
335 using ImportClassTemplatesVisibility = ImportVisibility<GetClassTemplPattern>;
336 
337 // FunctionDecl.
338 TEST_P(ImportFunctionsVisibility, ImportAfter) {
339   TypedTest_ImportAfter();
340 }
341 TEST_P(ImportFunctionsVisibility, ImportAfterImport) {
342   TypedTest_ImportAfterImport();
343 }
344 // VarDecl.
345 TEST_P(ImportVariablesVisibility, ImportAfter) {
346   TypedTest_ImportAfter();
347 }
348 TEST_P(ImportVariablesVisibility, ImportAfterImport) {
349   TypedTest_ImportAfterImport();
350 }
351 // CXXRecordDecl.
352 TEST_P(ImportClassesVisibility, ImportAfter) {
353   TypedTest_ImportAfter();
354 }
355 TEST_P(ImportClassesVisibility, ImportAfterImport) {
356   TypedTest_ImportAfterImport();
357 }
358 // EnumDecl.
359 TEST_P(ImportEnumsVisibility, ImportAfter) {
360   TypedTest_ImportAfterWithMerge();
361 }
362 TEST_P(ImportEnumsVisibility, ImportAfterImport) {
363   TypedTest_ImportAfterImportWithMerge();
364 }
365 TEST_P(ImportScopedEnumsVisibility, ImportAfter) {
366   TypedTest_ImportAfter();
367 }
368 TEST_P(ImportScopedEnumsVisibility, ImportAfterImport) {
369   TypedTest_ImportAfterImport();
370 }
371 // TypedefNameDecl.
372 TEST_P(ImportTypedefNameVisibility, ImportAfter) {
373   TypedTest_ImportAfterWithMerge();
374 }
375 TEST_P(ImportTypedefNameVisibility, ImportAfterImport) {
376   TypedTest_ImportAfterImportWithMerge();
377 }
378 // FunctionTemplateDecl.
379 TEST_P(ImportFunctionTemplatesVisibility, ImportAfter) {
380   TypedTest_ImportAfter();
381 }
382 TEST_P(ImportFunctionTemplatesVisibility, ImportAfterImport) {
383   TypedTest_ImportAfterImport();
384 }
385 // VarTemplateDecl.
386 TEST_P(ImportVariableTemplatesVisibility, ImportAfter) {
387   TypedTest_ImportAfter();
388 }
389 TEST_P(ImportVariableTemplatesVisibility, ImportAfterImport) {
390   TypedTest_ImportAfterImport();
391 }
392 // ClassTemplateDecl.
393 TEST_P(ImportClassTemplatesVisibility, ImportAfter) { TypedTest_ImportAfter(); }
394 TEST_P(ImportClassTemplatesVisibility, ImportAfterImport) {
395   TypedTest_ImportAfterImport();
396 }
397 
398 const bool ExpectLinkedDeclChain = true;
399 const bool ExpectUnlinkedDeclChain = false;
400 
401 INSTANTIATE_TEST_SUITE_P(
402     ParameterizedTests, ImportFunctionsVisibility,
403     ::testing::Combine(
404         DefaultTestValuesForRunOptions,
405         ::testing::Values(
406             std::make_tuple(ExternF, ExternF, ExpectLinkedDeclChain),
407             std::make_tuple(ExternF, StaticF, ExpectUnlinkedDeclChain),
408             std::make_tuple(ExternF, AnonF, ExpectUnlinkedDeclChain),
409             std::make_tuple(StaticF, ExternF, ExpectUnlinkedDeclChain),
410             std::make_tuple(StaticF, StaticF, ExpectUnlinkedDeclChain),
411             std::make_tuple(StaticF, AnonF, ExpectUnlinkedDeclChain),
412             std::make_tuple(AnonF, ExternF, ExpectUnlinkedDeclChain),
413             std::make_tuple(AnonF, StaticF, ExpectUnlinkedDeclChain),
414             std::make_tuple(AnonF, AnonF, ExpectUnlinkedDeclChain))) );
415 INSTANTIATE_TEST_SUITE_P(
416     ParameterizedTests, ImportVariablesVisibility,
417     ::testing::Combine(
418         DefaultTestValuesForRunOptions,
419         ::testing::Values(
420             std::make_tuple(ExternV, ExternV, ExpectLinkedDeclChain),
421             std::make_tuple(ExternV, StaticV, ExpectUnlinkedDeclChain),
422             std::make_tuple(ExternV, AnonV, ExpectUnlinkedDeclChain),
423             std::make_tuple(StaticV, ExternV, ExpectUnlinkedDeclChain),
424             std::make_tuple(StaticV, StaticV, ExpectUnlinkedDeclChain),
425             std::make_tuple(StaticV, AnonV, ExpectUnlinkedDeclChain),
426             std::make_tuple(AnonV, ExternV, ExpectUnlinkedDeclChain),
427             std::make_tuple(AnonV, StaticV, ExpectUnlinkedDeclChain),
428             std::make_tuple(AnonV, AnonV, ExpectUnlinkedDeclChain))) );
429 INSTANTIATE_TEST_SUITE_P(
430     ParameterizedTests, ImportClassesVisibility,
431     ::testing::Combine(
432         DefaultTestValuesForRunOptions,
433         ::testing::Values(
434             std::make_tuple(ExternC, ExternC, ExpectLinkedDeclChain),
435             std::make_tuple(ExternC, AnonC, ExpectUnlinkedDeclChain),
436             std::make_tuple(AnonC, ExternC, ExpectUnlinkedDeclChain),
437             std::make_tuple(AnonC, AnonC, ExpectUnlinkedDeclChain))) );
438 INSTANTIATE_TEST_SUITE_P(
439     ParameterizedTests, ImportEnumsVisibility,
440     ::testing::Combine(
441         DefaultTestValuesForRunOptions,
442         ::testing::Values(
443             std::make_tuple(ExternE, ExternE, ExpectLinkedDeclChain),
444             std::make_tuple(ExternE, AnonE, ExpectUnlinkedDeclChain),
445             std::make_tuple(AnonE, ExternE, ExpectUnlinkedDeclChain),
446             std::make_tuple(AnonE, AnonE, ExpectUnlinkedDeclChain))) );
447 INSTANTIATE_TEST_SUITE_P(
448     ParameterizedTests, ImportScopedEnumsVisibility,
449     ::testing::Combine(
450         DefaultTestValuesForRunOptions,
451         ::testing::Values(
452             std::make_tuple(ExternEC, ExternEC, ExpectLinkedDeclChain),
453             std::make_tuple(ExternEC, AnonEC, ExpectUnlinkedDeclChain),
454             std::make_tuple(AnonEC, ExternEC, ExpectUnlinkedDeclChain),
455             std::make_tuple(AnonEC, AnonEC, ExpectUnlinkedDeclChain))) );
456 INSTANTIATE_TEST_SUITE_P(
457     ParameterizedTests, ImportTypedefNameVisibility,
458     ::testing::Combine(
459         DefaultTestValuesForRunOptions,
460         ::testing::Values(
461             std::make_tuple(ExternTypedef, ExternTypedef,
462                             ExpectLinkedDeclChain),
463             std::make_tuple(ExternTypedef, AnonTypedef,
464                             ExpectUnlinkedDeclChain),
465             std::make_tuple(AnonTypedef, ExternTypedef,
466                             ExpectUnlinkedDeclChain),
467             std::make_tuple(AnonTypedef, AnonTypedef, ExpectUnlinkedDeclChain),
468 
469             std::make_tuple(ExternUsing, ExternUsing, ExpectLinkedDeclChain),
470             std::make_tuple(ExternUsing, AnonUsing, ExpectUnlinkedDeclChain),
471             std::make_tuple(AnonUsing, ExternUsing, ExpectUnlinkedDeclChain),
472             std::make_tuple(AnonUsing, AnonUsing, ExpectUnlinkedDeclChain),
473 
474             std::make_tuple(ExternUsing, ExternTypedef, ExpectLinkedDeclChain),
475             std::make_tuple(ExternUsing, AnonTypedef, ExpectUnlinkedDeclChain),
476             std::make_tuple(AnonUsing, ExternTypedef, ExpectUnlinkedDeclChain),
477             std::make_tuple(AnonUsing, AnonTypedef, ExpectUnlinkedDeclChain),
478 
479             std::make_tuple(ExternTypedef, ExternUsing, ExpectLinkedDeclChain),
480             std::make_tuple(ExternTypedef, AnonUsing, ExpectUnlinkedDeclChain),
481             std::make_tuple(AnonTypedef, ExternUsing, ExpectUnlinkedDeclChain),
482             std::make_tuple(AnonTypedef, AnonUsing,
483                             ExpectUnlinkedDeclChain))) );
484 INSTANTIATE_TEST_SUITE_P(
485     ParameterizedTests, ImportFunctionTemplatesVisibility,
486     ::testing::Combine(
487         DefaultTestValuesForRunOptions,
488         ::testing::Values(
489             std::make_tuple(ExternFT, ExternFT, ExpectLinkedDeclChain),
490             std::make_tuple(ExternFT, StaticFT, ExpectUnlinkedDeclChain),
491             std::make_tuple(ExternFT, AnonFT, ExpectUnlinkedDeclChain),
492             std::make_tuple(StaticFT, ExternFT, ExpectUnlinkedDeclChain),
493             std::make_tuple(StaticFT, StaticFT, ExpectUnlinkedDeclChain),
494             std::make_tuple(StaticFT, AnonFT, ExpectUnlinkedDeclChain),
495             std::make_tuple(AnonFT, ExternFT, ExpectUnlinkedDeclChain),
496             std::make_tuple(AnonFT, StaticFT, ExpectUnlinkedDeclChain),
497             std::make_tuple(AnonFT, AnonFT, ExpectUnlinkedDeclChain))) );
498 INSTANTIATE_TEST_SUITE_P(
499     ParameterizedTests, ImportVariableTemplatesVisibility,
500     ::testing::Combine(
501         DefaultTestValuesForRunOptions,
502         ::testing::Values(
503             std::make_tuple(ExternVT, ExternVT, ExpectLinkedDeclChain),
504             std::make_tuple(ExternVT, StaticVT, ExpectUnlinkedDeclChain),
505             std::make_tuple(ExternVT, AnonVT, ExpectUnlinkedDeclChain),
506             std::make_tuple(StaticVT, ExternVT, ExpectUnlinkedDeclChain),
507             std::make_tuple(StaticVT, StaticVT, ExpectUnlinkedDeclChain),
508             std::make_tuple(StaticVT, AnonVT, ExpectUnlinkedDeclChain),
509             std::make_tuple(AnonVT, ExternVT, ExpectUnlinkedDeclChain),
510             std::make_tuple(AnonVT, StaticVT, ExpectUnlinkedDeclChain),
511             std::make_tuple(AnonVT, AnonVT, ExpectUnlinkedDeclChain))) );
512 INSTANTIATE_TEST_SUITE_P(
513     ParameterizedTests, ImportClassTemplatesVisibility,
514     ::testing::Combine(
515         DefaultTestValuesForRunOptions,
516         ::testing::Values(std::make_tuple(ExternCT, ExternCT, ExpectLinkedDeclChain),
517                           std::make_tuple(ExternCT, AnonCT, ExpectUnlinkedDeclChain),
518                           std::make_tuple(AnonCT, ExternCT, ExpectUnlinkedDeclChain),
519                           std::make_tuple(AnonCT, AnonCT, ExpectUnlinkedDeclChain))) );
520 } // end namespace ast_matchers
521 } // end namespace clang
522