[clang] 9c72a30 - [clang][ASTImporter] New fix for default template parameter values. (#101836)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Sep 6 00:08:30 PDT 2024
Author: Balázs Kéri
Date: 2024-09-06T09:08:26+02:00
New Revision: 9c72a308d839a27ffcbb0c67104baceb1871c50e
URL: https://github.com/llvm/llvm-project/commit/9c72a308d839a27ffcbb0c67104baceb1871c50e
DIFF: https://github.com/llvm/llvm-project/commit/9c72a308d839a27ffcbb0c67104baceb1871c50e.diff
LOG: [clang][ASTImporter] New fix for default template parameter values. (#101836)
Commit e4440b8 added a change that introduced new crash in an
incorrectly handled case. This is fixed here. Default argument
definition or inheritance is preserved in the "To" AST compared to
the "From". If the default argument is defined already in the "To"
AST it can be duplicated at the import.
Added:
Modified:
clang/lib/AST/ASTImporter.cpp
clang/unittests/AST/ASTImporterTest.cpp
Removed:
################################################################################
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index fa850409ba1210..d335e34907b599 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -360,51 +360,42 @@ namespace clang {
}
template <typename TemplateParmDeclT>
- void tryUpdateTemplateParmDeclInheritedFrom(NamedDecl *RecentParm,
- NamedDecl *NewParm) {
- if (auto *ParmT = dyn_cast<TemplateParmDeclT>(RecentParm)) {
- if (ParmT->hasDefaultArgument()) {
- auto *P = cast<TemplateParmDeclT>(NewParm);
- P->removeDefaultArgument();
- P->setInheritedDefaultArgument(Importer.ToContext, ParmT);
+ Error importTemplateParameterDefaultArgument(const TemplateParmDeclT *D,
+ TemplateParmDeclT *ToD) {
+ Error Err = Error::success();
+ if (D->hasDefaultArgument()) {
+ if (D->defaultArgumentWasInherited()) {
+ auto *ToInheritedFrom = const_cast<TemplateParmDeclT *>(
+ importChecked(Err, D->getDefaultArgStorage().getInheritedFrom()));
+ if (Err)
+ return std::move(Err);
+ if (!ToInheritedFrom->hasDefaultArgument()) {
+ // Resolve possible circular dependency between default value of the
+ // template argument and the template declaration.
+ const auto ToInheritedDefaultArg =
+ importChecked(Err, D->getDefaultArgStorage()
+ .getInheritedFrom()
+ ->getDefaultArgument());
+ if (Err)
+ return std::move(Err);
+ ToInheritedFrom->setDefaultArgument(Importer.getToContext(),
+ ToInheritedDefaultArg);
+ }
+ ToD->setInheritedDefaultArgument(ToD->getASTContext(),
+ ToInheritedFrom);
+ } else {
+ Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
+ import(D->getDefaultArgument());
+ if (!ToDefaultArgOrErr)
+ return ToDefaultArgOrErr.takeError();
+ // Default argument could have been set in the
+ // '!ToInheritedFrom->hasDefaultArgument()' branch above.
+ if (!ToD->hasDefaultArgument())
+ ToD->setDefaultArgument(Importer.getToContext(),
+ *ToDefaultArgOrErr);
}
}
- }
-
- // Update the parameter list `NewParams` of a template declaration
- // by "inheriting" default argument values from `RecentParams`,
- // which is the parameter list of an earlier declaration of the
- // same template. (Note that "inheriting" default argument values
- // is not related to object-oriented inheritance.)
- //
- // In the clang AST template parameters (NonTypeTemplateParmDec,
- // TemplateTypeParmDecl, TemplateTemplateParmDecl) have a reference to the
- // default value, if one is specified at the first declaration. The default
- // value can be specified only once. The template parameters of the
- // following declarations have a reference to the original default value
- // through the "inherited" value. This value should be set for all imported
- // template parameters that have a previous declaration (also a previous
- // template declaration).
- //
- // In the `Visit*ParmDecl` functions the default value of these template
- // arguments is always imported. At that location the previous declaration
- // is not easily accessible, it is not possible to call
- // `setInheritedDefaultArgument` at that place.
- // `updateTemplateParametersInheritedFrom` is called later when the already
- // imported default value is erased and changed to "inherited".
- // It is important to change the mode to "inherited" otherwise false
- // structural in-equivalences could be detected.
- void updateTemplateParametersInheritedFrom(
- const TemplateParameterList &RecentParams,
- TemplateParameterList &NewParams) {
- for (auto [Idx, Param] : enumerate(RecentParams)) {
- tryUpdateTemplateParmDeclInheritedFrom<NonTypeTemplateParmDecl>(
- Param, NewParams.getParam(Idx));
- tryUpdateTemplateParmDeclInheritedFrom<TemplateTypeParmDecl>(
- Param, NewParams.getParam(Idx));
- tryUpdateTemplateParmDeclInheritedFrom<TemplateTemplateParmDecl>(
- Param, NewParams.getParam(Idx));
- }
+ return Err;
}
public:
@@ -5955,8 +5946,8 @@ ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
ExpectedDecl
ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
// For template arguments, we adopt the translation unit as our declaration
- // context. This context will be fixed when the actual template declaration
- // is created.
+ // context. This context will be fixed when (during) the actual template
+ // declaration is created.
ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
@@ -5988,13 +5979,8 @@ ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
ToD->setTypeConstraint(ToConceptRef, ToIDC);
}
- if (D->hasDefaultArgument()) {
- Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
- import(D->getDefaultArgument());
- if (!ToDefaultArgOrErr)
- return ToDefaultArgOrErr.takeError();
- ToD->setDefaultArgument(ToD->getASTContext(), *ToDefaultArgOrErr);
- }
+ if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
+ return Err;
return ToD;
}
@@ -6020,13 +6006,9 @@ ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
D->isParameterPack(), ToTypeSourceInfo))
return ToD;
- if (D->hasDefaultArgument()) {
- Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
- import(D->getDefaultArgument());
- if (!ToDefaultArgOrErr)
- return ToDefaultArgOrErr.takeError();
- ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
- }
+ Err = importTemplateParameterDefaultArgument(D, ToD);
+ if (Err)
+ return Err;
return ToD;
}
@@ -6057,13 +6039,8 @@ ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
*TemplateParamsOrErr))
return ToD;
- if (D->hasDefaultArgument()) {
- Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
- import(D->getDefaultArgument());
- if (!ToDefaultArgOrErr)
- return ToDefaultArgOrErr.takeError();
- ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
- }
+ if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
+ return Err;
return ToD;
}
@@ -6201,9 +6178,6 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
}
D2->setPreviousDecl(Recent);
-
- updateTemplateParametersInheritedFrom(*(Recent->getTemplateParameters()),
- **TemplateParamsOrErr);
}
return D2;
@@ -6518,9 +6492,6 @@ ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
ToTemplated->setPreviousDecl(PrevTemplated);
}
ToVarTD->setPreviousDecl(Recent);
-
- updateTemplateParametersInheritedFrom(*(Recent->getTemplateParameters()),
- **TemplateParamsOrErr);
}
return ToVarTD;
@@ -6793,9 +6764,6 @@ ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
TemplatedFD->setPreviousDecl(PrevTemplated);
}
ToFunc->setPreviousDecl(Recent);
-
- updateTemplateParametersInheritedFrom(*(Recent->getTemplateParameters()),
- *Params);
}
return ToFunc;
diff --git a/clang/unittests/AST/ASTImporterTest.cpp b/clang/unittests/AST/ASTImporterTest.cpp
index cc87e83e86055f..aacecd3fbcd902 100644
--- a/clang/unittests/AST/ASTImporterTest.cpp
+++ b/clang/unittests/AST/ASTImporterTest.cpp
@@ -9836,41 +9836,75 @@ TEST_P(ASTImporterOptionSpecificTestBase, ImportMultipleAnonymousEnumDecls) {
struct ImportTemplateParmDeclDefaultValue
: public ASTImporterOptionSpecificTestBase {
protected:
- void checkTemplateParams(RedeclarableTemplateDecl *D) {
- auto *CanD = cast<RedeclarableTemplateDecl>(D->getCanonicalDecl());
- auto *CanNonTypeP = cast<NonTypeTemplateParmDecl>(
- CanD->getTemplateParameters()->getParam(0));
- auto *CanTypeP =
- cast<TemplateTypeParmDecl>(CanD->getTemplateParameters()->getParam(1));
- auto *CanTemplateP = cast<TemplateTemplateParmDecl>(
- CanD->getTemplateParameters()->getParam(2));
- EXPECT_FALSE(CanNonTypeP->getDefaultArgStorage().isInherited());
- EXPECT_FALSE(CanTypeP->getDefaultArgStorage().isInherited());
- EXPECT_FALSE(CanTemplateP->getDefaultArgStorage().isInherited());
- for (Decl *Redecl : D->redecls()) {
- auto *ReD = cast<RedeclarableTemplateDecl>(Redecl);
- if (ReD != CanD) {
- auto *NonTypeP = cast<NonTypeTemplateParmDecl>(
- ReD->getTemplateParameters()->getParam(0));
- auto *TypeP = cast<TemplateTypeParmDecl>(
- ReD->getTemplateParameters()->getParam(1));
- auto *TemplateP = cast<TemplateTemplateParmDecl>(
- ReD->getTemplateParameters()->getParam(2));
- EXPECT_TRUE(NonTypeP->getDefaultArgStorage().isInherited());
- EXPECT_TRUE(TypeP->getDefaultArgStorage().isInherited());
- EXPECT_TRUE(TemplateP->getDefaultArgStorage().isInherited());
- EXPECT_EQ(NonTypeP->getDefaultArgStorage().getInheritedFrom(),
- CanNonTypeP);
- EXPECT_EQ(TypeP->getDefaultArgStorage().getInheritedFrom(), CanTypeP);
- EXPECT_EQ(TemplateP->getDefaultArgStorage().getInheritedFrom(),
- CanTemplateP);
- }
+ void checkTemplateParams(RedeclarableTemplateDecl *D,
+ RedeclarableTemplateDecl *InheritedFromD) {
+ auto *NonTypeP =
+ cast<NonTypeTemplateParmDecl>(D->getTemplateParameters()->getParam(0));
+ auto *TypeP =
+ cast<TemplateTypeParmDecl>(D->getTemplateParameters()->getParam(1));
+ auto *TemplateP =
+ cast<TemplateTemplateParmDecl>(D->getTemplateParameters()->getParam(2));
+ if (InheritedFromD) {
+ EXPECT_TRUE(NonTypeP->getDefaultArgStorage().isInherited());
+ EXPECT_TRUE(TypeP->getDefaultArgStorage().isInherited());
+ EXPECT_TRUE(TemplateP->getDefaultArgStorage().isInherited());
+ EXPECT_EQ(NonTypeP->getDefaultArgStorage().getInheritedFrom(),
+ InheritedFromD->getTemplateParameters()->getParam(0));
+ EXPECT_EQ(TypeP->getDefaultArgStorage().getInheritedFrom(),
+ InheritedFromD->getTemplateParameters()->getParam(1));
+ EXPECT_EQ(TemplateP->getDefaultArgStorage().getInheritedFrom(),
+ InheritedFromD->getTemplateParameters()->getParam(2));
+ } else {
+ EXPECT_FALSE(NonTypeP->getDefaultArgStorage().isInherited());
+ EXPECT_FALSE(TypeP->getDefaultArgStorage().isInherited());
+ EXPECT_FALSE(TemplateP->getDefaultArgStorage().isInherited());
}
}
- void testImport(RedeclarableTemplateDecl *FromD) {
- RedeclarableTemplateDecl *ToD = Import(FromD, Lang_CXX14);
- checkTemplateParams(ToD);
+ void testImport(RedeclarableTemplateDecl *FromD1,
+ RedeclarableTemplateDecl *FromD2,
+ RedeclarableTemplateDecl *FromD3,
+ RedeclarableTemplateDecl *ToExistingD1) {
+ auto *ToD1 = Import(FromD1, Lang_CXX14);
+ auto *ToD2 = Import(FromD2, Lang_CXX14);
+ auto *ToD3 = Import(FromD3, Lang_CXX14);
+ checkTemplateParams(ToD1, nullptr);
+ checkTemplateParams(ToD2, ToD1);
+ checkTemplateParams(ToD3, ToExistingD1 ? ToExistingD1 : ToD1);
+ }
+
+ // In these tests a circular dependency is created between the template
+ // parameter default value and the template declaration (with the same
+ // template parameter).
+ template <class TemplateParmDeclT>
+ void
+ testTemplateParmDeclCircularDependency(ClassTemplateDecl *FromD,
+ ClassTemplateDecl *FromDInherited) {
+ auto GetTemplateParm =
+ [](ClassTemplateDecl *D) -> const TemplateParmDeclT * {
+ return dyn_cast<TemplateParmDeclT>(
+ D->getTemplateParameters()->getParam(0));
+ };
+
+ ASSERT_FALSE(GetTemplateParm(FromD)->getDefaultArgStorage().isInherited());
+ ASSERT_TRUE(
+ GetTemplateParm(FromDInherited)->getDefaultArgStorage().isInherited());
+
+ auto *ToD = Import(FromD, Lang_CXX14);
+ EXPECT_TRUE(ToD);
+
+ auto *ToDInherited = Import(FromDInherited, Lang_CXX14);
+ EXPECT_TRUE(ToDInherited);
+
+ EXPECT_FALSE(GetTemplateParm(ToD)->getDefaultArgStorage().isInherited());
+ EXPECT_TRUE(
+ GetTemplateParm(ToDInherited)->getDefaultArgStorage().isInherited());
+ EXPECT_EQ(GetTemplateParm(ToDInherited)
+ ->getDefaultArgStorage()
+ .getInheritedFrom(),
+ GetTemplateParm(ToD));
+
+ EXPECT_EQ(ToD->getPreviousDecl(), ToDInherited);
}
const char *CodeFunction =
@@ -9878,81 +9912,245 @@ struct ImportTemplateParmDeclDefaultValue
template <class> struct X;
template <int A = 2, typename B = int, template<class> class C = X>
- void f();
+ void test();
template <int A, typename B, template<class> class C>
- void f();
+ void test();
template <int A, typename B, template<class> class C>
- void f() {}
+ void test() {}
)";
const char *CodeClass =
R"(
+ namespace N {
template <class> struct X;
template <int A = 2, typename B = int, template<class> class C = X>
- struct S;
+ struct test;
template <int A, typename B, template<class> class C>
- struct S;
+ struct test;
template <int A, typename B, template<class> class C>
- struct S {};
+ struct test {};
+ }
)";
const char *CodeVar =
R"(
+ namespace N {
template <class> struct X;
template <int A = 2, typename B = int, template<class> class C = X>
- extern int V;
+ extern int test;
template <int A, typename B, template<class> class C>
- extern int V;
+ extern int test;
template <int A, typename B, template<class> class C>
- int V = A;
+ int test = A;
+ }
)";
};
-TEST_P(ImportTemplateParmDeclDefaultValue, ImportFunctionTemplate) {
- Decl *FromTU = getTuDecl(CodeFunction, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<FunctionTemplateDecl>().match(
+TEST_P(ImportTemplateParmDeclDefaultValue, InvisibleInheritedFrom) {
+ const char *ToCode =
+ R"(
+ template <int P = 1>
+ void f() {}
+ )";
+ TranslationUnitDecl *ToTU = getToTuDecl(ToCode, Lang_CXX14);
+ auto *ToFDef = FirstDeclMatcher<FunctionTemplateDecl>().match(
+ ToTU, functionTemplateDecl(hasName("f")));
+
+ const char *FromCode =
+ R"(
+ template <int P = 1>
+ void f() {}
+ template <int P>
+ void f();
+ )";
+ TranslationUnitDecl *FromTU = getTuDecl(FromCode, Lang_CXX14);
+ auto *FromFDef = FirstDeclMatcher<FunctionTemplateDecl>().match(
+ FromTU, functionTemplateDecl(hasName("f")));
+ auto *FromF = LastDeclMatcher<FunctionTemplateDecl>().match(
FromTU, functionTemplateDecl(hasName("f")));
- testImport(FromLastD);
+
+ auto *ToFDefImported = Import(FromFDef, Lang_CXX14);
+ EXPECT_EQ(ToFDefImported, ToFDef);
+ auto *ToF = Import(FromF, Lang_CXX14);
+ EXPECT_NE(ToF, ToFDef);
+ const auto *Parm = dyn_cast<NonTypeTemplateParmDecl>(
+ ToF->getTemplateParameters()->getParam(0));
+ EXPECT_TRUE(Parm->defaultArgumentWasInherited());
+ // FIXME: This behavior may be confusing:
+ // Default value is not inherited from the existing declaration, instead a new
+ // is created at import that is similar to the existing but not reachable from
+ // the AST.
+ EXPECT_NE(Parm->getDefaultArgStorage().getInheritedFrom(),
+ ToFDef->getTemplateParameters()->getParam(0));
+}
+
+TEST_P(ImportTemplateParmDeclDefaultValue, ImportFunctionTemplate) {
+ TranslationUnitDecl *FromTU = getTuDecl(CodeFunction, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<FunctionTemplateDecl>().match(
+ FromTU, functionTemplateDecl(hasName("test") /*, hasBody(stmt())*/));
+ auto *D2 = dyn_cast<FunctionTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<FunctionTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, nullptr);
}
TEST_P(ImportTemplateParmDeclDefaultValue, ImportExistingFunctionTemplate) {
- getToTuDecl(CodeFunction, Lang_CXX14);
- Decl *FromTU = getTuDecl(CodeFunction, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<FunctionTemplateDecl>().match(
- FromTU, functionTemplateDecl(hasName("f")));
- testImport(FromLastD);
+ TranslationUnitDecl *ToTU = getToTuDecl(CodeFunction, Lang_CXX14);
+ auto *ToD1 = FirstDeclMatcher<FunctionTemplateDecl>().match(
+ ToTU, functionTemplateDecl(hasName("test")));
+ TranslationUnitDecl *FromTU = getTuDecl(CodeFunction, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<FunctionTemplateDecl>().match(
+ FromTU, functionTemplateDecl(hasName("test")));
+ auto *D2 = dyn_cast<FunctionTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<FunctionTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, ToD1);
}
TEST_P(ImportTemplateParmDeclDefaultValue, ImportClassTemplate) {
- Decl *FromTU = getTuDecl(CodeClass, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<ClassTemplateDecl>().match(
- FromTU, classTemplateDecl(hasName("S")));
- testImport(FromLastD);
+ TranslationUnitDecl *FromTU = getTuDecl(CodeClass, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("test")));
+ auto *D2 = dyn_cast<ClassTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<ClassTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, nullptr);
}
TEST_P(ImportTemplateParmDeclDefaultValue, ImportExistingClassTemplate) {
- getToTuDecl(CodeClass, Lang_CXX14);
- Decl *FromTU = getTuDecl(CodeClass, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<ClassTemplateDecl>().match(
- FromTU, classTemplateDecl(hasName("S")));
- testImport(FromLastD);
+ TranslationUnitDecl *ToTU = getToTuDecl(CodeClass, Lang_CXX14);
+ auto *ToD1 = FirstDeclMatcher<ClassTemplateDecl>().match(
+ ToTU, classTemplateDecl(hasName("test")));
+ TranslationUnitDecl *FromTU = getTuDecl(CodeClass, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("test")));
+ auto *D2 = dyn_cast<ClassTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<ClassTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, ToD1);
}
TEST_P(ImportTemplateParmDeclDefaultValue, ImportVarTemplate) {
- Decl *FromTU = getTuDecl(CodeVar, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<VarTemplateDecl>().match(
- FromTU, varTemplateDecl(hasName("V")));
- testImport(FromLastD);
+ TranslationUnitDecl *FromTU = getTuDecl(CodeVar, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<VarTemplateDecl>().match(
+ FromTU, varTemplateDecl(hasName("test")));
+ auto *D2 = dyn_cast<VarTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<VarTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, nullptr);
}
TEST_P(ImportTemplateParmDeclDefaultValue, ImportExistingVarTemplate) {
- getToTuDecl(CodeVar, Lang_CXX14);
- Decl *FromTU = getTuDecl(CodeVar, Lang_CXX14);
- auto *FromLastD = LastDeclMatcher<VarTemplateDecl>().match(
- FromTU, varTemplateDecl(hasName("V")));
- testImport(FromLastD);
+ TranslationUnitDecl *ToTU = getToTuDecl(CodeVar, Lang_CXX14);
+ auto *ToD1 = FirstDeclMatcher<VarTemplateDecl>().match(
+ ToTU, varTemplateDecl(hasName("test")));
+ TranslationUnitDecl *FromTU = getTuDecl(CodeVar, Lang_CXX14);
+ auto *D3 = LastDeclMatcher<VarTemplateDecl>().match(
+ FromTU, varTemplateDecl(hasName("test")));
+ auto *D2 = dyn_cast<VarTemplateDecl>(D3->getPreviousDecl());
+ auto *D1 = dyn_cast<VarTemplateDecl>(D2->getPreviousDecl());
+ testImport(D1, D2, D3, ToD1);
+}
+
+TEST_P(ImportTemplateParmDeclDefaultValue,
+ NonTypeTemplateParmDeclCircularDependency) {
+ const char *Code =
+ R"(
+ struct Z;
+
+ struct Y {
+ Z *z;
+ static const int x = 1;
+ };
+
+ template <int P1 = Y::x>
+ struct X;
+
+ template <int P2>
+ struct X {
+ static const int A = 1;
+ };
+
+ struct Z {
+ template<int P>
+ void f(int A = X<P>::A);
+ };
+ )";
+
+ Decl *FromTU = getTuDecl(Code, Lang_CXX14);
+ auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+ auto *FromDInherited = LastDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+
+ testTemplateParmDeclCircularDependency<NonTypeTemplateParmDecl>(
+ FromD, FromDInherited);
+}
+
+TEST_P(ImportTemplateParmDeclDefaultValue,
+ TemplateTypeParmDeclCircularDependency) {
+ const char *Code =
+ R"(
+ struct Z;
+
+ struct Y {
+ Z *z;
+ };
+
+ template <typename T1 = Y>
+ struct X;
+
+ template <typename T2>
+ struct X {
+ static const int A = 1;
+ };
+
+ struct Z {
+ template<typename T>
+ void f(int A = X<T>::A);
+ };
+ )";
+
+ Decl *FromTU = getTuDecl(Code, Lang_CXX14);
+ auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+ auto *FromDInherited = LastDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+
+ testTemplateParmDeclCircularDependency<TemplateTypeParmDecl>(FromD,
+ FromDInherited);
+}
+
+TEST_P(ImportTemplateParmDeclDefaultValue,
+ TemplateTemplateParmDeclCircularDependency) {
+ const char *Code =
+ R"(
+ struct Z;
+
+ template <int>
+ struct Y {
+ Z *z;
+ };
+
+ template <template <int> class T1 = Y>
+ struct X;
+
+ template <template <int> class T2>
+ struct X {
+ static const int A = 1;
+ };
+
+ struct Z {
+ template <template <int> class T>
+ void f(int A = X<T>::A);
+ };
+ )";
+
+ Decl *FromTU = getTuDecl(Code, Lang_CXX14);
+ auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+ auto *FromDInherited = LastDeclMatcher<ClassTemplateDecl>().match(
+ FromTU, classTemplateDecl(hasName("X")));
+
+ testTemplateParmDeclCircularDependency<TemplateTemplateParmDecl>(
+ FromD, FromDInherited);
}
INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ASTImporterLookupTableTest,
More information about the cfe-commits
mailing list