[clang] bc62fb9 - Ignore constraints when determining a canonical template parameter.
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Thu Mar 30 17:00:49 PDT 2023
Author: Richard Smith
Date: 2023-03-30T17:00:16-07:00
New Revision: bc62fb9e1779043ba4ffa75bb2133cc670d4105c
URL: https://github.com/llvm/llvm-project/commit/bc62fb9e1779043ba4ffa75bb2133cc670d4105c
DIFF: https://github.com/llvm/llvm-project/commit/bc62fb9e1779043ba4ffa75bb2133cc670d4105c.diff
LOG: Ignore constraints when determining a canonical template parameter.
This follows C++ [temp.over.link]/6, which says that constraints are not
part of what determines whether two template parameters are equivalent.
This allows templates that have different constraints on nested template
template parameters to be ordered by their constraints.
Added:
Modified:
clang/docs/ReleaseNotes.rst
clang/include/clang/AST/ASTContext.h
clang/lib/AST/ASTContext.cpp
clang/lib/AST/StmtProfile.cpp
clang/lib/Sema/SemaTemplate.cpp
clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
Removed:
################################################################################
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 9643f5973de5b..dc8daa605fac7 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -287,6 +287,8 @@ Bug Fixes to C++ Support
- Stop stripping CV qualifiers from the type of ``this`` when capturing it by value in
a lambda.
(`#50866 <https://github.com/llvm/llvm-project/issues/50866>`_)
+- Fix ordering of function templates by constraints when they have template
+ template parameters with
diff erent nested constraints.
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index e2362551b881d..26626192e338f 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1716,6 +1716,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
/// C++11 deduction pattern for 'auto &&' type.
QualType getAutoRRefDeductType() const;
+ /// Remove any type constraints from a template parameter type, for
+ /// equivalence comparison of template parameters.
+ QualType getUnconstrainedType(QualType T) const;
+
/// C++17 deduced class template specialization type.
QualType getDeducedTemplateSpecializationType(TemplateName Template,
QualType DeducedType,
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index e7992e458052f..841a0995238e5 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -754,11 +754,6 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
ID.AddInteger(0);
ID.AddBoolean(TTP->isParameterPack());
- const TypeConstraint *TC = TTP->getTypeConstraint();
- ID.AddBoolean(TC != nullptr);
- if (TC)
- TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
- /*Canonical=*/true);
if (TTP->isExpandedParameterPack()) {
ID.AddBoolean(true);
ID.AddInteger(TTP->getNumExpansionParameters());
@@ -770,11 +765,8 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
ID.AddInteger(1);
ID.AddBoolean(NTTP->isParameterPack());
- const Expr *TC = NTTP->getPlaceholderTypeConstraint();
- ID.AddBoolean(TC != nullptr);
- ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
- if (TC)
- TC->Profile(ID, C, /*Canonical=*/true);
+ ID.AddPointer(C.getUnconstrainedType(C.getCanonicalType(NTTP->getType()))
+ .getAsOpaquePtr());
if (NTTP->isExpandedParameterPack()) {
ID.AddBoolean(true);
ID.AddInteger(NTTP->getNumExpansionTypes());
@@ -791,65 +783,6 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
ID.AddInteger(2);
Profile(ID, C, TTP);
}
- Expr *RequiresClause = Parm->getTemplateParameters()->getRequiresClause();
- ID.AddBoolean(RequiresClause != nullptr);
- if (RequiresClause)
- RequiresClause->Profile(ID, C, /*Canonical=*/true);
-}
-
-static Expr *
-canonicalizeImmediatelyDeclaredConstraint(const ASTContext &C, Expr *IDC,
- QualType ConstrainedType) {
- // This is a bit ugly - we need to form a new immediately-declared
- // constraint that references the new parameter; this would ideally
- // require semantic analysis (e.g. template<C T> struct S {}; - the
- // converted arguments of C<T> could be an argument pack if C is
- // declared as template<typename... T> concept C = ...).
- // We don't have semantic analysis here so we dig deep into the
- // ready-made constraint expr and change the thing manually.
- ConceptSpecializationExpr *CSE;
- if (const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))
- CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());
- else
- CSE = cast<ConceptSpecializationExpr>(IDC);
- ArrayRef<TemplateArgument> OldConverted = CSE->getTemplateArguments();
- SmallVector<TemplateArgument, 3> NewConverted;
- NewConverted.reserve(OldConverted.size());
- if (OldConverted.front().getKind() == TemplateArgument::Pack) {
- // The case:
- // template<typename... T> concept C = true;
- // template<C<int> T> struct S; -> constraint is C<{T, int}>
- NewConverted.push_back(ConstrainedType);
- llvm::append_range(NewConverted,
- OldConverted.front().pack_elements().drop_front(1));
- TemplateArgument NewPack(NewConverted);
-
- NewConverted.clear();
- NewConverted.push_back(NewPack);
- assert(OldConverted.size() == 1 &&
- "Template parameter pack should be the last parameter");
- } else {
- assert(OldConverted.front().getKind() == TemplateArgument::Type &&
- "Unexpected first argument kind for immediately-declared "
- "constraint");
- NewConverted.push_back(ConstrainedType);
- llvm::append_range(NewConverted, OldConverted.drop_front(1));
- }
- auto *CSD = ImplicitConceptSpecializationDecl::Create(
- C, CSE->getNamedConcept()->getDeclContext(),
- CSE->getNamedConcept()->getLocation(), NewConverted);
-
- Expr *NewIDC = ConceptSpecializationExpr::Create(
- C, CSE->getNamedConcept(), CSE->getTemplateArgsAsWritten(), CSD,
- /*Satisfaction=*/nullptr, CSE->isInstantiationDependent(),
- CSE->containsUnexpandedParameterPack());
-
- if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))
- NewIDC = new (C) CXXFoldExpr(
- OrigFold->getType(), /*Callee*/ nullptr, SourceLocation(), NewIDC,
- BinaryOperatorKind::BO_LAnd, SourceLocation(), /*RHS=*/nullptr,
- SourceLocation(), /*NumExpansions=*/std::nullopt);
- return NewIDC;
}
TemplateTemplateParmDecl *
@@ -871,30 +804,19 @@ ASTContext::getCanonicalTemplateTemplateParmDecl(
for (TemplateParameterList::const_iterator P = Params->begin(),
PEnd = Params->end();
P != PEnd; ++P) {
+ // Note that, per C++20 [temp.over.link]/6, when determining whether
+ // template-parameters are equivalent, constraints are ignored.
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
TemplateTypeParmDecl *NewTTP = TemplateTypeParmDecl::Create(
*this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
TTP->getDepth(), TTP->getIndex(), nullptr, false,
- TTP->isParameterPack(), TTP->hasTypeConstraint(),
+ TTP->isParameterPack(), /*HasTypeConstraint=*/false,
TTP->isExpandedParameterPack()
? std::optional<unsigned>(TTP->getNumExpansionParameters())
: std::nullopt);
- if (const auto *TC = TTP->getTypeConstraint()) {
- QualType ParamAsArgument(NewTTP->getTypeForDecl(), 0);
- Expr *NewIDC = canonicalizeImmediatelyDeclaredConstraint(
- *this, TC->getImmediatelyDeclaredConstraint(),
- ParamAsArgument);
- NewTTP->setTypeConstraint(
- NestedNameSpecifierLoc(),
- DeclarationNameInfo(TC->getNamedConcept()->getDeclName(),
- SourceLocation()), /*FoundDecl=*/nullptr,
- // Actually canonicalizing a TemplateArgumentLoc is
diff icult so we
- // simply omit the ArgsAsWritten
- TC->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);
- }
CanonParams.push_back(NewTTP);
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
- QualType T = getCanonicalType(NTTP->getType());
+ QualType T = getUnconstrainedType(getCanonicalType(NTTP->getType()));
TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
NonTypeTemplateParmDecl *Param;
if (NTTP->isExpandedParameterPack()) {
@@ -925,35 +847,18 @@ ASTContext::getCanonicalTemplateTemplateParmDecl(
NTTP->isParameterPack(),
TInfo);
}
- if (AutoType *AT = T->getContainedAutoType()) {
- if (AT->isConstrained()) {
- Param->setPlaceholderTypeConstraint(
- canonicalizeImmediatelyDeclaredConstraint(
- *this, NTTP->getPlaceholderTypeConstraint(), T));
- }
- }
CanonParams.push_back(Param);
-
} else
CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
cast<TemplateTemplateParmDecl>(*P)));
}
- Expr *CanonRequiresClause = nullptr;
- if (Expr *RequiresClause = TTP->getTemplateParameters()->getRequiresClause())
- CanonRequiresClause = RequiresClause;
-
- TemplateTemplateParmDecl *CanonTTP
- = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
- SourceLocation(), TTP->getDepth(),
- TTP->getPosition(),
- TTP->isParameterPack(),
- nullptr,
- TemplateParameterList::Create(*this, SourceLocation(),
- SourceLocation(),
- CanonParams,
- SourceLocation(),
- CanonRequiresClause));
+ TemplateTemplateParmDecl *CanonTTP = TemplateTemplateParmDecl::Create(
+ *this, getTranslationUnitDecl(), SourceLocation(), TTP->getDepth(),
+ TTP->getPosition(), TTP->isParameterPack(), nullptr,
+ TemplateParameterList::Create(*this, SourceLocation(), SourceLocation(),
+ CanonParams, SourceLocation(),
+ /*RequiresClause=*/nullptr));
// Get the new insert position for the node we care about.
Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
@@ -5927,6 +5832,26 @@ ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
TypeConstraintConcept, TypeConstraintArgs);
}
+QualType ASTContext::getUnconstrainedType(QualType T) const {
+ QualType CanonT = T.getCanonicalType();
+
+ // Remove a type-constraint from a top-level auto or decltype(auto).
+ if (auto *AT = CanonT->getAs<AutoType>()) {
+ if (!AT->isConstrained())
+ return T;
+ return getQualifiedType(getAutoType(QualType(), AT->getKeyword(), false,
+ AT->containsUnexpandedParameterPack()),
+ T.getQualifiers());
+ }
+
+ // FIXME: We only support constrained auto at the top level in the type of a
+ // non-type template parameter at the moment. Once we lift that restriction,
+ // we'll need to recursively build types containing auto here.
+ assert(!CanonT->getContainedAutoType() ||
+ !CanonT->getContainedAutoType()->isConstrained());
+ return T;
+}
+
/// Return the uniqued reference to the deduced template specialization type
/// which has been deduced to the given type, or to the canonical undeduced
/// such type, or the canonical deduced-but-dependent such type.
diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp
index 960cc4f4fc27b..8a34dc98ca1af 100644
--- a/clang/lib/AST/StmtProfile.cpp
+++ b/clang/lib/AST/StmtProfile.cpp
@@ -99,7 +99,15 @@ namespace {
ID.AddInteger(NTTP->getDepth());
ID.AddInteger(NTTP->getIndex());
ID.AddBoolean(NTTP->isParameterPack());
- VisitType(NTTP->getType());
+ // C++20 [temp.over.link]p6:
+ // Two template-parameters are equivalent under the following
+ // conditions: [...] if they declare non-type template parameters,
+ // they have equivalent types ignoring the use of type-constraints
+ // for placeholder types
+ //
+ // TODO: Why do we need to include the type in the profile? It's not
+ // part of the mangling.
+ VisitType(Context.getUnconstrainedType(NTTP->getType()));
return;
}
@@ -111,6 +119,9 @@ namespace {
// definition of "equivalent" (per C++ [temp.over.link]) is at
// least as strong as the definition of "equivalent" used for
// name mangling.
+ //
+ // TODO: The Itanium C++ ABI only uses the top-level cv-qualifiers,
+ // not the entirety of the type.
VisitType(Parm->getType());
ID.AddInteger(Parm->getFunctionScopeDepth());
ID.AddInteger(Parm->getFunctionScopeIndex());
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 4a667d046f149..e277dccb31875 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -8023,8 +8023,14 @@ static bool MatchTemplateParameterKind(
// to actually compare the arguments.
if (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
(!OldNTTP->getType()->isDependentType() &&
- !NewNTTP->getType()->isDependentType()))
- if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
+ !NewNTTP->getType()->isDependentType())) {
+ // C++20 [temp.over.link]p6:
+ // Two [non-type] template-parameters are equivalent [if] they have
+ // equivalent types ignoring the use of type-constraints for
+ // placeholder types
+ QualType OldType = S.Context.getUnconstrainedType(OldNTTP->getType());
+ QualType NewType = S.Context.getUnconstrainedType(NewNTTP->getType());
+ if (!S.Context.hasSameType(OldType, NewType)) {
if (Complain) {
unsigned NextDiag = diag::err_template_nontype_parm_
diff erent_type;
if (TemplateArgLoc.isValid()) {
@@ -8042,6 +8048,7 @@ static bool MatchTemplateParameterKind(
return false;
}
+ }
}
// For template template parameters, check the template parameter types.
// The template parameter lists of template template
diff --git a/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp b/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
index 55626edddf20d..9f44878da6254 100644
--- a/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
+++ b/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
@@ -157,3 +157,24 @@ int h() {
}
}
+
+namespace NestedConstraintsDiffer {
+ template<typename T> concept A = true;
+ template<typename T> concept B = A<T> && true;
+
+ // This is valid: we can compare the constraints of the two overloads of `f`
+ // because the template-parameters are equivalent, despite having
diff erent
+ // constraints.
+ template<typename T> struct Z {};
+ template<template<typename T> typename> struct X {};
+ template<A U, template<A T> typename TT> void f(U, X<TT>) {}
+ template<B U, template<B T> typename TT> void f(U, X<TT>) {}
+ void g(X<Z> x) { f(0, x); }
+
+ // Same thing with a constrained non-type parameter.
+ template<auto N> struct W {};
+ template<template<auto> typename> struct Y {};
+ template<A U, template<A auto> typename TT> void h(U, Y<TT>) {}
+ template<B U, template<B auto> typename TT> void h(U, Y<TT>) {}
+ void i(Y<W> x) { h(0, x); }
+}
More information about the cfe-commits
mailing list