1 //===- unittest/AST/ASTImporterODRStrategiesTest.cpp -----------------------===//
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 to verify the import behaviour in case of ODR
10 // violation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "ASTImporterFixtures.h"
15 
16 namespace clang {
17 namespace ast_matchers {
18 
19 using internal::BindableMatcher;
20 
21 // DeclTy: Type of the Decl to check.
22 // Prototype: "Prototype" (forward declaration) of the Decl.
23 // Definition: A definition for the Prototype.
24 // ConflictingPrototype: A prototype with the same name but different
25 // declaration.
26 // ConflictingDefinition: A different definition for Prototype.
27 // ConflictingProtoDef: A definition for ConflictingPrototype.
28 // getPattern: Return a matcher that matches any of Prototype, Definition,
29 // ConflictingPrototype, ConflictingDefinition, ConflictingProtoDef.
30 
31 struct Function {
32   using DeclTy = FunctionDecl;
33   static constexpr auto *Prototype = "void X(int);";
34   static constexpr auto *ConflictingPrototype = "void X(double);";
35   static constexpr auto *Definition = "void X(int a) {}";
36   static constexpr auto *ConflictingDefinition = "void X(double a) {}";
getPatternclang::ast_matchers::Function37   BindableMatcher<Decl> getPattern() {
38     return functionDecl(hasName("X"), unless(isImplicit()));
39   }
getLangclang::ast_matchers::Function40   TestLanguage getLang() { return Lang_C99; }
41 };
42 
43 struct Typedef {
44   using DeclTy = TypedefNameDecl;
45   static constexpr auto *Definition = "typedef int X;";
46   static constexpr auto *ConflictingDefinition = "typedef double X;";
getPatternclang::ast_matchers::Typedef47   BindableMatcher<Decl> getPattern() { return typedefNameDecl(hasName("X")); }
getLangclang::ast_matchers::Typedef48   TestLanguage getLang() { return Lang_CXX03; }
49 };
50 
51 struct TypedefAlias {
52   using DeclTy = TypedefNameDecl;
53   static constexpr auto *Definition = "using X = int;";
54   static constexpr auto *ConflictingDefinition = "using X = double;";
getPatternclang::ast_matchers::TypedefAlias55   BindableMatcher<Decl> getPattern() { return typedefNameDecl(hasName("X")); }
getLangclang::ast_matchers::TypedefAlias56   TestLanguage getLang() { return Lang_CXX11; }
57 };
58 
59 struct Enum {
60   using DeclTy = EnumDecl;
61   static constexpr auto *Definition = "enum X { a, b };";
62   static constexpr auto *ConflictingDefinition = "enum X { a, b, c };";
getPatternclang::ast_matchers::Enum63   BindableMatcher<Decl> getPattern() { return enumDecl(hasName("X")); }
getLangclang::ast_matchers::Enum64   TestLanguage getLang() { return Lang_CXX03; }
65 };
66 
67 struct EnumClass {
68   using DeclTy = EnumDecl;
69   static constexpr auto *Definition = "enum class X { a, b };";
70   static constexpr auto *ConflictingDefinition = "enum class X { a, b, c };";
getPatternclang::ast_matchers::EnumClass71   BindableMatcher<Decl> getPattern() { return enumDecl(hasName("X")); }
getLangclang::ast_matchers::EnumClass72   TestLanguage getLang() { return Lang_CXX11; }
73 };
74 
75 struct EnumConstant {
76   using DeclTy = EnumConstantDecl;
77   static constexpr auto *Definition = "enum E { X = 0 };";
78   static constexpr auto *ConflictingDefinition = "enum E { X = 1 };";
getPatternclang::ast_matchers::EnumConstant79   BindableMatcher<Decl> getPattern() { return enumConstantDecl(hasName("X")); }
getLangclang::ast_matchers::EnumConstant80   TestLanguage getLang() { return Lang_CXX03; }
81 };
82 
83 struct Class {
84   using DeclTy = CXXRecordDecl;
85   static constexpr auto *Prototype = "class X;";
86   static constexpr auto *Definition = "class X {};";
87   static constexpr auto *ConflictingDefinition = "class X { int A; };";
getPatternclang::ast_matchers::Class88   BindableMatcher<Decl> getPattern() {
89     return cxxRecordDecl(hasName("X"), unless(isImplicit()));
90   }
getLangclang::ast_matchers::Class91   TestLanguage getLang() { return Lang_CXX03; }
92 };
93 
94 struct Variable {
95   using DeclTy = VarDecl;
96   static constexpr auto *Prototype = "extern int X;";
97   static constexpr auto *ConflictingPrototype = "extern float X;";
98   static constexpr auto *Definition = "int X;";
99   static constexpr auto *ConflictingDefinition = "float X;";
getPatternclang::ast_matchers::Variable100   BindableMatcher<Decl> getPattern() { return varDecl(hasName("X")); }
getLangclang::ast_matchers::Variable101   TestLanguage getLang() { return Lang_CXX03; }
102 };
103 
104 struct ClassTemplate {
105   using DeclTy = ClassTemplateDecl;
106   static constexpr auto *Prototype = "template <class> class X;";
107   static constexpr auto *ConflictingPrototype = "template <int> class X;";
108   static constexpr auto *Definition = "template <class> class X {};";
109   static constexpr auto *ConflictingDefinition =
110       "template <class> class X { int A; };";
111   static constexpr auto *ConflictingProtoDef = "template <int> class X { };";
getPatternclang::ast_matchers::ClassTemplate112   BindableMatcher<Decl> getPattern() {
113     return classTemplateDecl(hasName("X"), unless(isImplicit()));
114   }
getLangclang::ast_matchers::ClassTemplate115   TestLanguage getLang() { return Lang_CXX03; }
116 };
117 
118 struct FunctionTemplate {
119   using DeclTy = FunctionTemplateDecl;
120   static constexpr auto *Definition0 =
121       R"(
122       template <class T>
123       void X(T a) {};
124       )";
125   // This is actually not a conflicting definition, but another primary template.
126   static constexpr auto *Definition1 =
127       R"(
128       template <class T>
129       void X(T* a) {};
130       )";
getPatternclang::ast_matchers::FunctionTemplate131   BindableMatcher<Decl> getPattern() {
132     return functionTemplateDecl(hasName("X"), unless(isImplicit()));
133   }
getDef0clang::ast_matchers::FunctionTemplate134   static std::string getDef0() { return Definition0; }
getDef1clang::ast_matchers::FunctionTemplate135   static std::string getDef1() { return Definition1; }
getLangclang::ast_matchers::FunctionTemplate136   TestLanguage getLang() { return Lang_CXX03; }
137 };
138 
139 static const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateDecl>
140     varTemplateDecl;
141 
142 struct VarTemplate {
143   using DeclTy = VarTemplateDecl;
144   static constexpr auto *Definition =
145       R"(
146       template <class T>
147       constexpr T X = 0;
148       )";
149   static constexpr auto *ConflictingDefinition =
150       R"(
151       template <int>
152       constexpr int X = 0;
153       )";
getPatternclang::ast_matchers::VarTemplate154   BindableMatcher<Decl> getPattern() { return varTemplateDecl(hasName("X")); }
getLangclang::ast_matchers::VarTemplate155   TestLanguage getLang() { return Lang_CXX14; }
156 };
157 
158 struct ClassTemplateSpec {
159   using DeclTy = ClassTemplateSpecializationDecl;
160   static constexpr auto *Prototype =
161       R"(
162       template <class T> class X;
163       template <> class X<int>;
164       )";
165   static constexpr auto *Definition =
166       R"(
167       template <class T> class X;
168       template <> class X<int> {};
169       )";
170   static constexpr auto *ConflictingDefinition =
171       R"(
172       template <class T> class X;
173       template <> class X<int> { int A; };
174       )";
getPatternclang::ast_matchers::ClassTemplateSpec175   BindableMatcher<Decl> getPattern() {
176     return classTemplateSpecializationDecl(hasName("X"), unless(isImplicit()));
177   }
getLangclang::ast_matchers::ClassTemplateSpec178   TestLanguage getLang() { return Lang_CXX03; }
179 };
180 
181 // Function template specializations are all "full" specializations.
182 // Structural equivalency does not check the body of functions, so we cannot
183 // create conflicting function template specializations.
184 struct FunctionTemplateSpec {
185   using DeclTy = FunctionDecl;
186 
187   static constexpr auto *Definition0 =
188       R"(
189       template <class T>
190       void X(T a);
191       template <> void X(int a) {};
192       )";
193 
194   // This is actually not a conflicting definition, but another full
195   // specialization.
196   // Thus, during the import we would create a new specialization with a
197   // different type argument.
198   static constexpr auto *Definition1 =
199       R"(
200       template <class T>
201       void X(T a);
202       template <> void X(double a) {};
203       )";
204 
getPatternclang::ast_matchers::FunctionTemplateSpec205   BindableMatcher<Decl> getPattern() {
206     return functionDecl(hasName("X"), isExplicitTemplateSpecialization(),
207                         unless(isImplicit()));
208   }
getDef0clang::ast_matchers::FunctionTemplateSpec209   static std::string getDef0() { return Definition0; }
getDef1clang::ast_matchers::FunctionTemplateSpec210   static std::string getDef1() { return Definition1; }
getLangclang::ast_matchers::FunctionTemplateSpec211   TestLanguage getLang() { return Lang_CXX03; }
212 };
213 
214 static const internal::VariadicDynCastAllOfMatcher<
215     Decl, VarTemplateSpecializationDecl>
216     varTemplateSpecializationDecl;
217 
218 struct VarTemplateSpec {
219   using DeclTy = VarTemplateSpecializationDecl;
220   static constexpr auto *Definition =
221       R"(
222       template <class T> T X = 0;
223       template <> int X<int> = 0;
224       )";
225   static constexpr auto *ConflictingDefinition =
226       R"(
227       template <class T> T X = 0;
228       template <> float X<int> = 1.0;
229       )";
getPatternclang::ast_matchers::VarTemplateSpec230   BindableMatcher<Decl> getPattern() {
231     return varTemplateSpecializationDecl(hasName("X"), unless(isImplicit()));
232   }
getLangclang::ast_matchers::VarTemplateSpec233   TestLanguage getLang() { return Lang_CXX14; }
234 };
235 
236 template <typename TypeParam, ASTImporter::ODRHandlingType ODRHandlingParam>
237 struct ODRViolation : ASTImporterOptionSpecificTestBase {
238 
239   using DeclTy = typename TypeParam::DeclTy;
240 
ODRViolationclang::ast_matchers::ODRViolation241   ODRViolation() { ODRHandling = ODRHandlingParam; }
242 
getPrototypeclang::ast_matchers::ODRViolation243   static std::string getPrototype() { return TypeParam::Prototype; }
getConflictingPrototypeclang::ast_matchers::ODRViolation244   static std::string getConflictingPrototype() {
245     return TypeParam::ConflictingPrototype;
246   }
getDefinitionclang::ast_matchers::ODRViolation247   static std::string getDefinition() { return TypeParam::Definition; }
getConflictingDefinitionclang::ast_matchers::ODRViolation248   static std::string getConflictingDefinition() {
249     return TypeParam::ConflictingDefinition;
250   }
getConflictingProtoDefclang::ast_matchers::ODRViolation251   static std::string getConflictingProtoDef() {
252     return TypeParam::ConflictingProtoDef;
253   }
getPatternclang::ast_matchers::ODRViolation254   static BindableMatcher<Decl> getPattern() { return TypeParam().getPattern(); }
getLangclang::ast_matchers::ODRViolation255   static TestLanguage getLang() { return TypeParam().getLang(); }
256 
257   template <std::string (*ToTUContent)(), std::string (*FromTUContent)(),
258             void (*ResultChecker)(llvm::Expected<Decl *> &, Decl *, Decl *)>
TypedTest_ImportAfterclang::ast_matchers::ODRViolation259   void TypedTest_ImportAfter() {
260     Decl *ToTU = getToTuDecl(ToTUContent(), getLang());
261     auto *ToD = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
262 
263     Decl *FromTU = getTuDecl(FromTUContent(), getLang());
264     auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
265 
266     auto Result = importOrError(FromD, getLang());
267 
268     ResultChecker(Result, ToTU, ToD);
269   }
270 
271   // Check that a Decl has been successfully imported into a standalone redecl
272   // chain.
CheckImportedAsNewclang::ast_matchers::ODRViolation273   static void CheckImportedAsNew(llvm::Expected<Decl *> &Result, Decl *ToTU,
274                                  Decl *ToD) {
275     ASSERT_TRUE(isSuccess(Result));
276     Decl *ImportedD = *Result;
277     ASSERT_TRUE(ImportedD);
278     EXPECT_NE(ImportedD, ToD);
279     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
280 
281     // There may be a hidden fwd spec decl before a function spec decl.
282     if (auto *ImportedF = dyn_cast<FunctionDecl>(ImportedD))
283       if (ImportedF->getTemplatedKind() ==
284           FunctionDecl::TK_FunctionTemplateSpecialization)
285         return;
286 
287     EXPECT_FALSE(ImportedD->getPreviousDecl());
288   }
289 
290   // Check that a Decl was not imported because of NameConflict.
CheckImportNameConflictclang::ast_matchers::ODRViolation291   static void CheckImportNameConflict(llvm::Expected<Decl *> &Result,
292                                       Decl *ToTU, Decl *ToD) {
293     EXPECT_TRUE(isImportError(Result, ImportError::NameConflict));
294     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
295   }
296 
297   // Check that a Decl was not imported because lookup found the same decl.
CheckImportFoundExistingclang::ast_matchers::ODRViolation298   static void CheckImportFoundExisting(llvm::Expected<Decl *> &Result,
299                                       Decl *ToTU, Decl *ToD) {
300     ASSERT_TRUE(isSuccess(Result));
301     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
302   }
303 
TypedTest_ImportConflictingDefAfterDefclang::ast_matchers::ODRViolation304   void TypedTest_ImportConflictingDefAfterDef() {
305     TypedTest_ImportAfter<getDefinition, getConflictingDefinition,
306                           CheckImportedAsNew>();
307   }
TypedTest_ImportConflictingProtoAfterProtoclang::ast_matchers::ODRViolation308   void TypedTest_ImportConflictingProtoAfterProto() {
309     TypedTest_ImportAfter<getPrototype, getConflictingPrototype,
310                           CheckImportedAsNew>();
311   }
TypedTest_ImportConflictingProtoAfterDefclang::ast_matchers::ODRViolation312   void TypedTest_ImportConflictingProtoAfterDef() {
313     TypedTest_ImportAfter<getDefinition, getConflictingPrototype,
314                           CheckImportedAsNew>();
315   }
TypedTest_ImportConflictingDefAfterProtoclang::ast_matchers::ODRViolation316   void TypedTest_ImportConflictingDefAfterProto() {
317     TypedTest_ImportAfter<getConflictingPrototype, getDefinition,
318                           CheckImportedAsNew>();
319   }
TypedTest_ImportConflictingProtoDefAfterProtoclang::ast_matchers::ODRViolation320   void TypedTest_ImportConflictingProtoDefAfterProto() {
321     TypedTest_ImportAfter<getPrototype, getConflictingProtoDef,
322                           CheckImportedAsNew>();
323   }
TypedTest_ImportConflictingProtoAfterProtoDefclang::ast_matchers::ODRViolation324   void TypedTest_ImportConflictingProtoAfterProtoDef() {
325     TypedTest_ImportAfter<getConflictingProtoDef, getPrototype,
326                           CheckImportedAsNew>();
327   }
TypedTest_ImportConflictingProtoDefAfterDefclang::ast_matchers::ODRViolation328   void TypedTest_ImportConflictingProtoDefAfterDef() {
329     TypedTest_ImportAfter<getDefinition, getConflictingProtoDef,
330                           CheckImportedAsNew>();
331   }
TypedTest_ImportConflictingDefAfterProtoDefclang::ast_matchers::ODRViolation332   void TypedTest_ImportConflictingDefAfterProtoDef() {
333     TypedTest_ImportAfter<getConflictingProtoDef, getDefinition,
334                           CheckImportedAsNew>();
335   }
336 
TypedTest_DontImportConflictingProtoAfterProtoclang::ast_matchers::ODRViolation337   void TypedTest_DontImportConflictingProtoAfterProto() {
338     TypedTest_ImportAfter<getPrototype, getConflictingPrototype,
339                           CheckImportNameConflict>();
340   }
TypedTest_DontImportConflictingDefAfterDefclang::ast_matchers::ODRViolation341   void TypedTest_DontImportConflictingDefAfterDef() {
342     TypedTest_ImportAfter<getDefinition, getConflictingDefinition,
343                           CheckImportNameConflict>();
344   }
TypedTest_DontImportConflictingProtoAfterDefclang::ast_matchers::ODRViolation345   void TypedTest_DontImportConflictingProtoAfterDef() {
346     TypedTest_ImportAfter<getDefinition, getConflictingPrototype,
347                           CheckImportNameConflict>();
348   }
TypedTest_DontImportConflictingDefAfterProtoclang::ast_matchers::ODRViolation349   void TypedTest_DontImportConflictingDefAfterProto() {
350     TypedTest_ImportAfter<getConflictingPrototype, getDefinition,
351                           CheckImportNameConflict>();
352   }
TypedTest_DontImportConflictingProtoDefAfterProtoclang::ast_matchers::ODRViolation353   void TypedTest_DontImportConflictingProtoDefAfterProto() {
354     TypedTest_ImportAfter<getPrototype, getConflictingProtoDef,
355                           CheckImportNameConflict>();
356   }
TypedTest_DontImportConflictingProtoAfterProtoDefclang::ast_matchers::ODRViolation357   void TypedTest_DontImportConflictingProtoAfterProtoDef() {
358     TypedTest_ImportAfter<getConflictingProtoDef, getPrototype,
359                           CheckImportNameConflict>();
360   }
TypedTest_DontImportConflictingProtoDefAfterDefclang::ast_matchers::ODRViolation361   void TypedTest_DontImportConflictingProtoDefAfterDef() {
362     TypedTest_ImportAfter<getDefinition, getConflictingProtoDef,
363                           CheckImportNameConflict>();
364   }
TypedTest_DontImportConflictingDefAfterProtoDefclang::ast_matchers::ODRViolation365   void TypedTest_DontImportConflictingDefAfterProtoDef() {
366     TypedTest_ImportAfter<getConflictingProtoDef, getDefinition,
367                           CheckImportNameConflict>();
368   }
369 
370   // Used for function templates and function template specializations.
TypedTest_ImportDifferentDefAfterDefclang::ast_matchers::ODRViolation371   void TypedTest_ImportDifferentDefAfterDef() {
372     TypedTest_ImportAfter<TypeParam::getDef0, TypeParam::getDef1,
373                           CheckImportedAsNew>();
374   }
TypedTest_DontImportSameDefAfterDefclang::ast_matchers::ODRViolation375   void TypedTest_DontImportSameDefAfterDef() {
376     TypedTest_ImportAfter<TypeParam::getDef0, TypeParam::getDef0,
377                           CheckImportFoundExisting>();
378   }
379 };
380 
381 // ==============================
382 // Define the parametrized tests.
383 // ==============================
384 
385 #define ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(                           \
386     TypeParam, ODRHandlingParam, NamePrefix, TestCase)                         \
387   using TypeParam##ODRHandlingParam =                                          \
388       ODRViolation<TypeParam, ASTImporter::ODRHandlingType::ODRHandlingParam>; \
389   TEST_P(TypeParam##ODRHandlingParam, NamePrefix##TestCase) {                  \
390     TypedTest_##TestCase();                                                    \
391   }
392 
393 // clang-format off
394 
395 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
396     Function, Liberal, ,
397     ImportConflictingDefAfterDef)
398 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
399     Typedef, Liberal, ,
400     ImportConflictingDefAfterDef)
401 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
402     TypedefAlias, Liberal, ,
403     ImportConflictingDefAfterDef)
404 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
405     Enum, Liberal, ,
406     ImportConflictingDefAfterDef)
407 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
408     EnumClass, Liberal, ,
409     ImportConflictingDefAfterDef)
410 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
411     EnumConstant, Liberal, ,
412     ImportConflictingDefAfterDef)
413 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
414     Class, Liberal, ,
415     ImportConflictingDefAfterDef)
416 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
417     Variable, Liberal, ,
418     ImportConflictingDefAfterDef)
419 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
420     ClassTemplate, Liberal, ,
421     ImportConflictingDefAfterDef)
422 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
423     VarTemplate, Liberal, ,
424     ImportConflictingDefAfterDef)
425 // Class and variable template specializations/instantiatons are always
426 // imported conservatively, because the AST holds the specializations in a set,
427 // and the key within the set is a hash calculated from the arguments of the
428 // specialization.
429 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
430     ClassTemplateSpec, Liberal, ,
431     DontImportConflictingDefAfterDef) // Don't import !!!
432 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
433     VarTemplateSpec, Liberal, ,
434     DontImportConflictingDefAfterDef) // Don't import !!!
435 
436 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
437     Function, Conservative, ,
438     DontImportConflictingDefAfterDef)
439 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
440     Typedef, Conservative, ,
441     DontImportConflictingDefAfterDef)
442 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
443     TypedefAlias, Conservative, ,
444     DontImportConflictingDefAfterDef)
445 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
446     Enum, Conservative, ,
447     DontImportConflictingDefAfterDef)
448 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
449     EnumClass, Conservative, ,
450     DontImportConflictingDefAfterDef)
451 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
452     EnumConstant, Conservative, ,
453     DontImportConflictingDefAfterDef)
454 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
455     Class, Conservative, ,
456     DontImportConflictingDefAfterDef)
457 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
458     Variable, Conservative, ,
459     DontImportConflictingDefAfterDef)
460 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
461     ClassTemplate, Conservative, ,
462     DontImportConflictingDefAfterDef)
463 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
464     VarTemplate, Conservative, ,
465     DontImportConflictingDefAfterDef)
466 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
467     ClassTemplateSpec, Conservative, ,
468     DontImportConflictingDefAfterDef)
469 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
470     VarTemplateSpec, Conservative, ,
471     DontImportConflictingDefAfterDef)
472 
473 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
474     Function, Liberal, ,
475     ImportConflictingProtoAfterProto)
476 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
477     Variable, Liberal, ,
478     ImportConflictingProtoAfterProto)
479 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
480     ClassTemplate, Liberal, ,
481     ImportConflictingProtoAfterProto)
482 
483 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
484     Function, Conservative, ,
485     DontImportConflictingProtoAfterProto)
486 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
487     Variable, Conservative, ,
488     DontImportConflictingProtoAfterProto)
489 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
490     ClassTemplate, Conservative, ,
491     DontImportConflictingProtoAfterProto)
492 
493 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
494     Variable, Liberal, ,
495     ImportConflictingProtoAfterDef)
496 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
497     ClassTemplate, Liberal, ,
498     ImportConflictingProtoAfterDef)
499 
500 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
501     Variable, Conservative, ,
502     DontImportConflictingProtoAfterDef)
503 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
504     ClassTemplate, Conservative, ,
505     DontImportConflictingProtoAfterDef)
506 
507 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
508     Function, Liberal, ,
509     ImportConflictingDefAfterProto)
510 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
511     Variable, Liberal, ,
512     ImportConflictingDefAfterProto)
513 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
514     ClassTemplate, Liberal, ,
515     ImportConflictingDefAfterProto)
516 
517 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
518     Function, Conservative, ,
519     DontImportConflictingDefAfterProto)
520 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
521     Variable, Conservative, ,
522     DontImportConflictingDefAfterProto)
523 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
524     ClassTemplate, Conservative, ,
525     DontImportConflictingDefAfterProto)
526 
527 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
528     ClassTemplate, Liberal, ,
529     ImportConflictingProtoDefAfterProto)
530 
531 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
532     ClassTemplate, Conservative, ,
533     DontImportConflictingProtoDefAfterProto)
534 
535 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
536     ClassTemplate, Liberal, ,
537     ImportConflictingProtoAfterProtoDef)
538 
539 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
540     ClassTemplate, Conservative, ,
541     DontImportConflictingProtoAfterProtoDef)
542 
543 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
544     ClassTemplate, Liberal, ,
545     ImportConflictingProtoDefAfterDef)
546 
547 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
548     ClassTemplate, Conservative, ,
549     DontImportConflictingProtoDefAfterDef)
550 
551 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
552     ClassTemplate, Liberal, ,
553     ImportConflictingDefAfterProtoDef)
554 
555 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
556     ClassTemplate, Conservative, ,
557     DontImportConflictingDefAfterProtoDef)
558 
559 // FunctionTemplate decls overload with each other. Thus, they are imported
560 // always as a new node, independently from any ODRHandling strategy.
561 //
562 // Function template specializations are "full" specializations. Structural
563 // equivalency does not check the body of functions, so we cannot create
564 // conflicting function template specializations. Thus, ODR handling strategies
565 // has nothing to do with function template specializations. Fully specialized
566 // function templates are imported as new nodes if their template arguments are
567 // different.
568 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
569     FunctionTemplate, Liberal, ,
570     ImportDifferentDefAfterDef)
571 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
572     FunctionTemplateSpec, Liberal, ,
573     ImportDifferentDefAfterDef)
574 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
575     FunctionTemplate, Conservative, ,
576     ImportDifferentDefAfterDef)
577 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
578     FunctionTemplateSpec, Conservative, ,
579     ImportDifferentDefAfterDef)
580 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
581     FunctionTemplate, Liberal, ,
582     DontImportSameDefAfterDef)
583 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
584     FunctionTemplateSpec, Liberal, ,
585     DontImportSameDefAfterDef)
586 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
587     FunctionTemplate, Conservative, ,
588     DontImportSameDefAfterDef)
589 ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
590     FunctionTemplateSpec, Conservative, ,
591     DontImportSameDefAfterDef)
592 
593 // ======================
594 // Instantiate the tests.
595 // ======================
596 
597 // FIXME: These fail on Windows.
598 #if !defined(_WIN32)
599 INSTANTIATE_TEST_CASE_P(
600     ODRViolationTests, FunctionConservative,
601     DefaultTestValuesForRunOptions, );
602 #endif
603 INSTANTIATE_TEST_CASE_P(
604     ODRViolationTests, TypedefConservative,
605     DefaultTestValuesForRunOptions, );
606 INSTANTIATE_TEST_CASE_P(
607     ODRViolationTests, TypedefAliasConservative,
608     DefaultTestValuesForRunOptions, );
609 INSTANTIATE_TEST_CASE_P(
610     ODRViolationTests, EnumConservative,
611     DefaultTestValuesForRunOptions, );
612 INSTANTIATE_TEST_CASE_P(
613     ODRViolationTests, EnumClassConservative,
614     DefaultTestValuesForRunOptions, );
615 INSTANTIATE_TEST_CASE_P(
616     ODRViolationTests, EnumConstantConservative,
617     DefaultTestValuesForRunOptions, );
618 INSTANTIATE_TEST_CASE_P(
619     ODRViolationTests, ClassConservative,
620     DefaultTestValuesForRunOptions, );
621 INSTANTIATE_TEST_CASE_P(
622     ODRViolationTests, VariableConservative,
623     DefaultTestValuesForRunOptions, );
624 INSTANTIATE_TEST_CASE_P(
625     ODRViolationTests, ClassTemplateConservative,
626     DefaultTestValuesForRunOptions, );
627 INSTANTIATE_TEST_CASE_P(
628     ODRViolationTests, FunctionTemplateConservative,
629     DefaultTestValuesForRunOptions, );
630 // FIXME: Make VarTemplate tests work.
631 //INSTANTIATE_TEST_CASE_P(
632     //ODRViolationTests, VarTemplateConservative,
633     //DefaultTestValuesForRunOptions, );
634 INSTANTIATE_TEST_CASE_P(
635     ODRViolationTests, FunctionTemplateSpecConservative,
636     DefaultTestValuesForRunOptions, );
637 INSTANTIATE_TEST_CASE_P(
638     ODRViolationTests, ClassTemplateSpecConservative,
639     DefaultTestValuesForRunOptions, );
640 // FIXME: Make VarTemplateSpec tests work.
641 //INSTANTIATE_TEST_CASE_P(
642     //ODRViolationTests, VarTemplateSpecConservative,
643     //DefaultTestValuesForRunOptions, );
644 
645 // FIXME: These fail on Windows.
646 #if !defined(_WIN32)
647 INSTANTIATE_TEST_CASE_P(
648     ODRViolationTests, FunctionLiberal,
649     DefaultTestValuesForRunOptions, );
650 #endif
651 INSTANTIATE_TEST_CASE_P(
652     ODRViolationTests, TypedefLiberal,
653     DefaultTestValuesForRunOptions, );
654 INSTANTIATE_TEST_CASE_P(
655     ODRViolationTests, TypedefAliasLiberal,
656     DefaultTestValuesForRunOptions, );
657 INSTANTIATE_TEST_CASE_P(
658     ODRViolationTests, EnumLiberal,
659     DefaultTestValuesForRunOptions, );
660 INSTANTIATE_TEST_CASE_P(
661     ODRViolationTests, EnumClassLiberal,
662     DefaultTestValuesForRunOptions, );
663 INSTANTIATE_TEST_CASE_P(
664     ODRViolationTests, EnumConstantLiberal,
665     DefaultTestValuesForRunOptions, );
666 INSTANTIATE_TEST_CASE_P(
667     ODRViolationTests, ClassLiberal,
668     DefaultTestValuesForRunOptions, );
669 INSTANTIATE_TEST_CASE_P(
670     ODRViolationTests, VariableLiberal,
671     DefaultTestValuesForRunOptions, );
672 INSTANTIATE_TEST_CASE_P(
673     ODRViolationTests, ClassTemplateLiberal,
674     DefaultTestValuesForRunOptions, );
675 INSTANTIATE_TEST_CASE_P(
676     ODRViolationTests, FunctionTemplateLiberal,
677     DefaultTestValuesForRunOptions, );
678 // FIXME: Make VarTemplate tests work.
679 // INSTANTIATE_TEST_CASE_P(
680 //     ODRViolationTests, VarTemplateLiberal,
681 //     DefaultTestValuesForRunOptions, );
682 INSTANTIATE_TEST_CASE_P(
683     ODRViolationTests, ClassTemplateSpecLiberal,
684     DefaultTestValuesForRunOptions, );
685 INSTANTIATE_TEST_CASE_P(
686     ODRViolationTests, FunctionTemplateSpecLiberal,
687     DefaultTestValuesForRunOptions, );
688 // FIXME: Make VarTemplateSpec tests work.
689 //INSTANTIATE_TEST_CASE_P(
690     //ODRViolationTests, VarTemplateSpecLiberal,
691     //DefaultTestValuesForRunOptions, );
692 
693 // clang-format on
694 
695 } // end namespace ast_matchers
696 } // end namespace clang
697