return true;
}
+bool ASTContext::isSameDefaultTemplateArgument(const NamedDecl *X,
+ const NamedDecl *Y) const {
+ // If the type parameter isn't the same already, we don't need to check the
+ // default argument further.
+ if (!isSameTemplateParameter(X, Y))
+ return false;
+
+ if (auto *TTPX = dyn_cast<TemplateTypeParmDecl>(X)) {
+ auto *TTPY = cast<TemplateTypeParmDecl>(Y);
+ if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
+ return false;
+
+ return hasSameType(TTPX->getDefaultArgument(), TTPY->getDefaultArgument());
+ }
+
+ if (auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
+ auto *NTTPY = cast<NonTypeTemplateParmDecl>(Y);
+ if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
+ return false;
+
+ Expr *DefaultArgumentX = NTTPX->getDefaultArgument()->IgnoreImpCasts();
+ Expr *DefaultArgumentY = NTTPY->getDefaultArgument()->IgnoreImpCasts();
+ llvm::FoldingSetNodeID XID, YID;
+ DefaultArgumentX->Profile(XID, *this, /*Canonical=*/true);
+ DefaultArgumentY->Profile(YID, *this, /*Canonical=*/true);
+ return XID == YID;
+ }
+
+ auto *TTPX = cast<TemplateTemplateParmDecl>(X);
+ auto *TTPY = cast<TemplateTemplateParmDecl>(Y);
+
+ if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
+ return false;
+
+ const TemplateArgument &TAX = TTPX->getDefaultArgument().getArgument();
+ const TemplateArgument &TAY = TTPY->getDefaultArgument().getArgument();
+ return hasSameTemplateName(TAX.getAsTemplate(), TAY.getAsTemplate());
+}
+
static NamespaceDecl *getNamespace(const NestedNameSpecifier *X) {
if (auto *NS = X->getAsNamespace())
return NS;
return false;
}
-static bool hasSameDefaultTemplateArgument(NamedDecl *X, NamedDecl *Y) {
- ASTContext &C = X->getASTContext();
- // If the type parameter isn't the same already, we don't need to check the
- // default argument further.
- if (!C.isSameTemplateParameter(X, Y))
- return false;
-
- if (auto *TTPX = dyn_cast<TemplateTypeParmDecl>(X)) {
- auto *TTPY = cast<TemplateTypeParmDecl>(Y);
- if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
- return false;
-
- return C.hasSameType(TTPX->getDefaultArgument(),
- TTPY->getDefaultArgument());
- }
-
- if (auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
- auto *NTTPY = cast<NonTypeTemplateParmDecl>(Y);
- if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
- return false;
-
- Expr *DefaultArgumentX = NTTPX->getDefaultArgument()->IgnoreImpCasts();
- Expr *DefaultArgumentY = NTTPY->getDefaultArgument()->IgnoreImpCasts();
- llvm::FoldingSetNodeID XID, YID;
- DefaultArgumentX->Profile(XID, C, /*Canonical=*/true);
- DefaultArgumentY->Profile(YID, C, /*Canonical=*/true);
- return XID == YID;
- }
-
- auto *TTPX = cast<TemplateTemplateParmDecl>(X);
- auto *TTPY = cast<TemplateTemplateParmDecl>(Y);
-
- if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
- return false;
-
- const TemplateArgument &TAX = TTPX->getDefaultArgument().getArgument();
- const TemplateArgument &TAY = TTPY->getDefaultArgument().getArgument();
- return C.hasSameTemplateName(TAX.getAsTemplate(), TAY.getAsTemplate());
-}
-
/// Checks the validity of a template parameter list, possibly
/// considering the template parameter list from a previous
/// declaration.
if (!OldTypeParm->getOwningModule() ||
isModuleUnitOfCurrentTU(OldTypeParm->getOwningModule()))
RedundantDefaultArg = true;
- else if (!hasSameDefaultTemplateArgument(OldTypeParm, NewTypeParm)) {
+ else if (!getASTContext().isSameDefaultTemplateArgument(OldTypeParm,
+ NewTypeParm)) {
InconsistentDefaultArg = true;
PrevModuleName =
OldTypeParm->getImportedOwningModule()->getFullModuleName();
if (!OldNonTypeParm->getOwningModule() ||
isModuleUnitOfCurrentTU(OldNonTypeParm->getOwningModule()))
RedundantDefaultArg = true;
- else if (!hasSameDefaultTemplateArgument(OldNonTypeParm,
- NewNonTypeParm)) {
+ else if (!getASTContext().isSameDefaultTemplateArgument(
+ OldNonTypeParm, NewNonTypeParm)) {
InconsistentDefaultArg = true;
PrevModuleName =
OldNonTypeParm->getImportedOwningModule()->getFullModuleName();
if (!OldTemplateParm->getOwningModule() ||
isModuleUnitOfCurrentTU(OldTemplateParm->getOwningModule()))
RedundantDefaultArg = true;
- else if (!hasSameDefaultTemplateArgument(OldTemplateParm,
- NewTemplateParm)) {
+ else if (!getASTContext().isSameDefaultTemplateArgument(
+ OldTemplateParm, NewTemplateParm)) {
InconsistentDefaultArg = true;
PrevModuleName =
OldTemplateParm->getImportedOwningModule()->getFullModuleName();