[clang] [clang-tools-extra] [libcxx] [clang] improved preservation of template keyword (PR #133610)
Matheus Izvekov via cfe-commits
cfe-commits at lists.llvm.org
Sun Mar 30 12:24:24 PDT 2025
https://github.com/mizvekov updated https://github.com/llvm/llvm-project/pull/133610
>From 471bef0599a56ee90c1f8e2f7505a7b0003433c2 Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sat, 22 Mar 2025 17:29:16 -0300
Subject: [PATCH 1/9] Revert "[Clang] Distinguish expanding-pack-in-place cases
for SubstTemplateTypeParmTypes (#114220)"
This reverts commit adb0d8ddceb143749c519d14b8b31b481071da77.
---
clang/include/clang/AST/ASTContext.h | 4 +--
clang/include/clang/AST/PropertiesBase.td | 1 -
clang/include/clang/AST/Type.h | 29 ++--------------
clang/include/clang/AST/TypeProperties.td | 5 +--
clang/lib/AST/ASTContext.cpp | 7 ++--
clang/lib/AST/ASTImporter.cpp | 4 +--
clang/lib/AST/Type.cpp | 6 +---
clang/lib/Sema/SemaTemplateInstantiate.cpp | 35 ++++++--------------
clang/test/SemaCXX/cxx20-ctad-type-alias.cpp | 2 +-
9 files changed, 23 insertions(+), 70 deletions(-)
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index af8c49e99a7ce..1f7c75559e1e9 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1798,9 +1798,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType
getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
unsigned Index,
- std::optional<unsigned> PackIndex,
- SubstTemplateTypeParmTypeFlag Flag =
- SubstTemplateTypeParmTypeFlag::None) const;
+ std::optional<unsigned> PackIndex) const;
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
unsigned Index, bool Final,
const TemplateArgument &ArgPack);
diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td
index 42883b6419261..5f3a885832e2e 100644
--- a/clang/include/clang/AST/PropertiesBase.td
+++ b/clang/include/clang/AST/PropertiesBase.td
@@ -137,7 +137,6 @@ def Selector : PropertyType;
def SourceLocation : PropertyType;
def StmtRef : RefPropertyType<"Stmt"> { let ConstWhenWriting = 1; }
def ExprRef : SubclassPropertyType<"Expr", StmtRef>;
-def SubstTemplateTypeParmTypeFlag : EnumPropertyType;
def TemplateArgument : PropertyType;
def TemplateArgumentKind : EnumPropertyType<"TemplateArgument::ArgKind">;
def TemplateName : DefaultValuePropertyType;
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index a809102c069a8..c927eb13711c1 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -1786,15 +1786,6 @@ enum class AutoTypeKeyword {
GNUAutoType
};
-enum class SubstTemplateTypeParmTypeFlag {
- None,
-
- /// Whether to expand the pack using the stored PackIndex in place. This is
- /// useful for e.g. substituting into an atomic constraint expression, where
- /// that expression is part of an unexpanded pack.
- ExpandPacksInPlace,
-};
-
enum class ArraySizeModifier;
enum class ElaboratedTypeKeyword;
enum class VectorKind;
@@ -2164,9 +2155,6 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
LLVM_PREFERRED_TYPE(bool)
unsigned HasNonCanonicalUnderlyingType : 1;
- LLVM_PREFERRED_TYPE(SubstTemplateTypeParmTypeFlag)
- unsigned SubstitutionFlag : 1;
-
// The index of the template parameter this substitution represents.
unsigned Index : 15;
@@ -6409,8 +6397,7 @@ class SubstTemplateTypeParmType final
Decl *AssociatedDecl;
SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
- unsigned Index, std::optional<unsigned> PackIndex,
- SubstTemplateTypeParmTypeFlag Flag);
+ unsigned Index, std::optional<unsigned> PackIndex);
public:
/// Gets the type that was substituted for the template
@@ -6439,31 +6426,21 @@ class SubstTemplateTypeParmType final
return SubstTemplateTypeParmTypeBits.PackIndex - 1;
}
- SubstTemplateTypeParmTypeFlag getSubstitutionFlag() const {
- return static_cast<SubstTemplateTypeParmTypeFlag>(
- SubstTemplateTypeParmTypeBits.SubstitutionFlag);
- }
-
bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }
void Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getReplacementType(), getAssociatedDecl(), getIndex(),
- getPackIndex(), getSubstitutionFlag());
+ getPackIndex());
}
static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
const Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex,
- SubstTemplateTypeParmTypeFlag Flag) {
+ std::optional<unsigned> PackIndex) {
Replacement.Profile(ID);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
- ID.AddInteger(llvm::to_underlying(Flag));
- assert((Flag != SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace ||
- PackIndex) &&
- "ExpandPacksInPlace needs a valid PackIndex");
}
static bool classof(const Type *T) {
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index 27f71bf5cc62f..4d89d8a47396a 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -827,14 +827,11 @@ let Class = SubstTemplateTypeParmType in {
def : Property<"PackIndex", Optional<UInt32>> {
let Read = [{ node->getPackIndex() }];
}
- def : Property<"SubstitutionFlag", SubstTemplateTypeParmTypeFlag> {
- let Read = [{ node->getSubstitutionFlag() }];
- }
// The call to getCanonicalType here existed in ASTReader.cpp, too.
def : Creator<[{
return ctx.getSubstTemplateTypeParmType(
- replacementType, associatedDecl, Index, PackIndex, SubstitutionFlag);
+ replacementType, associatedDecl, Index, PackIndex);
}]>;
}
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 2d9480ebcf00c..292f29748f555 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -5449,11 +5449,10 @@ QualType ASTContext::getHLSLAttributedResourceType(
/// Retrieve a substitution-result type.
QualType ASTContext::getSubstTemplateTypeParmType(
QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex,
- SubstTemplateTypeParmTypeFlag Flag) const {
+ std::optional<unsigned> PackIndex) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index,
- PackIndex, Flag);
+ PackIndex);
void *InsertPos = nullptr;
SubstTemplateTypeParmType *SubstParm =
SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
@@ -5463,7 +5462,7 @@ QualType ASTContext::getSubstTemplateTypeParmType(
!Replacement.isCanonical()),
alignof(SubstTemplateTypeParmType));
SubstParm = new (Mem) SubstTemplateTypeParmType(Replacement, AssociatedDecl,
- Index, PackIndex, Flag);
+ Index, PackIndex);
Types.push_back(SubstParm);
SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 1db30b3f3f76f..b63e4da4896ff 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1631,8 +1631,8 @@ ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
return ToReplacementTypeOrErr.takeError();
return Importer.getToContext().getSubstTemplateTypeParmType(
- *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(), T->getPackIndex(),
- T->getSubstitutionFlag());
+ *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(),
+ T->getPackIndex());
}
ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 08798219c0b83..478c0b5f779b7 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -4270,7 +4270,7 @@ static const TemplateTypeParmDecl *getReplacedParameter(Decl *D,
SubstTemplateTypeParmType::SubstTemplateTypeParmType(
QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex, SubstTemplateTypeParmTypeFlag Flag)
+ std::optional<unsigned> PackIndex)
: Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
Replacement->getDependence()),
AssociatedDecl(AssociatedDecl) {
@@ -4281,10 +4281,6 @@ SubstTemplateTypeParmType::SubstTemplateTypeParmType(
SubstTemplateTypeParmTypeBits.Index = Index;
SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0;
- SubstTemplateTypeParmTypeBits.SubstitutionFlag = llvm::to_underlying(Flag);
- assert((Flag != SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace ||
- PackIndex) &&
- "ExpandPacksInPlace needs a valid PackIndex");
assert(AssociatedDecl != nullptr);
}
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 00dcadb41e8fb..6c9cd6512859a 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1720,17 +1720,14 @@ namespace {
QualType
TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
SubstTemplateTypeParmTypeLoc TL) {
- const SubstTemplateTypeParmType *Type = TL.getTypePtr();
- if (Type->getSubstitutionFlag() !=
- SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace)
+ if (SemaRef.CodeSynthesisContexts.back().Kind !=
+ Sema::CodeSynthesisContext::ConstraintSubstitution)
return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
- assert(Type->getPackIndex());
- TemplateArgument TA = TemplateArgs(
- Type->getReplacedParameter()->getDepth(), Type->getIndex());
- assert(*Type->getPackIndex() + 1 <= TA.pack_size());
- Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
- SemaRef, TA.pack_size() - 1 - *Type->getPackIndex());
+ auto PackIndex = TL.getTypePtr()->getPackIndex();
+ std::optional<Sema::ArgumentPackSubstitutionIndexRAII> SubstIndex;
+ if (SemaRef.ArgumentPackSubstitutionIndex == -1 && PackIndex)
+ SubstIndex.emplace(SemaRef, *PackIndex);
return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
}
@@ -3176,11 +3173,7 @@ struct ExpandPackedTypeConstraints
using inherited = TreeTransform<ExpandPackedTypeConstraints>;
- const MultiLevelTemplateArgumentList &TemplateArgs;
-
- ExpandPackedTypeConstraints(
- Sema &SemaRef, const MultiLevelTemplateArgumentList &TemplateArgs)
- : inherited(SemaRef), TemplateArgs(TemplateArgs) {}
+ ExpandPackedTypeConstraints(Sema &SemaRef) : inherited(SemaRef) {}
using inherited::TransformTemplateTypeParmType;
@@ -3196,15 +3189,9 @@ struct ExpandPackedTypeConstraints
assert(SemaRef.ArgumentPackSubstitutionIndex != -1);
- TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
-
- std::optional<unsigned> PackIndex;
- if (Arg.getKind() == TemplateArgument::Pack)
- PackIndex = Arg.pack_size() - 1 - SemaRef.ArgumentPackSubstitutionIndex;
-
QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
- TL.getType(), T->getDecl(), T->getIndex(), PackIndex,
- SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace);
+ TL.getType(), T->getDecl(), T->getIndex(),
+ SemaRef.ArgumentPackSubstitutionIndex);
SubstTemplateTypeParmTypeLoc NewTL =
TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
@@ -3263,8 +3250,8 @@ bool Sema::SubstTypeConstraint(
TemplateArgumentListInfo InstArgs;
InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
- if (ExpandPackedTypeConstraints(*this, TemplateArgs)
- .SubstTemplateArguments(TemplArgInfo->arguments(), InstArgs))
+ if (ExpandPackedTypeConstraints(*this).SubstTemplateArguments(
+ TemplArgInfo->arguments(), InstArgs))
return true;
// The type of the original parameter.
diff --git a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp
index 832ce15e66250..c863cc841af42 100644
--- a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp
+++ b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp
@@ -485,7 +485,7 @@ struct Out {
A(T2);
};
A(int) -> A<T1>;
-
+
template <typename T3>
using B = A<T3>;
};
>From 1a7cee2de26e57a64d6aa6587240dd96ab0d9ad6 Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sat, 22 Mar 2025 17:39:37 -0300
Subject: [PATCH 2/9] Revert "[Clang][Sema] Retain the expanding index for
unevaluated type constraints (#109518)"
This reverts commit 50e5411e4247421fd606f0a206682fcdf0303ae3.
---
clang/include/clang/Sema/Sema.h | 1 -
clang/lib/Sema/SemaTemplate.cpp | 6 +-
clang/lib/Sema/SemaTemplateInstantiate.cpp | 127 +--------------------
clang/lib/Sema/SemaType.cpp | 8 +-
4 files changed, 7 insertions(+), 135 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index c74e709ce06d2..bf89d15d9a792 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11350,7 +11350,6 @@ class Sema final : public SemaBase {
ConceptDecl *NamedConcept, NamedDecl *FoundDecl,
const TemplateArgumentListInfo *TemplateArgs,
TemplateTypeParmDecl *ConstrainedParameter,
- QualType ConstrainedType,
SourceLocation EllipsisLoc);
bool AttachTypeConstraint(AutoTypeLoc TL,
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index be81b6a46b2c0..3c83721a481b7 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -1133,8 +1133,7 @@ bool Sema::BuildTypeConstraint(const CXXScopeSpec &SS,
SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc(),
ConceptName, CD, /*FoundDecl=*/USD ? cast<NamedDecl>(USD) : CD,
TypeConstr->LAngleLoc.isValid() ? &TemplateArgs : nullptr,
- ConstrainedParameter, Context.getTypeDeclType(ConstrainedParameter),
- EllipsisLoc);
+ ConstrainedParameter, EllipsisLoc);
}
template <typename ArgumentLocAppender>
@@ -1191,7 +1190,6 @@ bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
ConceptDecl *NamedConcept, NamedDecl *FoundDecl,
const TemplateArgumentListInfo *TemplateArgs,
TemplateTypeParmDecl *ConstrainedParameter,
- QualType ConstrainedType,
SourceLocation EllipsisLoc) {
// C++2a [temp.param]p4:
// [...] If Q is of the form C<A1, ..., An>, then let E' be
@@ -1200,7 +1198,7 @@ bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
TemplateArgs ? ASTTemplateArgumentListInfo::Create(Context,
*TemplateArgs) : nullptr;
- QualType ParamAsArgument = ConstrainedType;
+ QualType ParamAsArgument(ConstrainedParameter->getTypeForDecl(), 0);
ExprResult ImmediatelyDeclaredConstraint = formImmediatelyDeclaredConstraint(
*this, NS, NameInfo, NamedConcept, FoundDecl,
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 6c9cd6512859a..ec9a2fb1e9542 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1717,21 +1717,6 @@ namespace {
SubstTemplateTypeParmPackTypeLoc TL,
bool SuppressObjCLifetime);
- QualType
- TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
- SubstTemplateTypeParmTypeLoc TL) {
- if (SemaRef.CodeSynthesisContexts.back().Kind !=
- Sema::CodeSynthesisContext::ConstraintSubstitution)
- return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
-
- auto PackIndex = TL.getTypePtr()->getPackIndex();
- std::optional<Sema::ArgumentPackSubstitutionIndexRAII> SubstIndex;
- if (SemaRef.ArgumentPackSubstitutionIndex == -1 && PackIndex)
- SubstIndex.emplace(SemaRef, *PackIndex);
-
- return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
- }
-
CXXRecordDecl::LambdaDependencyKind
ComputeLambdaDependency(LambdaScopeInfo *LSI) {
if (auto TypeAlias =
@@ -3166,58 +3151,6 @@ namespace {
} // namespace
-namespace {
-
-struct ExpandPackedTypeConstraints
- : TreeTransform<ExpandPackedTypeConstraints> {
-
- using inherited = TreeTransform<ExpandPackedTypeConstraints>;
-
- ExpandPackedTypeConstraints(Sema &SemaRef) : inherited(SemaRef) {}
-
- using inherited::TransformTemplateTypeParmType;
-
- QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL, bool) {
- const TemplateTypeParmType *T = TL.getTypePtr();
- if (!T->isParameterPack()) {
- TemplateTypeParmTypeLoc NewTL =
- TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
- NewTL.setNameLoc(TL.getNameLoc());
- return TL.getType();
- }
-
- assert(SemaRef.ArgumentPackSubstitutionIndex != -1);
-
- QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
- TL.getType(), T->getDecl(), T->getIndex(),
- SemaRef.ArgumentPackSubstitutionIndex);
- SubstTemplateTypeParmTypeLoc NewTL =
- TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
- NewTL.setNameLoc(TL.getNameLoc());
- return Result;
- }
-
- QualType TransformSubstTemplateTypeParmType(TypeLocBuilder &TLB,
- SubstTemplateTypeParmTypeLoc TL) {
- const SubstTemplateTypeParmType *T = TL.getTypePtr();
- if (T->getPackIndex()) {
- SubstTemplateTypeParmTypeLoc TypeLoc =
- TLB.push<SubstTemplateTypeParmTypeLoc>(TL.getType());
- TypeLoc.setNameLoc(TL.getNameLoc());
- return TypeLoc.getType();
- }
- return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
- }
-
- bool SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
- TemplateArgumentListInfo &Out) {
- return inherited::TransformTemplateArguments(Args.begin(), Args.end(), Out);
- }
-};
-
-} // namespace
-
bool Sema::SubstTypeConstraint(
TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
const MultiLevelTemplateArgumentList &TemplateArgs,
@@ -3226,62 +3159,9 @@ bool Sema::SubstTypeConstraint(
TC->getTemplateArgsAsWritten();
if (!EvaluateConstraints) {
- bool ShouldExpandExplicitTemplateArgs =
- TemplArgInfo && ArgumentPackSubstitutionIndex != -1 &&
- llvm::any_of(TemplArgInfo->arguments(), [](auto &Arg) {
- return Arg.getArgument().containsUnexpandedParameterPack();
- });
-
- // We want to transform the packs into Subst* nodes for type constraints
- // inside a pack expansion. For example,
- //
- // template <class... Ts> void foo() {
- // bar([](C<Ts> auto value) {}...);
- // }
- //
- // As we expand Ts in the process of instantiating foo(), and retain
- // the original template depths of Ts until the constraint evaluation, we
- // would otherwise have no chance to expand Ts by the time of evaluating
- // C<auto, Ts>.
- //
- // So we form a Subst* node for Ts along with a proper substitution index
- // here, and substitute the node with a complete MLTAL later in evaluation.
- if (ShouldExpandExplicitTemplateArgs) {
- TemplateArgumentListInfo InstArgs;
- InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
- InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
- if (ExpandPackedTypeConstraints(*this).SubstTemplateArguments(
- TemplArgInfo->arguments(), InstArgs))
- return true;
-
- // The type of the original parameter.
- auto *ConstraintExpr = TC->getImmediatelyDeclaredConstraint();
- QualType ConstrainedType;
-
- if (auto *FE = dyn_cast<CXXFoldExpr>(ConstraintExpr)) {
- assert(FE->getLHS());
- ConstraintExpr = FE->getLHS();
- }
- auto *CSE = cast<ConceptSpecializationExpr>(ConstraintExpr);
- assert(!CSE->getTemplateArguments().empty() &&
- "Empty template arguments?");
- ConstrainedType = CSE->getTemplateArguments()[0].getAsType();
- assert(!ConstrainedType.isNull() &&
- "Failed to extract the original ConstrainedType?");
-
- return AttachTypeConstraint(
- TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
- TC->getNamedConcept(),
- /*FoundDecl=*/TC->getConceptReference()->getFoundDecl(), &InstArgs,
- Inst, ConstrainedType,
- Inst->isParameterPack()
- ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
- ->getEllipsisLoc()
- : SourceLocation());
- }
- Inst->setTypeConstraint(TC->getConceptReference(),
- TC->getImmediatelyDeclaredConstraint());
- return false;
+ Inst->setTypeConstraint(TC->getConceptReference(),
+ TC->getImmediatelyDeclaredConstraint());
+ return false;
}
TemplateArgumentListInfo InstArgs;
@@ -3297,7 +3177,6 @@ bool Sema::SubstTypeConstraint(
TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
TC->getNamedConcept(),
/*FoundDecl=*/TC->getConceptReference()->getFoundDecl(), &InstArgs, Inst,
- Context.getTypeDeclType(Inst),
Inst->isParameterPack()
? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
->getEllipsisLoc()
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 776d6e55acc18..2df961a48c7c3 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -3052,9 +3052,7 @@ InventTemplateParameter(TypeProcessingState &state, QualType T,
AutoLoc.getNestedNameSpecifierLoc(), AutoLoc.getConceptNameInfo(),
AutoLoc.getNamedConcept(), /*FoundDecl=*/AutoLoc.getFoundDecl(),
AutoLoc.hasExplicitTemplateArgs() ? &TAL : nullptr,
- InventedTemplateParam,
- S.Context.getTypeDeclType(InventedTemplateParam),
- D.getEllipsisLoc());
+ InventedTemplateParam, D.getEllipsisLoc());
}
} else {
// The 'auto' appears in the decl-specifiers; we've not finished forming
@@ -3091,9 +3089,7 @@ InventTemplateParameter(TypeProcessingState &state, QualType T,
/*FoundDecl=*/
USD ? cast<NamedDecl>(USD) : CD,
TemplateId->LAngleLoc.isValid() ? &TemplateArgsInfo : nullptr,
- InventedTemplateParam,
- S.Context.getTypeDeclType(InventedTemplateParam),
- D.getEllipsisLoc());
+ InventedTemplateParam, D.getEllipsisLoc());
}
}
}
>From a2a372d436c6135e13306aed2814fc1a2d66753d Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sat, 22 Mar 2025 22:51:42 -0300
Subject: [PATCH 3/9] [clang] Concepts: support pack expansions for type
constraints
This reverts an earlier attempt to support these expansions,
which was limited to type arguments and which subverted the purpose
of SubstTemplateTypeParmType.
This propagates the ArgumentPackSubstitutionIndex along with the
AssociatedConstraint, so that the pack expansion works, without
needing any new transforms or otherwise any changes to the template
instanntiation process.
This keeps the tests from the reverted commits, and adds a few more
showing the new solution also works for NTTPs.
This patch is incomplete:
* It is likely missing plumbing the ArgumentPackSubstitutionIndex
into more places.
* The Normalization cache is not adapted so it indexes on the
ArgumentPackSubstitutionIndex as well.
One new test is added, which in any case shows an ambiguous call,
but if the normalization cache were corrected, the reason for
ambighuity would change from subsumption both ways, to neither
subsumes the other.
I am not sure if the current language rules would allow
for a test case where the pack index would break an ambiguity,
this is left for future consideration.
Fixes https://github.com/llvm/llvm-project/issues/131798
---
.../modernize/UseConstraintsCheck.cpp | 4 +-
clang/docs/ReleaseNotes.rst | 3 +
clang/include/clang/AST/ASTConcept.h | 11 ++-
clang/include/clang/AST/Decl.h | 17 +++-
clang/include/clang/AST/DeclTemplate.h | 26 +++--
clang/include/clang/Sema/Sema.h | 23 +++--
clang/include/clang/Sema/SemaConcept.h | 11 ++-
clang/lib/AST/ASTImporter.cpp | 3 +-
clang/lib/AST/DeclTemplate.cpp | 26 ++---
clang/lib/Sema/SemaCodeComplete.cpp | 9 +-
clang/lib/Sema/SemaConcept.cpp | 95 ++++++++++---------
clang/lib/Sema/SemaDecl.cpp | 7 +-
clang/lib/Sema/SemaExprCXX.cpp | 7 +-
clang/lib/Sema/SemaOverload.cpp | 4 +-
clang/lib/Sema/SemaTemplate.cpp | 12 ++-
clang/lib/Sema/SemaTemplateDeduction.cpp | 16 ++--
clang/lib/Sema/SemaTemplateInstantiate.cpp | 16 +++-
clang/lib/Serialization/ASTReaderDecl.cpp | 4 +-
clang/lib/Serialization/ASTWriterDecl.cpp | 1 +
.../SemaCXX/fold_lambda_with_variadics.cpp | 47 +++++++++
clang/unittests/AST/SourceLocationTest.cpp | 6 +-
21 files changed, 232 insertions(+), 116 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/modernize/UseConstraintsCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseConstraintsCheck.cpp
index ea4d99586c711..fb82efb4dd211 100644
--- a/clang-tools-extra/clang-tidy/modernize/UseConstraintsCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/UseConstraintsCheck.cpp
@@ -356,7 +356,7 @@ static std::vector<FixItHint> handleReturnType(const FunctionDecl *Function,
if (!TypeText)
return {};
- SmallVector<const Expr *, 3> ExistingConstraints;
+ SmallVector<AssociatedConstraint, 3> ExistingConstraints;
Function->getAssociatedConstraints(ExistingConstraints);
if (!ExistingConstraints.empty()) {
// FIXME - Support adding new constraints to existing ones. Do we need to
@@ -404,7 +404,7 @@ handleTrailingTemplateType(const FunctionTemplateDecl *FunctionTemplate,
if (!ConditionText)
return {};
- SmallVector<const Expr *, 3> ExistingConstraints;
+ SmallVector<AssociatedConstraint, 3> ExistingConstraints;
Function->getAssociatedConstraints(ExistingConstraints);
if (!ExistingConstraints.empty()) {
// FIXME - Support adding new constraints to existing ones. Do we need to
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index e409f206f6eae..0655c90e72413 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -357,6 +357,9 @@ Bug Fixes to C++ Support
- Clang now uses the parameter location for abbreviated function templates in ``extern "C"``. (#GH46386)
- Clang will emit an error instead of crash when use co_await or co_yield in
C++26 braced-init-list template parameter initialization. (#GH78426)
+- Improved fix for an issue with pack expansions of type constraints, where this
+ now also works if the constraint has non-type or template template parameters.
+ (#GH131798)
- Fixes matching of nested template template parameters. (#GH130362)
- Correctly diagnoses template template paramters which have a pack parameter
not in the last position.
diff --git a/clang/include/clang/AST/ASTConcept.h b/clang/include/clang/AST/ASTConcept.h
index 00500e214f4ce..f89899c3ea7b1 100644
--- a/clang/include/clang/AST/ASTConcept.h
+++ b/clang/include/clang/AST/ASTConcept.h
@@ -229,12 +229,15 @@ class TypeConstraint {
/// type-constraint.
Expr *ImmediatelyDeclaredConstraint = nullptr;
ConceptReference *ConceptRef;
+ int ArgumentPackSubstitutionIndex;
public:
TypeConstraint(ConceptReference *ConceptRef,
- Expr *ImmediatelyDeclaredConstraint)
+ Expr *ImmediatelyDeclaredConstraint,
+ int ArgumentPackSubstitutionIndex)
: ImmediatelyDeclaredConstraint(ImmediatelyDeclaredConstraint),
- ConceptRef(ConceptRef) {}
+ ConceptRef(ConceptRef),
+ ArgumentPackSubstitutionIndex(ArgumentPackSubstitutionIndex) {}
/// \brief Get the immediately-declared constraint expression introduced by
/// this type-constraint, that is - the constraint expression that is added to
@@ -245,6 +248,10 @@ class TypeConstraint {
ConceptReference *getConceptReference() const { return ConceptRef; }
+ int getArgumentPackSubstitutionIndex() const {
+ return ArgumentPackSubstitutionIndex;
+ }
+
// FIXME: Instead of using these concept related functions the callers should
// directly work with the corresponding ConceptReference.
ConceptDecl *getNamedConcept() const { return ConceptRef->getNamedConcept(); }
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index efac36e49351e..6557a4c4962ec 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -78,6 +78,18 @@ class UnresolvedSetImpl;
class VarTemplateDecl;
enum class ImplicitParamKind;
+// Holds a constraint expression along with a pack expansion index, if
+// expanded.
+struct AssociatedConstraint {
+ const Expr *ConstraintExpr;
+ int ArgumentPackSubstitutionIndex;
+
+ AssociatedConstraint(const Expr *ConstraintExpr,
+ int ArgumentPackSubstitutionIndex)
+ : ConstraintExpr(ConstraintExpr),
+ ArgumentPackSubstitutionIndex(ArgumentPackSubstitutionIndex) {}
+};
+
/// The top declaration context.
class TranslationUnitDecl : public Decl,
public DeclContext,
@@ -2631,9 +2643,10 @@ class FunctionDecl : public DeclaratorDecl,
///
/// Use this instead of getTrailingRequiresClause for concepts APIs that
/// accept an ArrayRef of constraint expressions.
- void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
+ void
+ getAssociatedConstraints(SmallVectorImpl<AssociatedConstraint> &AC) const {
if (auto *TRC = getTrailingRequiresClause())
- AC.push_back(TRC);
+ AC.emplace_back(TRC, /*ArgumentPackSubstitutionIndex=*/-1);
}
/// Get the message that indicates why this function was deleted.
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index b27e698236c02..6123273ce5ec1 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -195,7 +195,8 @@ class TemplateParameterList final
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const;
bool hasAssociatedConstraints() const;
@@ -422,7 +423,8 @@ class TemplateDecl : public NamedDecl {
/// including constraint-expressions derived from the requires-clause,
/// trailing requires-clause (for functions and methods) and constrained
/// template parameters.
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const;
bool hasAssociatedConstraints() const;
@@ -1341,7 +1343,8 @@ class TemplateTypeParmDecl final : public TypeDecl,
}
void setTypeConstraint(ConceptReference *CR,
- Expr *ImmediatelyDeclaredConstraint);
+ Expr *ImmediatelyDeclaredConstraint,
+ int ArgumentPackSubstitutionIndex);
/// Determine whether this template parameter has a type-constraint.
bool hasTypeConstraint() const {
@@ -1353,9 +1356,11 @@ class TemplateTypeParmDecl final : public TypeDecl,
///
/// Use this instead of getTypeConstraint for concepts APIs that
/// accept an ArrayRef of constraint expressions.
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const {
if (HasTypeConstraint)
- AC.push_back(getTypeConstraint()->getImmediatelyDeclaredConstraint());
+ AC.emplace_back(getTypeConstraint()->getImmediatelyDeclaredConstraint(),
+ getTypeConstraint()->getArgumentPackSubstitutionIndex());
}
SourceRange getSourceRange() const override LLVM_READONLY;
@@ -1574,9 +1579,10 @@ class NonTypeTemplateParmDecl final
///
/// Use this instead of getPlaceholderImmediatelyDeclaredConstraint for
/// concepts APIs that accept an ArrayRef of constraint expressions.
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const {
if (Expr *E = getPlaceholderTypeConstraint())
- AC.push_back(E);
+ AC.emplace_back(E, /*ArgumentPackSubstitutionIndex=*/-1);
}
// Implement isa/cast/dyncast/etc.
@@ -2169,7 +2175,8 @@ class ClassTemplatePartialSpecializationDecl
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const {
TemplateParams->getAssociatedConstraints(AC);
}
@@ -2943,7 +2950,8 @@ class VarTemplatePartialSpecializationDecl
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &AC) const {
TemplateParams->getAssociatedConstraints(AC);
}
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index bf89d15d9a792..5f66db8e557a6 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -14550,13 +14550,14 @@ class Sema final : public SemaBase {
/// \returns true if an error occurred and satisfaction could not be checked,
/// false otherwise.
bool CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template,
+ ArrayRef<AssociatedConstraint> AssociatedConstraints,
const MultiLevelTemplateArgumentList &TemplateArgLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
llvm::SmallVector<Expr *, 4> Converted;
- return CheckConstraintSatisfaction(Template, ConstraintExprs, Converted,
- TemplateArgLists, TemplateIDRange,
- Satisfaction);
+ return CheckConstraintSatisfaction(Template, AssociatedConstraints,
+ Converted, TemplateArgLists,
+ TemplateIDRange, Satisfaction);
}
/// \brief Check whether the given list of constraint expressions are
@@ -14582,7 +14583,8 @@ class Sema final : public SemaBase {
/// \returns true if an error occurred and satisfaction could not be checked,
/// false otherwise.
bool CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template,
+ ArrayRef<AssociatedConstraint> AssociatedConstraints,
llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
const MultiLevelTemplateArgumentList &TemplateArgList,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
@@ -14660,7 +14662,7 @@ class Sema final : public SemaBase {
const NormalizedConstraint *getNormalizedAssociatedConstraints(
const NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints);
+ ArrayRef<AssociatedConstraint> AssociatedConstraints);
/// \brief Check whether the given declaration's associated constraints are
/// at least as constrained than another declaration's according to the
@@ -14671,17 +14673,18 @@ class Sema final : public SemaBase {
///
/// \returns true if an error occurred, false otherwise.
bool IsAtLeastAsConstrained(const NamedDecl *D1,
- MutableArrayRef<const Expr *> AC1,
+ MutableArrayRef<AssociatedConstraint> AC1,
const NamedDecl *D2,
- MutableArrayRef<const Expr *> AC2, bool &Result);
+ MutableArrayRef<AssociatedConstraint> AC2,
+ bool &Result);
/// If D1 was not at least as constrained as D2, but would've been if a pair
/// of atomic constraints involved had been declared in a concept and not
/// repeated in two separate places in code.
/// \returns true if such a diagnostic was emitted, false otherwise.
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(
- const NamedDecl *D1, ArrayRef<const Expr *> AC1, const NamedDecl *D2,
- ArrayRef<const Expr *> AC2);
+ const NamedDecl *D1, ArrayRef<AssociatedConstraint> AC1,
+ const NamedDecl *D2, ArrayRef<AssociatedConstraint> AC2);
private:
/// Caches pairs of template-like decls whose associated constraints were
diff --git a/clang/include/clang/Sema/SemaConcept.h b/clang/include/clang/Sema/SemaConcept.h
index cbb3720c30ee2..648a9c51ae6c1 100644
--- a/clang/include/clang/Sema/SemaConcept.h
+++ b/clang/include/clang/Sema/SemaConcept.h
@@ -114,7 +114,8 @@ struct NormalizedConstraint {
private:
static std::optional<NormalizedConstraint>
- fromConstraintExprs(Sema &S, const NamedDecl *D, ArrayRef<const Expr *> E);
+ fromAssociatedConstraints(Sema &S, const NamedDecl *D,
+ ArrayRef<AssociatedConstraint> ACs);
static std::optional<NormalizedConstraint>
fromConstraintExpr(Sema &S, const NamedDecl *D, const Expr *E);
};
@@ -138,7 +139,7 @@ struct alignas(ConstraintAlignment) FoldExpandedConstraint {
const NormalizedConstraint *getNormalizedAssociatedConstraints(
Sema &S, const NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints);
+ ArrayRef<AssociatedConstraint> AssociatedConstraints);
/// \brief SubsumptionChecker establishes subsumption
/// between two set of constraints.
@@ -149,8 +150,10 @@ class SubsumptionChecker {
SubsumptionChecker(Sema &SemaRef, SubsumptionCallable Callable = {});
- std::optional<bool> Subsumes(const NamedDecl *DP, ArrayRef<const Expr *> P,
- const NamedDecl *DQ, ArrayRef<const Expr *> Q);
+ std::optional<bool> Subsumes(const NamedDecl *DP,
+ ArrayRef<AssociatedConstraint> P,
+ const NamedDecl *DQ,
+ ArrayRef<AssociatedConstraint> Q);
bool Subsumes(const NormalizedConstraint *P, const NormalizedConstraint *Q);
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index b63e4da4896ff..d397c9285ed76 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -5983,7 +5983,8 @@ ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
if (Err)
return std::move(Err);
- ToD->setTypeConstraint(ToConceptRef, ToIDC);
+ ToD->setTypeConstraint(ToConceptRef, ToIDC,
+ TC->getArgumentPackSubstitutionIndex());
}
if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index c0f5be51db5f3..ff1c3028f89ba 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -223,20 +223,21 @@ static bool AdoptTemplateParameterList(TemplateParameterList *Params,
return Invalid;
}
-void TemplateParameterList::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+void TemplateParameterList::getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &ACs) const {
if (HasConstrainedParameters)
for (const NamedDecl *Param : *this) {
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
if (const auto *TC = TTP->getTypeConstraint())
- AC.push_back(TC->getImmediatelyDeclaredConstraint());
+ ACs.emplace_back(TC->getImmediatelyDeclaredConstraint(),
+ TC->getArgumentPackSubstitutionIndex());
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
- AC.push_back(E);
+ ACs.emplace_back(E, /*ArgumentPackSubstitutionIndex=*/-1);
}
}
if (HasRequiresClause)
- AC.push_back(getRequiresClause());
+ ACs.emplace_back(getRequiresClause(), /*ArgumentPackSubstitutionIndex=*/-1);
}
bool TemplateParameterList::hasAssociatedConstraints() const {
@@ -286,12 +287,12 @@ TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
void TemplateDecl::anchor() {}
-void TemplateDecl::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
- TemplateParams->getAssociatedConstraints(AC);
+void TemplateDecl::getAssociatedConstraints(
+ llvm::SmallVectorImpl<AssociatedConstraint> &ACs) const {
+ TemplateParams->getAssociatedConstraints(ACs);
if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
if (const Expr *TRC = FD->getTrailingRequiresClause())
- AC.push_back(TRC);
+ ACs.emplace_back(TRC, /*ArgumentPackSubstitutionIndex=*/-1);
}
bool TemplateDecl::hasAssociatedConstraints() const {
@@ -748,14 +749,15 @@ bool TemplateTypeParmDecl::isParameterPack() const {
}
void TemplateTypeParmDecl::setTypeConstraint(
- ConceptReference *Loc, Expr *ImmediatelyDeclaredConstraint) {
+ ConceptReference *Loc, Expr *ImmediatelyDeclaredConstraint,
+ int ArgumentPackSubstitutionIndex) {
assert(HasTypeConstraint &&
"HasTypeConstraint=true must be passed at construction in order to "
"call setTypeConstraint");
assert(!TypeConstraintInitialized &&
"TypeConstraint was already initialized!");
- new (getTrailingObjects<TypeConstraint>())
- TypeConstraint(Loc, ImmediatelyDeclaredConstraint);
+ new (getTrailingObjects<TypeConstraint>()) TypeConstraint(
+ Loc, ImmediatelyDeclaredConstraint, ArgumentPackSubstitutionIndex);
TypeConstraintInitialized = true;
}
diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp
index 2003701b65654..db4ddfeaccdc2 100644
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -5463,8 +5463,9 @@ class ConceptInfo {
// that T is attached to in order to gather the relevant constraints.
ConceptInfo(const TemplateTypeParmType &BaseType, Scope *S) {
auto *TemplatedEntity = getTemplatedEntity(BaseType.getDecl(), S);
- for (const Expr *E : constraintsForTemplatedEntity(TemplatedEntity))
- believe(E, &BaseType);
+ for (const AssociatedConstraint &AC :
+ constraintsForTemplatedEntity(TemplatedEntity))
+ believe(AC.ConstraintExpr, &BaseType);
}
std::vector<Member> members() {
@@ -5696,9 +5697,9 @@ class ConceptInfo {
// Gets all the type constraint expressions that might apply to the type
// variables associated with DC (as returned by getTemplatedEntity()).
- static SmallVector<const Expr *, 1>
+ static SmallVector<AssociatedConstraint, 1>
constraintsForTemplatedEntity(DeclContext *DC) {
- SmallVector<const Expr *, 1> Result;
+ SmallVector<AssociatedConstraint, 1> Result;
if (DC == nullptr)
return Result;
// Primary templates can have constraints.
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index ebee5994bfed2..d8b1722928cfc 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -567,11 +567,12 @@ static ExprResult calculateConstraintSatisfaction(
}
static bool CheckConstraintSatisfaction(
- Sema &S, const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ Sema &S, const NamedDecl *Template,
+ ArrayRef<AssociatedConstraint> AssociatedConstraints,
llvm::SmallVectorImpl<Expr *> &Converted,
const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
- if (ConstraintExprs.empty()) {
+ if (AssociatedConstraints.empty()) {
Satisfaction.IsSatisfied = true;
return false;
}
@@ -592,10 +593,12 @@ static bool CheckConstraintSatisfaction(
if (Inst.isInvalid())
return true;
- for (const Expr *ConstraintExpr : ConstraintExprs) {
+ for (const AssociatedConstraint &AC : AssociatedConstraints) {
+ Sema::ArgumentPackSubstitutionIndexRAII _(S,
+ AC.ArgumentPackSubstitutionIndex);
ExprResult Res = calculateConstraintSatisfaction(
S, Template, TemplateIDRange.getBegin(), TemplateArgsLists,
- ConstraintExpr, Satisfaction);
+ AC.ConstraintExpr, Satisfaction);
if (Res.isInvalid())
return true;
@@ -603,7 +606,8 @@ static bool CheckConstraintSatisfaction(
if (!Satisfaction.IsSatisfied) {
// Backfill the 'converted' list with nulls so we can keep the Converted
// and unconverted lists in sync.
- Converted.append(ConstraintExprs.size() - Converted.size(), nullptr);
+ Converted.append(AssociatedConstraints.size() - Converted.size(),
+ nullptr);
// [temp.constr.op] p2
// [...] To determine if a conjunction is satisfied, the satisfaction
// of the first operand is checked. If that is not satisfied, the
@@ -615,17 +619,18 @@ static bool CheckConstraintSatisfaction(
}
bool Sema::CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template,
+ ArrayRef<AssociatedConstraint> AssociatedConstraints,
llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &OutSatisfaction) {
- if (ConstraintExprs.empty()) {
+ if (AssociatedConstraints.empty()) {
OutSatisfaction.IsSatisfied = true;
return false;
}
if (!Template) {
return ::CheckConstraintSatisfaction(
- *this, nullptr, ConstraintExprs, ConvertedConstraints,
+ *this, nullptr, AssociatedConstraints, ConvertedConstraints,
TemplateArgsLists, TemplateIDRange, OutSatisfaction);
}
// Invalid templates could make their way here. Substituting them could result
@@ -654,7 +659,7 @@ bool Sema::CheckConstraintSatisfaction(
auto Satisfaction =
std::make_unique<ConstraintSatisfaction>(Template, FlattenedArgs);
- if (::CheckConstraintSatisfaction(*this, Template, ConstraintExprs,
+ if (::CheckConstraintSatisfaction(*this, Template, AssociatedConstraints,
ConvertedConstraints, TemplateArgsLists,
TemplateIDRange, *Satisfaction)) {
OutSatisfaction = *Satisfaction;
@@ -923,8 +928,10 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
ForOverloadResolution);
return CheckConstraintSatisfaction(
- FD, {FD->getTrailingRequiresClause()}, *MLTAL,
- SourceRange(UsageLoc.isValid() ? UsageLoc : FD->getLocation()),
+ FD,
+ AssociatedConstraint(FD->getTrailingRequiresClause(),
+ ArgumentPackSubstitutionIndex),
+ *MLTAL, SourceRange(UsageLoc.isValid() ? UsageLoc : FD->getLocation()),
Satisfaction);
}
@@ -1099,13 +1106,13 @@ bool Sema::FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD) {
assert(FD->getDescribedFunctionTemplate() &&
"Non-function templates don't need to be checked");
- SmallVector<const Expr *, 3> ACs;
+ SmallVector<AssociatedConstraint, 3> ACs;
FD->getDescribedFunctionTemplate()->getAssociatedConstraints(ACs);
unsigned OldTemplateDepth = CalculateTemplateDepthForConstraints(*this, FD);
- for (const Expr *Constraint : ACs)
+ for (const AssociatedConstraint &AC : ACs)
if (ConstraintExpressionDependsOnEnclosingTemplate(FD, OldTemplateDepth,
- Constraint))
+ AC.ConstraintExpr))
return true;
return false;
@@ -1115,7 +1122,7 @@ bool Sema::EnsureTemplateArgumentListConstraints(
TemplateDecl *TD, const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange) {
ConstraintSatisfaction Satisfaction;
- llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
+ llvm::SmallVector<AssociatedConstraint, 3> AssociatedConstraints;
TD->getAssociatedConstraints(AssociatedConstraints);
if (CheckConstraintSatisfaction(TD, AssociatedConstraints, TemplateArgsLists,
TemplateIDRange, Satisfaction))
@@ -1146,7 +1153,7 @@ bool Sema::CheckInstantiatedFunctionTemplateConstraints(
FunctionTemplateDecl *Template = Decl->getPrimaryTemplate();
// Note - code synthesis context for the constraints check is created
// inside CheckConstraintsSatisfaction.
- SmallVector<const Expr *, 3> TemplateAC;
+ SmallVector<AssociatedConstraint, 3> TemplateAC;
Template->getAssociatedConstraints(TemplateAC);
if (TemplateAC.empty()) {
Satisfaction.IsSatisfied = true;
@@ -1438,7 +1445,7 @@ void Sema::DiagnoseUnsatisfiedConstraint(
const NormalizedConstraint *Sema::getNormalizedAssociatedConstraints(
const NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints) {
+ ArrayRef<AssociatedConstraint> AssociatedConstraints) {
// In case the ConstrainedDecl comes from modules, it is necessary to use
// the canonical decl to avoid different atomic constraints with the 'same'
// declarations.
@@ -1446,9 +1453,8 @@ const NormalizedConstraint *Sema::getNormalizedAssociatedConstraints(
auto CacheEntry = NormalizationCache.find(ConstrainedDecl);
if (CacheEntry == NormalizationCache.end()) {
- auto Normalized =
- NormalizedConstraint::fromConstraintExprs(*this, ConstrainedDecl,
- AssociatedConstraints);
+ auto Normalized = NormalizedConstraint::fromAssociatedConstraints(
+ *this, ConstrainedDecl, AssociatedConstraints);
CacheEntry =
NormalizationCache
.try_emplace(ConstrainedDecl,
@@ -1463,7 +1469,7 @@ const NormalizedConstraint *Sema::getNormalizedAssociatedConstraints(
const NormalizedConstraint *clang::getNormalizedAssociatedConstraints(
Sema &S, const NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints) {
+ ArrayRef<AssociatedConstraint> AssociatedConstraints) {
return S.getNormalizedAssociatedConstraints(ConstrainedDecl,
AssociatedConstraints);
}
@@ -1593,14 +1599,14 @@ NormalizedConstraint &NormalizedConstraint::getRHS() const {
}
std::optional<NormalizedConstraint>
-NormalizedConstraint::fromConstraintExprs(Sema &S, const NamedDecl *D,
- ArrayRef<const Expr *> E) {
- assert(E.size() != 0);
- auto Conjunction = fromConstraintExpr(S, D, E[0]);
+NormalizedConstraint::fromAssociatedConstraints(
+ Sema &S, const NamedDecl *D, ArrayRef<AssociatedConstraint> ACs) {
+ assert(ACs.size() != 0);
+ auto Conjunction = fromConstraintExpr(S, D, ACs[0].ConstraintExpr);
if (!Conjunction)
return std::nullopt;
- for (unsigned I = 1; I < E.size(); ++I) {
- auto Next = fromConstraintExpr(S, D, E[I]);
+ for (unsigned I = 1; I < ACs.size(); ++I) {
+ auto Next = fromConstraintExpr(S, D, ACs[I].ConstraintExpr);
if (!Next)
return std::nullopt;
*Conjunction = NormalizedConstraint(S.Context, std::move(*Conjunction),
@@ -1655,8 +1661,9 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
// expression, the program is ill-formed; no diagnostic is required.
// [...]
ConceptDecl *CD = CSE->getNamedConcept();
- SubNF = S.getNormalizedAssociatedConstraints(CD,
- {CD->getConstraintExpr()});
+ SubNF = S.getNormalizedAssociatedConstraints(
+ CD, AssociatedConstraint(CD->getConstraintExpr(),
+ /*ArgumentPackSubstitutionIndex=*/-1));
if (!SubNF)
return std::nullopt;
}
@@ -1731,9 +1738,9 @@ bool FoldExpandedConstraint::AreCompatibleForSubsumption(
}
bool Sema::IsAtLeastAsConstrained(const NamedDecl *D1,
- MutableArrayRef<const Expr *> AC1,
+ MutableArrayRef<AssociatedConstraint> AC1,
const NamedDecl *D2,
- MutableArrayRef<const Expr *> AC2,
+ MutableArrayRef<AssociatedConstraint> AC2,
bool &Result) {
#ifndef NDEBUG
if (const auto *FD1 = dyn_cast<FunctionDecl>(D1)) {
@@ -1771,13 +1778,15 @@ bool Sema::IsAtLeastAsConstrained(const NamedDecl *D1,
for (size_t I = 0; I != AC1.size() && I != AC2.size(); ++I) {
if (Depth2 > Depth1) {
- AC1[I] = AdjustConstraintDepth(*this, Depth2 - Depth1)
- .TransformExpr(const_cast<Expr *>(AC1[I]))
- .get();
+ AC1[I].ConstraintExpr =
+ AdjustConstraintDepth(*this, Depth2 - Depth1)
+ .TransformExpr(const_cast<Expr *>(AC1[I].ConstraintExpr))
+ .get();
} else if (Depth1 > Depth2) {
- AC2[I] = AdjustConstraintDepth(*this, Depth1 - Depth2)
- .TransformExpr(const_cast<Expr *>(AC2[I]))
- .get();
+ AC2[I].ConstraintExpr =
+ AdjustConstraintDepth(*this, Depth1 - Depth2)
+ .TransformExpr(const_cast<Expr *>(AC2[I].ConstraintExpr))
+ .get();
}
}
@@ -1793,9 +1802,8 @@ bool Sema::IsAtLeastAsConstrained(const NamedDecl *D1,
}
bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(
- const NamedDecl *D1, ArrayRef<const Expr *> AC1, const NamedDecl *D2,
- ArrayRef<const Expr *> AC2) {
-
+ const NamedDecl *D1, ArrayRef<AssociatedConstraint> AC1,
+ const NamedDecl *D2, ArrayRef<AssociatedConstraint> AC2) {
if (isSFINAEContext())
// No need to work here because our notes would be discarded.
return false;
@@ -2106,10 +2114,9 @@ void SubsumptionChecker::AddUniqueClauseToFormula(Formula &F, Clause C) {
F.push_back(C);
}
-std::optional<bool> SubsumptionChecker::Subsumes(const NamedDecl *DP,
- ArrayRef<const Expr *> P,
- const NamedDecl *DQ,
- ArrayRef<const Expr *> Q) {
+std::optional<bool> SubsumptionChecker::Subsumes(
+ const NamedDecl *DP, ArrayRef<AssociatedConstraint> P, const NamedDecl *DQ,
+ ArrayRef<AssociatedConstraint> Q) {
const NormalizedConstraint *PNormalized =
getNormalizedAssociatedConstraints(SemaRef, DP, P);
if (!PNormalized)
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 5527ed5419fc8..ed3c8ed4194ae 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -19130,8 +19130,11 @@ static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record,
AnotherMethodIsMoreConstrained = true;
break;
}
- if (S.IsAtLeastAsConstrained(OtherMethod, {OtherConstraints}, OrigMethod,
- {Constraints},
+ AssociatedConstraint Other(OtherConstraints,
+ /*ArgumentPackSubstitutionIndex=*/-1);
+ AssociatedConstraint Orig(Constraints,
+ /*ArgumentPackSubstitutionIndex=*/-1);
+ if (S.IsAtLeastAsConstrained(OtherMethod, {Other}, OrigMethod, {Orig},
AnotherMethodIsMoreConstrained)) {
// There was an error with the constraints comparison. Exit the loop
// and don't consider this function eligible.
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 46895db4a0756..8c0dd6ea749c0 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -9552,8 +9552,11 @@ concepts::NestedRequirement *
Sema::BuildNestedRequirement(Expr *Constraint) {
ConstraintSatisfaction Satisfaction;
if (!Constraint->isInstantiationDependent() &&
- CheckConstraintSatisfaction(nullptr, {Constraint}, /*TemplateArgs=*/{},
- Constraint->getSourceRange(), Satisfaction))
+ CheckConstraintSatisfaction(
+ nullptr,
+ AssociatedConstraint(Constraint,
+ /*ArgumentPackSubstitutionIndex=*/-1),
+ /*TemplateArgs=*/{}, Constraint->getSourceRange(), Satisfaction))
return nullptr;
return new (Context) concepts::NestedRequirement(Context, Constraint,
Satisfaction);
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 6d8006b35dcf4..1802f8f4e1f91 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -11280,12 +11280,12 @@ MaybeDiagnoseAmbiguousConstraints(Sema &S, ArrayRef<OverloadCandidate> Cands) {
// source-level construct. This behavior is quite confusing and we should try
// to help the user figure out what happened.
- SmallVector<const Expr *, 3> FirstAC, SecondAC;
+ SmallVector<AssociatedConstraint, 3> FirstAC, SecondAC;
FunctionDecl *FirstCand = nullptr, *SecondCand = nullptr;
for (auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
if (!I->Function)
continue;
- SmallVector<const Expr *, 3> AC;
+ SmallVector<AssociatedConstraint, 3> AC;
if (auto *Template = I->Function->getPrimaryTemplate())
Template->getAssociatedConstraints(AC);
else
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 3c83721a481b7..1211b9e708758 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -1221,7 +1221,8 @@ bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
/*NamedConcept=*/NamedConcept,
/*ArgsWritten=*/ArgsAsWritten);
ConstrainedParameter->setTypeConstraint(CL,
- ImmediatelyDeclaredConstraint.get());
+ ImmediatelyDeclaredConstraint.get(),
+ /*ArgumentPackSubstitutionIndex=*/-1);
return false;
}
@@ -4060,7 +4061,7 @@ static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
}
S.NoteTemplateLocation(*Template);
- SmallVector<const Expr *, 3> PartialAC, TemplateAC;
+ SmallVector<AssociatedConstraint, 3> PartialAC, TemplateAC;
Template->getAssociatedConstraints(TemplateAC);
Partial->getAssociatedConstraints(PartialAC);
S.MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Partial, PartialAC, Template,
@@ -4602,7 +4603,10 @@ Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
if (!AreArgsDependent &&
CheckConstraintSatisfaction(
- NamedConcept, {NamedConcept->getConstraintExpr()}, MLTAL,
+ NamedConcept,
+ AssociatedConstraint(NamedConcept->getConstraintExpr(),
+ /*ArgumentPackSubstitutionIndex=*/-1),
+ MLTAL,
SourceRange(SS.isSet() ? SS.getBeginLoc() : ConceptNameInfo.getLoc(),
TemplateArgs->getRAngleLoc()),
Satisfaction))
@@ -7429,7 +7433,7 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
// C++20[temp.func.order]p2
// [...] If both deductions succeed, the partial ordering selects the
// more constrained template (if one exists) as determined below.
- SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
+ SmallVector<AssociatedConstraint, 3> ParamsAC, TemplateAC;
Params->getAssociatedConstraints(ParamsAC);
// C++20[temp.arg.template]p3
// [...] In this comparison, if P is unconstrained, the constraints on A
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 740a7a1513975..6398778dcb77f 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3255,7 +3255,7 @@ CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
ArrayRef<TemplateArgument> SugaredDeducedArgs,
ArrayRef<TemplateArgument> CanonicalDeducedArgs,
TemplateDeductionInfo &Info) {
- llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
+ llvm::SmallVector<AssociatedConstraint, 3> AssociatedConstraints;
Template->getAssociatedConstraints(AssociatedConstraints);
std::optional<ArrayRef<TemplateArgument>> Innermost;
@@ -5245,9 +5245,11 @@ static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
ImplicitConceptSpecializationDecl::Create(
S.getASTContext(), Concept->getDeclContext(), Concept->getLocation(),
CTAI.CanonicalConverted));
- if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()},
- MLTAL, TypeLoc.getLocalSourceRange(),
- Satisfaction))
+ if (S.CheckConstraintSatisfaction(
+ Concept,
+ AssociatedConstraint(Concept->getConstraintExpr(),
+ /*ArgumentPackSubstitutionIndex=*/-1),
+ MLTAL, TypeLoc.getLocalSourceRange(), Satisfaction))
return true;
if (!Satisfaction.IsSatisfied) {
std::string Buf;
@@ -6121,7 +6123,7 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
!Context.hasSameType(FD1->getReturnType(), FD2->getReturnType()))
return nullptr;
- llvm::SmallVector<const Expr *, 3> AC1, AC2;
+ llvm::SmallVector<AssociatedConstraint, 3> AC1, AC2;
FT1->getAssociatedConstraints(AC1);
FT2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
@@ -6226,7 +6228,7 @@ FunctionDecl *Sema::getMoreConstrainedFunction(FunctionDecl *FD1,
if (FunctionDecl *P = FD2->getTemplateInstantiationPattern(false))
F2 = P;
- llvm::SmallVector<const Expr *, 1> AC1, AC2;
+ llvm::SmallVector<AssociatedConstraint, 1> AC1, AC2;
F1->getAssociatedConstraints(AC1);
F2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
@@ -6458,7 +6460,7 @@ getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1,
if (!TemplateArgumentListAreEqual(S.getASTContext())(P1, P2))
return nullptr;
- llvm::SmallVector<const Expr *, 3> AC1, AC2;
+ llvm::SmallVector<AssociatedConstraint, 3> AC1, AC2;
P1->getAssociatedConstraints(AC1);
P2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index ec9a2fb1e9542..9f5ca9dca8e89 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -2876,8 +2876,11 @@ TemplateInstantiator::TransformNestedRequirement(
return nullptr;
llvm::SmallVector<Expr *> Result;
if (!SemaRef.CheckConstraintSatisfaction(
- nullptr, {Req->getConstraintExpr()}, Result, TemplateArgs,
- Req->getConstraintExpr()->getSourceRange(), Satisfaction) &&
+ nullptr,
+ AssociatedConstraint(Req->getConstraintExpr(),
+ SemaRef.ArgumentPackSubstitutionIndex),
+ Result, TemplateArgs, Req->getConstraintExpr()->getSourceRange(),
+ Satisfaction) &&
!Result.empty())
TransConstraint = Result[0];
assert(!Trap.hasErrorOccurred() && "Substitution failures must be handled "
@@ -3159,9 +3162,12 @@ bool Sema::SubstTypeConstraint(
TC->getTemplateArgsAsWritten();
if (!EvaluateConstraints) {
- Inst->setTypeConstraint(TC->getConceptReference(),
- TC->getImmediatelyDeclaredConstraint());
- return false;
+ auto Index = TC->getArgumentPackSubstitutionIndex();
+ if (Index == -1)
+ Index = SemaRef.ArgumentPackSubstitutionIndex;
+ Inst->setTypeConstraint(TC->getConceptReference(),
+ TC->getImmediatelyDeclaredConstraint(), Index);
+ return false;
}
TemplateArgumentListInfo InstArgs;
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index c3341e00bacef..77daeaee5dd1f 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -2706,8 +2706,10 @@ void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
if (Record.readBool())
CR = Record.readConceptReference();
Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
+ int ArgumentPackSubstitutionIndex = Record.readInt();
- D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint);
+ D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint,
+ ArgumentPackSubstitutionIndex);
if ((D->ExpandedParameterPack = Record.readInt()))
D->NumExpanded = Record.readInt();
}
diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp
index a14b8cf201bba..8689868eecc2b 100644
--- a/clang/lib/Serialization/ASTWriterDecl.cpp
+++ b/clang/lib/Serialization/ASTWriterDecl.cpp
@@ -2036,6 +2036,7 @@ void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
if (CR)
Record.AddConceptReference(CR);
Record.AddStmt(TC->getImmediatelyDeclaredConstraint());
+ Record.push_back(TC->getArgumentPackSubstitutionIndex());
Record.push_back(D->isExpandedParameterPack());
if (D->isExpandedParameterPack())
Record.push_back(D->getNumExpansionParameters());
diff --git a/clang/test/SemaCXX/fold_lambda_with_variadics.cpp b/clang/test/SemaCXX/fold_lambda_with_variadics.cpp
index 69572bea3664a..106da7d0e2663 100644
--- a/clang/test/SemaCXX/fold_lambda_with_variadics.cpp
+++ b/clang/test/SemaCXX/fold_lambda_with_variadics.cpp
@@ -238,4 +238,51 @@ static_assert(bar<int, float>()(123));
// expected-note@#C {{evaluated to false}}
// expected-note@#same_as 2{{evaluated to false}}
+template <class T, auto U>
+concept same_as_v = __is_same(T, decltype(U)); // #same_as_v
+
+template <auto... Vs> constexpr auto baz() {
+ return Overloaded{[](same_as_v<Vs> auto value) { return value; }...}; // #baz
+}
+
+static_assert(baz<1, 1.>()(123) == 123);
+static_assert(baz<1, 1.>()(2.718) == 2.718);
+
+static_assert(baz<1, 1.>()('c'));
+// expected-error at -1 {{no matching function}}
+
+// expected-note@#baz {{constraints not satisfied}}
+// expected-note@#baz {{'same_as_v<char, 1>' evaluated to false}}
+// expected-note@#same_as_v {{evaluated to false}}
+
+// expected-note@#baz {{constraints not satisfied}}
+// expected-note@#baz {{'same_as_v<char, 1.>' evaluated to false}}
+// expected-note@#same_as_v {{evaluated to false}}
+
+template <auto... Ts> constexpr auto bazz() {
+ return Overloaded{[](same_as_v<Ts> auto value) { return Ts; }...}; // #bazz
+}
+
+static_assert(bazz<1, 2>()(1));
+// expected-error at -1 {{is ambiguous}}
+// expected-note@#bazz 2{{candidate function [with value:auto = int]}}
+
} // namespace GH101754
+
+namespace GH131798 {
+ template <class T0>
+ struct tuple { T0 elem0; };
+
+ template <class, class>
+ concept C = true;
+
+ template <int>
+ struct Foo {};
+
+ template <int... Vals>
+ constexpr tuple fs{[] (C<Foo<Vals>> auto) {}...};
+
+ int main() {
+ fs<0>.elem0(1);
+ }
+} // namspace GH131798
diff --git a/clang/unittests/AST/SourceLocationTest.cpp b/clang/unittests/AST/SourceLocationTest.cpp
index daea2d62fe496..5b461d1cf4400 100644
--- a/clang/unittests/AST/SourceLocationTest.cpp
+++ b/clang/unittests/AST/SourceLocationTest.cpp
@@ -1094,11 +1094,11 @@ class ConceptSpecializationExprConceptReferenceRangeVerifier
protected:
SourceRange getRange(const VarTemplateDecl &Node) override {
assert(Node.hasAssociatedConstraints());
- SmallVector<const Expr *, 3> ACs;
+ SmallVector<AssociatedConstraint, 3> ACs;
Node.getAssociatedConstraints(ACs);
- for (const Expr *Constraint : ACs) {
+ for (const AssociatedConstraint &AC : ACs) {
if (const ConceptSpecializationExpr *CSConstraint =
- dyn_cast<ConceptSpecializationExpr>(Constraint)) {
+ dyn_cast<ConceptSpecializationExpr>(AC.ConstraintExpr)) {
return CSConstraint->getConceptReference()->getSourceRange();
}
}
>From 2d4717492599f445975019339024e2d1bc02128f Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sat, 22 Mar 2025 16:03:04 -0300
Subject: [PATCH 4/9] [clang] Track final substitution for
SubstTemplateTemplateParm nodes
---
clang/include/clang/AST/ASTContext.h | 9 +++++----
clang/include/clang/AST/PropertiesBase.td | 3 ++-
clang/include/clang/AST/TemplateName.h | 17 ++++++++++++-----
clang/include/clang/AST/Type.h | 3 ++-
clang/lib/AST/ASTContext.cpp | 6 +++---
clang/lib/AST/ASTImporter.cpp | 2 +-
clang/lib/AST/TemplateName.cpp | 6 ++++--
clang/lib/AST/TextNodeDumper.cpp | 2 ++
clang/lib/Sema/SemaTemplateInstantiate.cpp | 8 ++------
9 files changed, 33 insertions(+), 23 deletions(-)
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 1f7c75559e1e9..14a097189ca86 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -2396,10 +2396,11 @@ class ASTContext : public RefCountedBase<ASTContext> {
const IdentifierInfo *Name) const;
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
OverloadedOperatorKind Operator) const;
- TemplateName
- getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl,
- unsigned Index,
- std::optional<unsigned> PackIndex) const;
+ TemplateName getSubstTemplateTemplateParm(TemplateName replacement,
+ Decl *AssociatedDecl,
+ unsigned Index,
+ std::optional<unsigned> PackIndex,
+ bool Final) const;
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
Decl *AssociatedDecl,
unsigned Index,
diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td
index 5f3a885832e2e..416914db2f7c8 100644
--- a/clang/include/clang/AST/PropertiesBase.td
+++ b/clang/include/clang/AST/PropertiesBase.td
@@ -729,8 +729,9 @@ let Class = PropertyTypeCase<TemplateName, "SubstTemplateTemplateParm"> in {
def : Property<"packIndex", Optional<UInt32>> {
let Read = [{ parm->getPackIndex() }];
}
+ def : Property<"final", Bool> { let Read = [{ parm->getFinal() }]; }
def : Creator<[{
- return ctx.getSubstTemplateTemplateParm(replacement, associatedDecl, index, packIndex);
+ return ctx.getSubstTemplateTemplateParm(replacement, associatedDecl, index, packIndex, final);
}]>;
}
let Class = PropertyTypeCase<TemplateName, "SubstTemplateTemplateParmPack"> in {
diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h
index ce97f834bfc1d..313802502f818 100644
--- a/clang/include/clang/AST/TemplateName.h
+++ b/clang/include/clang/AST/TemplateName.h
@@ -413,9 +413,11 @@ class SubstTemplateTemplateParmStorage
SubstTemplateTemplateParmStorage(TemplateName Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex)
+ std::optional<unsigned> PackIndex,
+ bool Final)
: UncommonTemplateNameStorage(SubstTemplateTemplateParm, Index,
- PackIndex ? *PackIndex + 1 : 0),
+ ((PackIndex ? *PackIndex + 1 : 0) << 1) |
+ Final),
Replacement(Replacement), AssociatedDecl(AssociatedDecl) {
assert(AssociatedDecl != nullptr);
}
@@ -429,10 +431,15 @@ class SubstTemplateTemplateParmStorage
/// This should match the result of `getParameter()->getIndex()`.
unsigned getIndex() const { return Bits.Index; }
+ // This substitution is Final, which means the substitution is fully
+ // sugared: it doesn't need to be resugared later.
+ bool getFinal() const { return Bits.Data & 1; }
+
std::optional<unsigned> getPackIndex() const {
- if (Bits.Data == 0)
+ auto Data = Bits.Data >> 1;
+ if (Data == 0)
return std::nullopt;
- return Bits.Data - 1;
+ return Data - 1;
}
TemplateTemplateParmDecl *getParameter() const;
@@ -442,7 +449,7 @@ class SubstTemplateTemplateParmStorage
static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex);
+ std::optional<unsigned> PackIndex, bool Final);
};
class DeducedTemplateStorage : public UncommonTemplateNameStorage,
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index c927eb13711c1..e62b9938c9ba1 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -6488,7 +6488,8 @@ class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
/// This should match the result of `getReplacedParameter()->getIndex()`.
unsigned getIndex() const { return SubstTemplateTypeParmPackTypeBits.Index; }
- // When true the substitution will be 'Final' (subst node won't be placed).
+ // This substitution will be Final, which means the substitution will be fully
+ // sugared: it doesn't need to be resugared later.
bool getFinal() const;
unsigned getNumArgs() const {
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 292f29748f555..cd818b3e1300d 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -10130,10 +10130,10 @@ ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
TemplateName ASTContext::getSubstTemplateTemplateParm(
TemplateName Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) const {
+ std::optional<unsigned> PackIndex, bool Final) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmStorage::Profile(ID, Replacement, AssociatedDecl,
- Index, PackIndex);
+ Index, PackIndex, Final);
void *insertPos = nullptr;
SubstTemplateTemplateParmStorage *subst
@@ -10141,7 +10141,7 @@ TemplateName ASTContext::getSubstTemplateTemplateParm(
if (!subst) {
subst = new (*this) SubstTemplateTemplateParmStorage(
- Replacement, AssociatedDecl, Index, PackIndex);
+ Replacement, AssociatedDecl, Index, PackIndex, Final);
SubstTemplateTemplateParms.InsertNode(subst, insertPos);
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index d397c9285ed76..4131220f18348 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -9958,7 +9958,7 @@ Expected<TemplateName> ASTImporter::Import(TemplateName From) {
return ToContext.getSubstTemplateTemplateParm(
*ReplacementOrErr, *AssociatedDeclOrErr, Subst->getIndex(),
- Subst->getPackIndex());
+ Subst->getPackIndex(), Subst->getFinal());
}
case TemplateName::SubstTemplateTemplateParmPack: {
diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp
index 9e0a7dc2b8cdc..109cc3c4771ee 100644
--- a/clang/lib/AST/TemplateName.cpp
+++ b/clang/lib/AST/TemplateName.cpp
@@ -77,16 +77,18 @@ SubstTemplateTemplateParmStorage::getParameter() const {
}
void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
- Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex());
+ Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex(),
+ getFinal());
}
void SubstTemplateTemplateParmStorage::Profile(
llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
- unsigned Index, std::optional<unsigned> PackIndex) {
+ unsigned Index, std::optional<unsigned> PackIndex, bool Final) {
Replacement.Profile(ID);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
ID.AddInteger(PackIndex ? *PackIndex + 1 : 0);
+ ID.AddBoolean(Final);
}
SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index f18cf703bdaa6..01d09eb2fd148 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -1302,6 +1302,8 @@ void TextNodeDumper::dumpBareTemplateName(TemplateName TN) {
OS << " index " << STS->getIndex();
if (std::optional<unsigned int> PackIndex = STS->getPackIndex())
OS << " pack_index " << *PackIndex;
+ if (STS->getFinal())
+ OS << " final";
if (const TemplateTemplateParmDecl *P = STS->getParameter())
AddChild("parameter", [=] { Visit(P); });
dumpDeclRef(STS->getAssociatedDecl(), "associated");
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 9f5ca9dca8e89..1a8894ce50532 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -2083,10 +2083,8 @@ TemplateName TemplateInstantiator::TransformTemplateName(
TemplateName Template = Arg.getAsTemplate();
assert(!Template.isNull() && "Null template template argument");
- if (Final)
- return Template;
return getSema().Context.getSubstTemplateTemplateParm(
- Template, AssociatedDecl, TTP->getIndex(), PackIndex);
+ Template, AssociatedDecl, TTP->getIndex(), PackIndex, Final);
}
}
@@ -2098,11 +2096,9 @@ TemplateName TemplateInstantiator::TransformTemplateName(
TemplateArgument Pack = SubstPack->getArgumentPack();
TemplateName Template =
getPackSubstitutedTemplateArgument(getSema(), Pack).getAsTemplate();
- if (SubstPack->getFinal())
- return Template;
return getSema().Context.getSubstTemplateTemplateParm(
Template, SubstPack->getAssociatedDecl(), SubstPack->getIndex(),
- getPackIndex(Pack));
+ getPackIndex(Pack), SubstPack->getFinal());
}
return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
>From 3a7d718e76b164b4748fe1fd846c8b0019aeaeea Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sat, 22 Mar 2025 16:35:39 -0300
Subject: [PATCH 5/9] [clang] Track final substitution for
SubstNonTypeTemplateParmExpr nodes
---
clang/include/clang/AST/ExprCXX.h | 25 ++++++++++++----
clang/lib/AST/ASTImporter.cpp | 3 +-
clang/lib/AST/ExprCXX.cpp | 6 ++--
clang/lib/Sema/SemaTemplate.cpp | 2 +-
clang/lib/Sema/SemaTemplateInstantiate.cpp | 34 ++++++++++------------
5 files changed, 42 insertions(+), 28 deletions(-)
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
index 223d74993e9e6..028ee82718d50 100644
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -4514,7 +4514,9 @@ class SubstNonTypeTemplateParmExpr : public Expr {
llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndRef;
unsigned Index : 15;
- unsigned PackIndex : 16;
+ unsigned PackIndex : 15;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned Final : 1;
explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
: Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
@@ -4523,11 +4525,12 @@ class SubstNonTypeTemplateParmExpr : public Expr {
SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
SourceLocation Loc, Expr *Replacement,
Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex, bool RefParam)
+ std::optional<unsigned> PackIndex, bool RefParam,
+ bool Final)
: Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
Replacement(Replacement),
AssociatedDeclAndRef(AssociatedDecl, RefParam), Index(Index),
- PackIndex(PackIndex ? *PackIndex + 1 : 0) {
+ PackIndex(PackIndex ? *PackIndex + 1 : 0), Final(Final) {
assert(AssociatedDecl != nullptr);
SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
setDependence(computeDependence(this));
@@ -4555,6 +4558,10 @@ class SubstNonTypeTemplateParmExpr : public Expr {
return PackIndex - 1;
}
+ // This substitution is Final, which means the substitution is fully
+ // sugared: it doesn't need to be resugared later.
+ bool getFinal() const { return Final; }
+
NonTypeTemplateParmDecl *getParameter() const;
bool isReferenceParameter() const { return AssociatedDeclAndRef.getInt(); }
@@ -4598,7 +4605,10 @@ class SubstNonTypeTemplateParmPackExpr : public Expr {
const TemplateArgument *Arguments;
/// The number of template arguments in \c Arguments.
- unsigned NumArguments : 16;
+ unsigned NumArguments : 15;
+
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned Final : 1;
unsigned Index : 16;
@@ -4612,7 +4622,8 @@ class SubstNonTypeTemplateParmPackExpr : public Expr {
SubstNonTypeTemplateParmPackExpr(QualType T, ExprValueKind ValueKind,
SourceLocation NameLoc,
const TemplateArgument &ArgPack,
- Decl *AssociatedDecl, unsigned Index);
+ Decl *AssociatedDecl, unsigned Index,
+ bool Final);
/// A template-like entity which owns the whole pattern being substituted.
/// This will own a set of template parameters.
@@ -4622,6 +4633,10 @@ class SubstNonTypeTemplateParmPackExpr : public Expr {
/// This should match the result of `getParameterPack()->getIndex()`.
unsigned getIndex() const { return Index; }
+ // This substitution will be Final, which means the substitution will be fully
+ // sugared: it doesn't need to be resugared later.
+ bool getFinal() const { return Final; }
+
/// Retrieve the non-type template parameter pack being substituted.
NonTypeTemplateParmDecl *getParameterPack() const;
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 4131220f18348..ab19965dd2063 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -8945,7 +8945,8 @@ ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
ToType, E->getValueKind(), ToExprLoc, ToReplacement, ToAssociatedDecl,
- E->getIndex(), E->getPackIndex(), E->isReferenceParameter());
+ E->getIndex(), E->getPackIndex(), E->isReferenceParameter(),
+ E->getFinal());
}
ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
index a000e988e6834..a0bc50c449d82 100644
--- a/clang/lib/AST/ExprCXX.cpp
+++ b/clang/lib/AST/ExprCXX.cpp
@@ -1760,10 +1760,12 @@ QualType SubstNonTypeTemplateParmExpr::getParameterType(
SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
QualType T, ExprValueKind ValueKind, SourceLocation NameLoc,
- const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index)
+ const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
+ bool Final)
: Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary),
AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),
- NumArguments(ArgPack.pack_size()), Index(Index), NameLoc(NameLoc) {
+ NumArguments(ArgPack.pack_size()), Final(Final), Index(Index),
+ NameLoc(NameLoc) {
assert(AssociatedDecl != nullptr);
setDependence(ExprDependence::TypeValueInstantiation |
ExprDependence::UnexpandedPack);
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 1211b9e708758..d82fcdc2dc8dc 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -7569,7 +7569,7 @@ ExprResult Sema::BuildExpressionFromDeclTemplateArgument(
ParamType->getPointeeType(), RefExpr.get()->getValueKind(),
RefExpr.get()->getExprLoc(), RefExpr.get(), VD, NTTP->getIndex(),
/*PackIndex=*/std::nullopt,
- /*RefParam=*/true);
+ /*RefParam=*/true, /*Final=*/true);
}
}
}
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 1a8894ce50532..4b9d97cc7d97a 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1865,11 +1865,10 @@ namespace {
Sema::ExtParameterInfoBuilder &PInfos);
private:
- ExprResult
- transformNonTypeTemplateParmRef(Decl *AssociatedDecl,
- const NonTypeTemplateParmDecl *parm,
- SourceLocation loc, TemplateArgument arg,
- std::optional<unsigned> PackIndex);
+ ExprResult transformNonTypeTemplateParmRef(
+ Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
+ SourceLocation loc, TemplateArgument arg,
+ std::optional<unsigned> PackIndex, bool Final);
};
}
@@ -2140,7 +2139,8 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
return Arg.getAsExpr();
}
- auto [AssociatedDecl, _] = TemplateArgs.getAssociatedDecl(NTTP->getDepth());
+ auto [AssociatedDecl, Final] =
+ TemplateArgs.getAssociatedDecl(NTTP->getDepth());
std::optional<unsigned> PackIndex;
if (NTTP->isParameterPack()) {
assert(Arg.getKind() == TemplateArgument::Pack &&
@@ -2159,17 +2159,15 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
QualType ExprType = TargetType.getNonLValueExprType(SemaRef.Context);
if (TargetType->isRecordType())
ExprType.addConst();
- // FIXME: Pass in Final.
return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
ExprType, TargetType->isReferenceType() ? VK_LValue : VK_PRValue,
- E->getLocation(), Arg, AssociatedDecl, NTTP->getPosition());
+ E->getLocation(), Arg, AssociatedDecl, NTTP->getPosition(), Final);
}
PackIndex = getPackIndex(Arg);
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
}
- // FIXME: Don't put subst node on Final replacement.
return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP, E->getLocation(),
- Arg, PackIndex);
+ Arg, PackIndex, Final);
}
const AnnotateAttr *
@@ -2264,8 +2262,8 @@ TemplateInstantiator::TransformOpenACCRoutineDeclAttr(
ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
- SourceLocation loc, TemplateArgument arg,
- std::optional<unsigned> PackIndex) {
+ SourceLocation loc, TemplateArgument arg, std::optional<unsigned> PackIndex,
+ bool Final) {
ExprResult result;
// Determine the substituted parameter type. We can usually infer this from
@@ -2331,10 +2329,9 @@ ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
return ExprError();
Expr *resultExpr = result.get();
- // FIXME: Don't put subst node on final replacement.
return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
resultExpr->getType(), resultExpr->getValueKind(), loc, resultExpr,
- AssociatedDecl, parm->getIndex(), PackIndex, refParam);
+ AssociatedDecl, parm->getIndex(), PackIndex, refParam, Final);
}
ExprResult
@@ -2347,10 +2344,9 @@ TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
TemplateArgument Pack = E->getArgumentPack();
TemplateArgument Arg = getPackSubstitutedTemplateArgument(getSema(), Pack);
- // FIXME: Don't put subst node on final replacement.
return transformNonTypeTemplateParmRef(
E->getAssociatedDecl(), E->getParameterPack(),
- E->getParameterPackLocation(), Arg, getPackIndex(Pack));
+ E->getParameterPackLocation(), Arg, getPackIndex(Pack), E->getFinal());
}
ExprResult
@@ -2392,9 +2388,9 @@ TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
/*PartialOrderingTTP=*/false, Sema::CTAK_Specified)
.isInvalid())
return true;
- return transformNonTypeTemplateParmRef(E->getAssociatedDecl(),
- E->getParameter(), E->getExprLoc(),
- SugaredConverted, E->getPackIndex());
+ return transformNonTypeTemplateParmRef(
+ E->getAssociatedDecl(), E->getParameter(), E->getExprLoc(),
+ SugaredConverted, E->getPackIndex(), E->getFinal());
}
ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(ValueDecl *PD,
>From bd95f1d7ec7c4f6b686edda0d2b8f64a62fda3bd Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sun, 23 Mar 2025 17:45:40 -0300
Subject: [PATCH 6/9] [clang] Track final substitution for
SubstTemplateTypeParmType nodes
---
clang/include/clang/AST/ASTContext.h | 8 +++----
clang/include/clang/AST/Type.h | 21 ++++++++++--------
clang/include/clang/AST/TypeProperties.td | 4 ++--
clang/lib/AST/ASTContext.cpp | 9 ++++----
clang/lib/AST/ASTImporter.cpp | 4 ++--
clang/lib/AST/TextNodeDumper.cpp | 2 ++
clang/lib/AST/Type.cpp | 22 +++++++++++++++----
clang/lib/Sema/SemaTemplateInstantiate.cpp | 6 +----
clang/lib/Sema/TreeTransform.h | 3 ++-
clang/test/AST/ast-dump-template-decls.cpp | 18 ++++++++++-----
.../test/Misc/diag-template-diffing-cxx11.cpp | 4 ++--
clang/test/SemaTemplate/make_integer_seq.cpp | 8 +++++--
12 files changed, 68 insertions(+), 41 deletions(-)
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 14a097189ca86..2ef8112225767 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1795,10 +1795,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType Wrapped, QualType Contained,
const HLSLAttributedResourceType::Attributes &Attrs);
- QualType
- getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
- unsigned Index,
- std::optional<unsigned> PackIndex) const;
+ QualType getSubstTemplateTypeParmType(QualType Replacement,
+ Decl *AssociatedDecl, unsigned Index,
+ std::optional<unsigned> PackIndex,
+ bool Final) const;
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
unsigned Index, bool Final,
const TemplateArgument &ArgPack);
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index e62b9938c9ba1..d7b4ffd060e69 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -2158,12 +2158,15 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
// The index of the template parameter this substitution represents.
unsigned Index : 15;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned Final : 1;
+
/// Represents the index within a pack if this represents a substitution
/// from a pack expansion. This index starts at the end of the pack and
/// increments towards the beginning.
/// Positive non-zero number represents the index + 1.
/// Zero means this is not substituted from an expansion.
- unsigned PackIndex : 16;
+ unsigned PackIndex : 15;
};
class SubstTemplateTypeParmPackTypeBitfields {
@@ -6397,7 +6400,8 @@ class SubstTemplateTypeParmType final
Decl *AssociatedDecl;
SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
- unsigned Index, std::optional<unsigned> PackIndex);
+ unsigned Index, std::optional<unsigned> PackIndex,
+ bool Final);
public:
/// Gets the type that was substituted for the template
@@ -6420,6 +6424,10 @@ class SubstTemplateTypeParmType final
/// This should match the result of `getReplacedParameter()->getIndex()`.
unsigned getIndex() const { return SubstTemplateTypeParmTypeBits.Index; }
+ // This substitution is Final, which means the substitution is fully
+ // sugared: it doesn't need to be resugared later.
+ unsigned getFinal() const { return SubstTemplateTypeParmTypeBits.Final; }
+
std::optional<unsigned> getPackIndex() const {
if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
return std::nullopt;
@@ -6431,17 +6439,12 @@ class SubstTemplateTypeParmType final
void Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getReplacementType(), getAssociatedDecl(), getIndex(),
- getPackIndex());
+ getPackIndex(), getFinal());
}
static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
const Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) {
- Replacement.Profile(ID);
- ID.AddPointer(AssociatedDecl);
- ID.AddInteger(Index);
- ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
- }
+ std::optional<unsigned> PackIndex, bool Final);
static bool classof(const Type *T) {
return T->getTypeClass() == SubstTemplateTypeParm;
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index 4d89d8a47396a..93f391e99c5ab 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -827,11 +827,11 @@ let Class = SubstTemplateTypeParmType in {
def : Property<"PackIndex", Optional<UInt32>> {
let Read = [{ node->getPackIndex() }];
}
+ def : Property<"Final", Bool> { let Read = [{ node->getFinal() }]; }
- // The call to getCanonicalType here existed in ASTReader.cpp, too.
def : Creator<[{
return ctx.getSubstTemplateTypeParmType(
- replacementType, associatedDecl, Index, PackIndex);
+ replacementType, associatedDecl, Index, PackIndex, Final);
}]>;
}
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index cd818b3e1300d..e088e2ea45cc7 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -5449,10 +5449,10 @@ QualType ASTContext::getHLSLAttributedResourceType(
/// Retrieve a substitution-result type.
QualType ASTContext::getSubstTemplateTypeParmType(
QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex) const {
+ std::optional<unsigned> PackIndex, bool Final) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index,
- PackIndex);
+ PackIndex, Final);
void *InsertPos = nullptr;
SubstTemplateTypeParmType *SubstParm =
SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
@@ -5462,7 +5462,7 @@ QualType ASTContext::getSubstTemplateTypeParmType(
!Replacement.isCanonical()),
alignof(SubstTemplateTypeParmType));
SubstParm = new (Mem) SubstTemplateTypeParmType(Replacement, AssociatedDecl,
- Index, PackIndex);
+ Index, PackIndex, Final);
Types.push_back(SubstParm);
SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
}
@@ -14246,7 +14246,8 @@ static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X,
if (PackIndex != SY->getPackIndex())
return QualType();
return Ctx.getSubstTemplateTypeParmType(Ctx.getQualifiedType(Underlying),
- CD, Index, PackIndex);
+ CD, Index, PackIndex,
+ SX->getFinal() && SY->getFinal());
}
case Type::ObjCTypeParam:
// FIXME: Try to merge these.
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index ab19965dd2063..4e27f9d884a83 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1631,8 +1631,8 @@ ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
return ToReplacementTypeOrErr.takeError();
return Importer.getToContext().getSubstTemplateTypeParmType(
- *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(),
- T->getPackIndex());
+ *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(), T->getPackIndex(),
+ T->getFinal());
}
ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 01d09eb2fd148..02373e8072536 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -2130,6 +2130,8 @@ void TextNodeDumper::VisitSubstTemplateTypeParmType(
VisitTemplateTypeParmDecl(T->getReplacedParameter());
if (auto PackIndex = T->getPackIndex())
OS << " pack_index " << *PackIndex;
+ if (T->getFinal())
+ OS << " final";
}
void TextNodeDumper::VisitSubstTemplateTypeParmPackType(
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 478c0b5f779b7..c47096839e101 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -1294,9 +1294,9 @@ struct SimpleTransformVisitor : public TypeVisitor<Derived, QualType> {
== T->getReplacementType().getAsOpaquePtr())
return QualType(T, 0);
- return Ctx.getSubstTemplateTypeParmType(replacementType,
- T->getAssociatedDecl(),
- T->getIndex(), T->getPackIndex());
+ return Ctx.getSubstTemplateTypeParmType(
+ replacementType, T->getAssociatedDecl(), T->getIndex(),
+ T->getPackIndex(), T->getFinal());
}
// FIXME: Non-trivial to implement, but important for C++
@@ -4270,7 +4270,7 @@ static const TemplateTypeParmDecl *getReplacedParameter(Decl *D,
SubstTemplateTypeParmType::SubstTemplateTypeParmType(
QualType Replacement, Decl *AssociatedDecl, unsigned Index,
- std::optional<unsigned> PackIndex)
+ std::optional<unsigned> PackIndex, bool Final)
: Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
Replacement->getDependence()),
AssociatedDecl(AssociatedDecl) {
@@ -4280,6 +4280,7 @@ SubstTemplateTypeParmType::SubstTemplateTypeParmType(
*getTrailingObjects<QualType>() = Replacement;
SubstTemplateTypeParmTypeBits.Index = Index;
+ SubstTemplateTypeParmTypeBits.Final = Final;
SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0;
assert(AssociatedDecl != nullptr);
}
@@ -4289,6 +4290,19 @@ SubstTemplateTypeParmType::getReplacedParameter() const {
return ::getReplacedParameter(getAssociatedDecl(), getIndex());
}
+void SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID,
+ QualType Replacement,
+ const Decl *AssociatedDecl,
+ unsigned Index,
+ std::optional<unsigned> PackIndex,
+ bool Final) {
+ Replacement.Profile(ID);
+ ID.AddPointer(AssociatedDecl);
+ ID.AddInteger(Index);
+ ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
+ ID.AddBoolean(Final);
+}
+
SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
QualType Canon, Decl *AssociatedDecl, unsigned Index, bool Final,
const TemplateArgument &ArgPack)
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 4b9d97cc7d97a..d835b3b06893d 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -2546,13 +2546,9 @@ QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), RQs);
}
- if (Final) {
- TLB.pushTrivial(SemaRef.Context, Replacement, NameLoc);
- return Replacement;
- }
// TODO: only do this uniquing once, at the start of instantiation.
QualType Result = getSema().Context.getSubstTemplateTypeParmType(
- Replacement, AssociatedDecl, Index, PackIndex);
+ Replacement, AssociatedDecl, Index, PackIndex, Final);
SubstTemplateTypeParmTypeLoc NewTL =
TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(NameLoc);
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 8fdb2cf6dce6c..7b29f06373d32 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -7082,7 +7082,8 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
return QualType();
QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
- Replacement, NewReplaced, T->getIndex(), T->getPackIndex());
+ Replacement, NewReplaced, T->getIndex(), T->getPackIndex(),
+ T->getFinal());
// Propagate type-source information.
SubstTemplateTypeParmTypeLoc NewTL
diff --git a/clang/test/AST/ast-dump-template-decls.cpp b/clang/test/AST/ast-dump-template-decls.cpp
index 9f578e5afe561..d5228d4667304 100644
--- a/clang/test/AST/ast-dump-template-decls.cpp
+++ b/clang/test/AST/ast-dump-template-decls.cpp
@@ -123,6 +123,8 @@ using type2 = typename C<int>::type1<void>;
// CHECK-NEXT: TemplateArgument type 'void'
// CHECK-NEXT: BuiltinType 0x{{[^ ]*}} 'void'
// CHECK-NEXT: FunctionProtoType 0x{{[^ ]*}} 'void (int)' cdecl
+// CHECK-NEXT: SubstTemplateTypeParmType 0x{{[^ ]*}} 'void' sugar class depth 0 index 0 U final
+// CHECK-NEXT: TypeAliasTemplate 0x{{[^ ]*}} 'type1'
// CHECK-NEXT: BuiltinType 0x{{[^ ]*}} 'void'
// CHECK-NEXT: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar class depth 0 index 0 T
// CHECK-NEXT: ClassTemplateSpecialization 0x{{[^ ]*}} 'C'
@@ -139,14 +141,14 @@ template struct D<float, char>::bind<int, short>;
// CHECK: TypeAliasDecl 0x{{[^ ]*}} <line:{{[1-9]+}}:5, col:45> col:11 bound_type 'int (int (*)(float, int), int (*)(char, short))'
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (int (*)(float, int), int (*)(char, short))' cdecl
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (float, int)' cdecl
-// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar typename depth 0 index 0 ... T pack_index 1
+// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar typename depth 0 index 0 ... T pack_index 1{{$}}
// CHECK-NEXT: ClassTemplateSpecialization 0x{{[^ ]*}} 'D'
-// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar typename depth 0 index 0 ... U pack_index 1
+// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar typename depth 0 index 0 ... U pack_index 1{{$}}
// CHECK-NEXT: ClassTemplateSpecialization 0x{{[^ ]*}} 'bind'
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (char, short)' cdecl
-// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar typename depth 0 index 0 ... T pack_index 0
+// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar typename depth 0 index 0 ... T pack_index 0{{$}}
// CHECK-NEXT: ClassTemplateSpecialization 0x{{[^ ]*}} 'D'
-// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar typename depth 0 index 0 ... U pack_index 0
+// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar typename depth 0 index 0 ... U pack_index 0{{$}}
// CHECK-NEXT: ClassTemplateSpecialization 0x{{[^ ]*}} 'bind'
} // namespace PR56099
@@ -156,12 +158,16 @@ template<template<class C1, class C2 = A<C1>> class D1, class D2> using D = D1<D
template<class E1, class E2> class E {};
using test1 = D<E, int>;
-// CHECK: TypeAliasDecl 0x{{[^ ]*}} <line:{{[1-9]+}}:1, col:23> col:7 test1 'D<E, int>':'subst_default_argument::E<int, subst_default_argument::A<int>>'
+// CHECK: TypeAliasDecl 0x{{[^ ]*}} <line:{{[0-9]+}}:1, col:23> col:7 test1 'D<E, int>':'subst_default_argument::E<int, subst_default_argument::A<int>>'
// CHECK: TemplateSpecializationType 0x{{[^ ]*}} 'A<int>' sugar
// CHECK-NEXT: |-name: 'A':'subst_default_argument::A' qualified
// CHECK-NEXT: | `-ClassTemplateDecl {{.+}} A
// CHECK-NEXT: |-TemplateArgument type 'int'
-// CHECK-NEXT: | `-BuiltinType 0x{{[^ ]*}} 'int'
+// CHECK-NEXT: | `-SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar class depth 0 index 0 E1 final
+// CHECK-NEXT: | |-ClassTemplate 0x{{[^ ]*}} 'E'
+// CHECK-NEXT: | `-SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar class depth 0 index 1 D2 final
+// CHECK-NEXT: | |-TypeAliasTemplate 0x{{[^ ]*}} 'D'
+// CHECK-NEXT: | `-BuiltinType 0x{{[^ ]*}} 'int'
// CHECK-NEXT: `-RecordType 0x{{[^ ]*}} 'subst_default_argument::A<int>'
// CHECK-NEXT: `-ClassTemplateSpecialization 0x{{[^ ]*}} 'A'
} // namespace subst_default_argument
diff --git a/clang/test/Misc/diag-template-diffing-cxx11.cpp b/clang/test/Misc/diag-template-diffing-cxx11.cpp
index ae4fa524e4e44..c62bffe2b458d 100644
--- a/clang/test/Misc/diag-template-diffing-cxx11.cpp
+++ b/clang/test/Misc/diag-template-diffing-cxx11.cpp
@@ -265,14 +265,14 @@ int k9 = f9(V9<double>());
// CHECK-ELIDE-TREE: S9<
// CHECK-ELIDE-TREE: [2 * ...],
// CHECK-ELIDE-TREE: U9<
-// CHECK-ELIDE-TREE: [(no qualifiers) != const] double>>
+// CHECK-ELIDE-TREE: [double != const double]>>
// CHECK-NOELIDE-TREE: no matching function for call to 'f9'
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: S9<
// CHECK-NOELIDE-TREE: int,
// CHECK-NOELIDE-TREE: char,
// CHECK-NOELIDE-TREE: U9<
-// CHECK-NOELIDE-TREE: [(no qualifiers) != const] double>>
+// CHECK-NOELIDE-TREE: [double != const double]>>
template<typename ...A> class class_types {};
void set10(class_types<int, int>) {}
diff --git a/clang/test/SemaTemplate/make_integer_seq.cpp b/clang/test/SemaTemplate/make_integer_seq.cpp
index 71e34c5e0e7df..7ca7b55b49964 100644
--- a/clang/test/SemaTemplate/make_integer_seq.cpp
+++ b/clang/test/SemaTemplate/make_integer_seq.cpp
@@ -48,7 +48,9 @@ using test2 = B<int, 1>;
// CHECK-NEXT: |-TemplateArgument template 'A'
// CHECK-NEXT: | `-ClassTemplateDecl 0x{{[0-9A-Fa-f]+}} <line:{{.+}}:1, col:41> col:38 A
// CHECK-NEXT: |-TemplateArgument type 'int'
-// CHECK-NEXT: | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
+// CHECK-NEXT: | `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar class depth 0 index 0 B1 final
+// CHECK-NEXT: | |-TypeAliasTemplate 0x{{[0-9A-Fa-f]+}} 'B'
+// CHECK-NEXT: | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
// CHECK-NEXT: |-TemplateArgument expr '1'
// CHECK-NEXT: | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <line:{{.+}}:64> 'int'
// CHECK-NEXT: | |-value: Int 1
@@ -59,7 +61,9 @@ using test2 = B<int, 1>;
// CHECK-NEXT: |-name: 'A' qualified
// CHECK-NEXT: | `-ClassTemplateDecl {{.+}} A
// CHECK-NEXT: |-TemplateArgument type 'int'
-// CHECK-NEXT: | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
+// CHECK-NEXT: | `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar class depth 0 index 0 B1 final
+// CHECK-NEXT: | |-TypeAliasTemplate 0x{{[0-9A-Fa-f]+}} 'B'
+// CHECK-NEXT: | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
// CHECK-NEXT: |-TemplateArgument expr '0'
// CHECK-NEXT: | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <line:{{.+}}:64> 'int'
// CHECK-NEXT: | |-value: Int 0
>From 7db83f29fb46bd90918e35096ca95076abedae0f Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sun, 23 Mar 2025 17:51:59 -0300
Subject: [PATCH 7/9] Revert "[clang] Add frontend flag to enable support for
broken external resugarers (#103219)"
This reverts commit 661dda9df13c65ce021407bb726b558c7a414731.
---
clang/include/clang/Basic/LangOptions.def | 1 -
clang/include/clang/Driver/Options.td | 6 ------
clang/lib/Sema/SemaTemplate.cpp | 12 +++---------
...subst-template-type-parm-type-ast-nodes.cpp | 18 ------------------
4 files changed, 3 insertions(+), 34 deletions(-)
delete mode 100644 clang/test/AST/ast-dump-retain-subst-template-type-parm-type-ast-nodes.cpp
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
index 3879cc7942877..930c1c06d1a76 100644
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -161,7 +161,6 @@ LANGOPT(Coroutines , 1, 0, "C++20 coroutines")
LANGOPT(CoroAlignedAllocation, 1, 0, "prefer Aligned Allocation according to P2014 Option 2")
LANGOPT(DllExportInlines , 1, 1, "dllexported classes dllexport inline methods")
LANGOPT(ExperimentalLibrary, 1, 0, "enable unstable and experimental library features")
-LANGOPT(RetainSubstTemplateTypeParmTypeAstNodes, 1, 0, "retain SubstTemplateTypeParmType nodes in the AST's representation of alias template specializations")
LANGOPT(PointerAuthIntrinsics, 1, 0, "pointer authentication intrinsics")
LANGOPT(PointerAuthCalls , 1, 0, "function pointer authentication")
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 3af072242d039..e278940f189a9 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -3508,12 +3508,6 @@ defm application_extension : BoolFOption<"application-extension",
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Restrict code to those available for App Extensions">,
NegFlag<SetFalse>>;
-defm retain_subst_template_type_parm_type_ast_nodes : BoolFOption<"retain-subst-template-type-parm-type-ast-nodes",
- LangOpts<"RetainSubstTemplateTypeParmTypeAstNodes">, DefaultFalse,
- PosFlag<SetTrue, [], [CC1Option], "Enable">,
- NegFlag<SetFalse, [], [], "Disable">,
- BothFlags<[], [], " retain SubstTemplateTypeParmType nodes in the AST's representation"
- " of alias template specializations">>;
defm sized_deallocation : BoolFOption<"sized-deallocation",
LangOpts<"SizedDeallocation">, Default<cpp14.KeyPath>,
PosFlag<SetTrue, [], [], "Enable C++14 sized global deallocation functions">,
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index d82fcdc2dc8dc..3928d93a9abf7 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -3529,16 +3529,10 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
if (Pattern->isInvalidDecl())
return QualType();
- // Only substitute for the innermost template argument list. NOTE: Some
- // external resugarers rely on leaving a Subst* node here. Make the
- // substitution non-final in that case. Note that these external resugarers
- // will still miss some information in this representation, because we don't
- // provide enough context in the Subst* nodes in order to tell different
- // template type alias specializations apart.
+ // Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
- TemplateArgLists.addOuterTemplateArguments(
- Template, CTAI.SugaredConverted,
- /*Final=*/!getLangOpts().RetainSubstTemplateTypeParmTypeAstNodes);
+ TemplateArgLists.addOuterTemplateArguments(Template, CTAI.SugaredConverted,
+ /*Final=*/true);
TemplateArgLists.addOuterRetainedLevels(
AliasTemplate->getTemplateParameters()->getDepth());
diff --git a/clang/test/AST/ast-dump-retain-subst-template-type-parm-type-ast-nodes.cpp b/clang/test/AST/ast-dump-retain-subst-template-type-parm-type-ast-nodes.cpp
deleted file mode 100644
index 97dc983e2436c..0000000000000
--- a/clang/test/AST/ast-dump-retain-subst-template-type-parm-type-ast-nodes.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// RUN: %clang_cc1 -fsyntax-only -fretain-subst-template-type-parm-type-ast-nodes -ast-dump -ast-dump-filter=dump %s | FileCheck -strict-whitespace %s
-
-namespace t1 {
-template<class T> using X = T;
-using dump = X<int>;
-
-// CHECK-LABEL: Dumping t1::dump:
-// CHECK-NEXT: TypeAliasDecl
-// CHECK-NEXT: `-ElaboratedType
-// CHECK-NEXT: `-TemplateSpecializationType
-// CHECK-NEXT: |-name: 'X':'t1::X' qualified
-// CHECK-NEXT: | `-TypeAliasTemplateDecl
-// CHECK-NEXT: |-TemplateArgument
-// CHECK-NEXT: | `-BuiltinType {{.+}} 'int'
-// CHECK-NEXT: `-SubstTemplateTypeParmType 0x{{[0-9a-f]+}} 'int' sugar class depth 0 index 0 T
-// CHECK-NEXT: |-TypeAliasTemplate {{.+}} 'X'
-// CHECK-NEXT: `-BuiltinType {{.+}} 'int'
-} // namespace t1
>From bade8925f7579c78df8336004489d5b1ed6f445f Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Thu, 27 Mar 2025 22:21:32 -0300
Subject: [PATCH 8/9] [clang] improved preservation of template keyword
This makes it so clang can better represent the abscence of
the template keyword for a template which cannot be resolved
due to a dependent prefix.
The tracking of the template keyword is removed from the
NestedNameSpecifier, and added to the last type node which had
it missing, the DependentTemplateSpecializationType (DTST).
The DTST and the DependentTemplateName are refactored to share
most of their implementation.
That refactoring along with the removal of the TypeSpecWithTemplate kind
from the nested name specifiers amounts to a large amount of code
removed, making this patch a small performance improvement overall.
This will also enable future further simplifications.
As a drive-by, this removes some special cases from the type printer,
allowing template arguments within NestedNameSpecifiers to not have
their nested names suppressed when printing.
---
clang-tools-extra/clangd/AST.cpp | 3 +-
clang-tools-extra/clangd/CodeComplete.cpp | 1 -
clang-tools-extra/clangd/DumpAST.cpp | 1 -
clang-tools-extra/clangd/FindTarget.cpp | 1 -
.../include-cleaner/lib/WalkAST.cpp | 1 -
clang/docs/ReleaseNotes.rst | 4 +
clang/include/clang/AST/ASTContext.h | 20 +-
clang/include/clang/AST/ASTImporter.h | 8 +
clang/include/clang/AST/ASTNodeTraverser.h | 3 +-
clang/include/clang/AST/AbstractBasicReader.h | 4 +-
clang/include/clang/AST/AbstractBasicWriter.h | 1 -
clang/include/clang/AST/NestedNameSpecifier.h | 20 +-
clang/include/clang/AST/ODRHash.h | 1 +
clang/include/clang/AST/PropertiesBase.td | 15 +-
clang/include/clang/AST/RecursiveASTVisitor.h | 5 +-
clang/include/clang/AST/TemplateName.h | 133 +++++------
clang/include/clang/AST/Type.h | 22 +-
clang/include/clang/AST/TypeLoc.h | 9 +-
clang/include/clang/AST/TypeProperties.td | 47 ++--
clang/include/clang/Sema/DeclSpec.h | 3 +-
clang/lib/AST/ASTContext.cpp | 214 +++++++-----------
clang/lib/AST/ASTImporter.cpp | 63 ++----
clang/lib/AST/ASTStructuralEquivalence.cpp | 37 +--
clang/lib/AST/ItaniumMangle.cpp | 35 +--
clang/lib/AST/NestedNameSpecifier.cpp | 102 ++-------
clang/lib/AST/ODRHash.cpp | 19 +-
clang/lib/AST/QualTypeNames.cpp | 8 +-
clang/lib/AST/TemplateName.cpp | 67 +++++-
clang/lib/AST/TextNodeDumper.cpp | 4 -
clang/lib/AST/Type.cpp | 27 +--
clang/lib/AST/TypeLoc.cpp | 5 +-
clang/lib/AST/TypePrinter.cpp | 12 +-
clang/lib/ExtractAPI/DeclarationFragments.cpp | 7 -
clang/lib/Index/IndexTypeSourceInfo.cpp | 1 -
clang/lib/Parse/ParseExprCXX.cpp | 8 +-
clang/lib/Sema/DeclSpec.cpp | 6 +-
clang/lib/Sema/HeuristicResolver.cpp | 6 +-
clang/lib/Sema/SemaCXXScopeSpec.cpp | 31 +--
clang/lib/Sema/SemaCodeComplete.cpp | 6 +-
clang/lib/Sema/SemaCoroutine.cpp | 3 +-
clang/lib/Sema/SemaDecl.cpp | 24 +-
clang/lib/Sema/SemaDeclCXX.cpp | 3 +-
clang/lib/Sema/SemaExpr.cpp | 2 +-
clang/lib/Sema/SemaExprCXX.cpp | 1 -
clang/lib/Sema/SemaLookup.cpp | 4 +-
clang/lib/Sema/SemaTemplate.cpp | 41 ++--
clang/lib/Sema/SemaTemplateDeduction.cpp | 3 +-
clang/lib/Sema/TreeTransform.h | 149 ++++++------
clang/lib/Serialization/ASTReader.cpp | 10 +-
clang/lib/Serialization/ASTWriter.cpp | 2 -
clang/lib/Tooling/Syntax/BuildTree.cpp | 2 -
clang/test/AST/ast-dump-decl.cpp | 20 +-
clang/test/AST/ast-dump-expr.cpp | 3 +-
clang/test/AST/ast-dump-templates.cpp | 6 +-
clang/test/CXX/class.access/p6.cpp | 4 +-
clang/test/CXX/drs/cwg2xx.cpp | 4 +-
.../expr.prim.req/nested-requirement.cpp | 2 +-
clang/test/SemaCXX/static-assert.cpp | 4 +-
.../aggregate-deduction-candidate.cpp | 8 +-
.../dependent-template-recover.cpp | 18 ++
.../instantiate-requires-expr.cpp | 4 +-
clang/tools/libclang/CIndex.cpp | 2 -
.../array/array.overview/nttp.verify.cpp | 2 +-
.../adapt/inout_ptr/inout_ptr.verify.cpp | 2 +-
.../smartptr/adapt/out_ptr/out_ptr.verify.cpp | 2 +-
.../utility/pairs/pairs.pair/nttp.verify.cpp | 2 +-
66 files changed, 585 insertions(+), 702 deletions(-)
diff --git a/clang-tools-extra/clangd/AST.cpp b/clang-tools-extra/clangd/AST.cpp
index f3eee1c6335f9..66b587f00ff4a 100644
--- a/clang-tools-extra/clangd/AST.cpp
+++ b/clang-tools-extra/clangd/AST.cpp
@@ -119,8 +119,7 @@ getQualification(ASTContext &Context, const DeclContext *DestContext,
// There can't be any more tag parents after hitting a namespace.
assert(!ReachedNS);
(void)ReachedNS;
- NNS = NestedNameSpecifier::Create(Context, nullptr, false,
- TD->getTypeForDecl());
+ NNS = NestedNameSpecifier::Create(Context, nullptr, TD->getTypeForDecl());
} else if (auto *NSD = llvm::dyn_cast<NamespaceDecl>(CurContext)) {
ReachedNS = true;
NNS = NestedNameSpecifier::Create(Context, nullptr, NSD);
diff --git a/clang-tools-extra/clangd/CodeComplete.cpp b/clang-tools-extra/clangd/CodeComplete.cpp
index 008cc96c91996..0eb196fbad46a 100644
--- a/clang-tools-extra/clangd/CodeComplete.cpp
+++ b/clang-tools-extra/clangd/CodeComplete.cpp
@@ -1467,7 +1467,6 @@ bool allowIndex(CodeCompletionContext &CC) {
return true;
case NestedNameSpecifier::Super:
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
// Unresolved inside a template.
case NestedNameSpecifier::Identifier:
return false;
diff --git a/clang-tools-extra/clangd/DumpAST.cpp b/clang-tools-extra/clangd/DumpAST.cpp
index e605f82e91fe4..584bb1f088380 100644
--- a/clang-tools-extra/clangd/DumpAST.cpp
+++ b/clang-tools-extra/clangd/DumpAST.cpp
@@ -157,7 +157,6 @@ class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
NNS_KIND(Identifier);
NNS_KIND(Namespace);
NNS_KIND(TypeSpec);
- NNS_KIND(TypeSpecWithTemplate);
NNS_KIND(Global);
NNS_KIND(Super);
NNS_KIND(NamespaceAlias);
diff --git a/clang-tools-extra/clangd/FindTarget.cpp b/clang-tools-extra/clangd/FindTarget.cpp
index bb4c91b831354..62f220b32bd10 100644
--- a/clang-tools-extra/clangd/FindTarget.cpp
+++ b/clang-tools-extra/clangd/FindTarget.cpp
@@ -500,7 +500,6 @@ struct TargetFinder {
}
return;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
add(QualType(NNS->getAsType(), 0), Flags);
return;
case NestedNameSpecifier::Global:
diff --git a/clang-tools-extra/include-cleaner/lib/WalkAST.cpp b/clang-tools-extra/include-cleaner/lib/WalkAST.cpp
index 7a140c991925c..dff0c711f04c5 100644
--- a/clang-tools-extra/include-cleaner/lib/WalkAST.cpp
+++ b/clang-tools-extra/include-cleaner/lib/WalkAST.cpp
@@ -144,7 +144,6 @@ class ASTWalker : public RecursiveASTVisitor<ASTWalker> {
case NestedNameSpecifier::Global:
return true;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::Super:
case NestedNameSpecifier::Identifier:
return false;
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 0655c90e72413..284dc36c9c7b7 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -275,6 +275,10 @@ Improvements to Clang's diagnostics
- Diagnostics on chained comparisons (``a < b < c``) are now an error by default. This can be disabled with
``-Wno-error=parentheses``.
- Clang now better preserves the sugared types of pointers to member.
+- Clang now better preserves the presence of the template keyword with dependent
+ prefixes.
+- When printing types for diagnostics, clang now doesn't suppress the scopes of
+ template arguments contained within nested names.
- The ``-Wshift-bool`` warning has been added to warn about shifting a boolean. (#GH28334)
- Fixed diagnostics adding a trailing ``::`` when printing some source code
constructs, like base classes.
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 2ef8112225767..36d06f3af7eb3 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1835,15 +1835,15 @@ class ASTContext : public RefCountedBase<ASTContext> {
TagDecl *OwnedTagDecl = nullptr) const;
QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
- const IdentifierInfo *Name,
- QualType Canon = QualType()) const;
+ const IdentifierInfo *Name) const;
QualType getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
- const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const;
- QualType getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
- const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgumentLoc> Args) const;
+ QualType
+ getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
+ const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgument> Args) const;
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const;
@@ -2392,10 +2392,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
bool TemplateKeyword,
TemplateName Template) const;
- TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
- const IdentifierInfo *Name) const;
- TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
- OverloadedOperatorKind Operator) const;
+ TemplateName
+ getDependentTemplateName(const DependentTemplateStorage &Name) const;
TemplateName getSubstTemplateTemplateParm(TemplateName replacement,
Decl *AssociatedDecl,
unsigned Index,
diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h
index 8c3fa842ab8b9..a2550716e3c7f 100644
--- a/clang/include/clang/AST/ASTImporter.h
+++ b/clang/include/clang/AST/ASTImporter.h
@@ -446,6 +446,14 @@ class TypeSourceInfo;
/// returns nullptr only if the FromId was nullptr.
IdentifierInfo *Import(const IdentifierInfo *FromId);
+ /// Import the given identifier or overloaded operator from the "from"
+ /// context into the "to" context.
+ ///
+ /// \returns The equivalent identifier or overloaded operator in the "to"
+ /// context.
+ IdentifierOrOverloadedOperator
+ Import(IdentifierOrOverloadedOperator FromIO);
+
/// Import the given Objective-C selector from the "from"
/// context into the "to" context.
///
diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h
index 83a6b77704f34..f086d8134a64b 100644
--- a/clang/include/clang/AST/ASTNodeTraverser.h
+++ b/clang/include/clang/AST/ASTNodeTraverser.h
@@ -396,8 +396,7 @@ class ASTNodeTraverser
// FIXME: Provide a NestedNameSpecifier visitor.
NestedNameSpecifier *Qualifier = T->getQualifier();
if (NestedNameSpecifier::SpecifierKind K = Qualifier->getKind();
- K == NestedNameSpecifier::TypeSpec ||
- K == NestedNameSpecifier::TypeSpecWithTemplate)
+ K == NestedNameSpecifier::TypeSpec)
Visit(Qualifier->getAsType());
if (T->isSugared())
Visit(T->getMostRecentCXXRecordDecl()->getTypeForDecl());
diff --git a/clang/include/clang/AST/AbstractBasicReader.h b/clang/include/clang/AST/AbstractBasicReader.h
index 4b627c65e276b..5ab438715ecf7 100644
--- a/clang/include/clang/AST/AbstractBasicReader.h
+++ b/clang/include/clang/AST/AbstractBasicReader.h
@@ -279,10 +279,8 @@ class DataStreamBasicReader : public BasicReaderBase<Impl> {
continue;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
cur = NestedNameSpecifier::Create(ctx, cur,
- kind == NestedNameSpecifier::TypeSpecWithTemplate,
- asImpl().readQualType().getTypePtr());
+ asImpl().readQualType().getTypePtr());
continue;
case NestedNameSpecifier::Global:
diff --git a/clang/include/clang/AST/AbstractBasicWriter.h b/clang/include/clang/AST/AbstractBasicWriter.h
index b941add8bde88..f65d94abc2ff1 100644
--- a/clang/include/clang/AST/AbstractBasicWriter.h
+++ b/clang/include/clang/AST/AbstractBasicWriter.h
@@ -260,7 +260,6 @@ class DataStreamBasicWriter : public BasicWriterBase<Impl> {
continue;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
asImpl().writeQualType(QualType(NNS->getAsType(), 0));
continue;
diff --git a/clang/include/clang/AST/NestedNameSpecifier.h b/clang/include/clang/AST/NestedNameSpecifier.h
index 273e73e7c1e95..d7da3272d0943 100644
--- a/clang/include/clang/AST/NestedNameSpecifier.h
+++ b/clang/include/clang/AST/NestedNameSpecifier.h
@@ -52,8 +52,7 @@ class NestedNameSpecifier : public llvm::FoldingSetNode {
enum StoredSpecifierKind {
StoredIdentifier = 0,
StoredDecl = 1,
- StoredTypeSpec = 2,
- StoredTypeSpecWithTemplate = 3
+ StoredTypeSpec = 2
};
/// The nested name specifier that precedes this nested name
@@ -89,10 +88,6 @@ class NestedNameSpecifier : public llvm::FoldingSetNode {
/// A type, stored as a Type*.
TypeSpec,
- /// A type that was preceded by the 'template' keyword,
- /// stored as a Type*.
- TypeSpecWithTemplate,
-
/// The global specifier '::'. There is no stored value.
Global,
@@ -137,9 +132,8 @@ class NestedNameSpecifier : public llvm::FoldingSetNode {
const NamespaceAliasDecl *Alias);
/// Builds a nested name specifier that names a type.
- static NestedNameSpecifier *Create(const ASTContext &Context,
- NestedNameSpecifier *Prefix,
- bool Template, const Type *T);
+ static NestedNameSpecifier *
+ Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const Type *T);
/// Builds a specifier that consists of just an identifier.
///
@@ -194,8 +188,7 @@ class NestedNameSpecifier : public llvm::FoldingSetNode {
/// Retrieve the type stored in this nested name specifier.
const Type *getAsType() const {
- if (Prefix.getInt() == StoredTypeSpec ||
- Prefix.getInt() == StoredTypeSpecWithTemplate)
+ if (Prefix.getInt() == StoredTypeSpec)
return (const Type *)Specifier;
return nullptr;
@@ -401,13 +394,10 @@ class NestedNameSpecifierLocBuilder {
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
- /// \param TemplateKWLoc The location of the 'template' keyword, if present.
- ///
/// \param TL The TypeLoc that describes the type preceding the '::'.
///
/// \param ColonColonLoc The location of the trailing '::'.
- void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
- SourceLocation ColonColonLoc);
+ void Extend(ASTContext &Context, TypeLoc TL, SourceLocation ColonColonLoc);
/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'identifier::'.
diff --git a/clang/include/clang/AST/ODRHash.h b/clang/include/clang/AST/ODRHash.h
index a1caa6d39a87c..a923901b32dc0 100644
--- a/clang/include/clang/AST/ODRHash.h
+++ b/clang/include/clang/AST/ODRHash.h
@@ -94,6 +94,7 @@ class ODRHash {
void AddStmt(const Stmt *S);
void AddIdentifierInfo(const IdentifierInfo *II);
void AddNestedNameSpecifier(const NestedNameSpecifier *NNS);
+ void AddDependentTemplateName(const DependentTemplateStorage &Name);
void AddTemplateName(TemplateName Name);
void AddDeclarationName(DeclarationName Name, bool TreatAsDecl = false);
void AddTemplateArgument(TemplateArgument TA);
diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td
index 416914db2f7c8..0e360de16fdd6 100644
--- a/clang/include/clang/AST/PropertiesBase.td
+++ b/clang/include/clang/AST/PropertiesBase.td
@@ -691,25 +691,26 @@ let Class = PropertyTypeCase<TemplateName, "QualifiedTemplate"> in {
let Class = PropertyTypeCase<TemplateName, "DependentTemplate"> in {
def : ReadHelper<[{
auto dtn = node.getAsDependentTemplateName();
+ auto name = dtn->getName();
}]>;
def : Property<"qualifier", NestedNameSpecifier> {
let Read = [{ dtn->getQualifier() }];
}
def : Property<"identifier", Optional<Identifier>> {
- let Read = [{ makeOptionalFromPointer(
- dtn->isIdentifier()
- ? dtn->getIdentifier()
- : nullptr) }];
+ let Read = [{ makeOptionalFromPointer(name.getIdentifier()) }];
}
def : Property<"operatorKind", OverloadedOperatorKind> {
let Conditional = [{ !identifier }];
- let Read = [{ dtn->getOperator() }];
+ let Read = [{ name.getOperator() }];
+ }
+ def : Property<"HasTemplateKeyword", Bool> {
+ let Read = [{ dtn->hasTemplateKeyword() }];
}
def : Creator<[{
if (identifier) {
- return ctx.getDependentTemplateName(qualifier, *identifier);
+ return ctx.getDependentTemplateName({qualifier, *identifier, HasTemplateKeyword});
} else {
- return ctx.getDependentTemplateName(qualifier, *operatorKind);
+ return ctx.getDependentTemplateName({qualifier, *operatorKind, HasTemplateKeyword});
}
}]>;
}
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
index 0d5d515c0e6f7..0530996ed20d3 100644
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -795,7 +795,6 @@ bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
return true;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
}
@@ -820,7 +819,6 @@ bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
return true;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
break;
}
@@ -1172,7 +1170,8 @@ DEF_TRAVERSE_TYPE(DependentNameType,
{ TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); })
DEF_TRAVERSE_TYPE(DependentTemplateSpecializationType, {
- TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
+ const DependentTemplateStorage &S = T->getDependentTemplateName();
+ TRY_TO(TraverseNestedNameSpecifier(S.getQualifier()));
TRY_TO(TraverseTemplateArguments(T->template_arguments()));
})
diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h
index 313802502f818..ece2afcfa72ab 100644
--- a/clang/include/clang/AST/TemplateName.h
+++ b/clang/include/clang/AST/TemplateName.h
@@ -16,6 +16,7 @@
#include "clang/AST/DependenceFlags.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/Basic/LLVM.h"
+#include "clang/Basic/OperatorKinds.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/PointerUnion.h"
@@ -544,6 +545,35 @@ class QualifiedTemplateName : public llvm::FoldingSetNode {
}
};
+struct IdentifierOrOverloadedOperator {
+ IdentifierOrOverloadedOperator() = default;
+ IdentifierOrOverloadedOperator(const IdentifierInfo *II);
+ IdentifierOrOverloadedOperator(OverloadedOperatorKind OOK);
+
+ /// Returns the identifier to which this template name refers.
+ const IdentifierInfo *getIdentifier() const {
+ if (getOperator() != OO_None)
+ return nullptr;
+ return reinterpret_cast<const IdentifierInfo *>(PtrOrOp);
+ }
+
+ /// Return the overloaded operator to which this template name refers.
+ OverloadedOperatorKind getOperator() const {
+ uintptr_t OOK = -PtrOrOp;
+ return OOK < NUM_OVERLOADED_OPERATORS ? OverloadedOperatorKind(OOK)
+ : OO_None;
+ }
+
+ void Profile(llvm::FoldingSetNodeID &ID) const;
+
+ bool operator==(const IdentifierOrOverloadedOperator &Other) const {
+ return PtrOrOp == Other.PtrOrOp;
+ };
+
+private:
+ uintptr_t PtrOrOp = 0;
+};
+
/// Represents a dependent template name that cannot be
/// resolved prior to template instantiation.
///
@@ -552,104 +582,53 @@ class QualifiedTemplateName : public llvm::FoldingSetNode {
/// DependentTemplateName can refer to "MetaFun::template apply",
/// where "MetaFun::" is the nested name specifier and "apply" is the
/// template name referenced. The "template" keyword is implied.
-class DependentTemplateName : public llvm::FoldingSetNode {
- friend class ASTContext;
-
+class DependentTemplateStorage {
/// The nested name specifier that qualifies the template
/// name.
///
/// The bit stored in this qualifier describes whether the \c Name field
- /// is interpreted as an IdentifierInfo pointer (when clear) or as an
- /// overloaded operator kind (when set).
+ /// was preceeded by a template keyword.
llvm::PointerIntPair<NestedNameSpecifier *, 1, bool> Qualifier;
/// The dependent template name.
- union {
- /// The identifier template name.
- ///
- /// Only valid when the bit on \c Qualifier is clear.
- const IdentifierInfo *Identifier;
-
- /// The overloaded operator name.
- ///
- /// Only valid when the bit on \c Qualifier is set.
- OverloadedOperatorKind Operator;
- };
-
- /// The canonical template name to which this dependent
- /// template name refers.
- ///
- /// The canonical template name for a dependent template name is
- /// another dependent template name whose nested name specifier is
- /// canonical.
- TemplateName CanonicalTemplateName;
-
- DependentTemplateName(NestedNameSpecifier *Qualifier,
- const IdentifierInfo *Identifier)
- : Qualifier(Qualifier, false), Identifier(Identifier),
- CanonicalTemplateName(this) {}
-
- DependentTemplateName(NestedNameSpecifier *Qualifier,
- const IdentifierInfo *Identifier,
- TemplateName Canon)
- : Qualifier(Qualifier, false), Identifier(Identifier),
- CanonicalTemplateName(Canon) {}
-
- DependentTemplateName(NestedNameSpecifier *Qualifier,
- OverloadedOperatorKind Operator)
- : Qualifier(Qualifier, true), Operator(Operator),
- CanonicalTemplateName(this) {}
-
- DependentTemplateName(NestedNameSpecifier *Qualifier,
- OverloadedOperatorKind Operator,
- TemplateName Canon)
- : Qualifier(Qualifier, true), Operator(Operator),
- CanonicalTemplateName(Canon) {}
+ IdentifierOrOverloadedOperator Name;
public:
+ DependentTemplateStorage(NestedNameSpecifier *Qualifier,
+ IdentifierOrOverloadedOperator Name,
+ bool HasTemplateKeyword);
+
/// Return the nested name specifier that qualifies this name.
NestedNameSpecifier *getQualifier() const { return Qualifier.getPointer(); }
- /// Determine whether this template name refers to an identifier.
- bool isIdentifier() const { return !Qualifier.getInt(); }
+ IdentifierOrOverloadedOperator getName() const { return Name; }
- /// Returns the identifier to which this template name refers.
- const IdentifierInfo *getIdentifier() const {
- assert(isIdentifier() && "Template name isn't an identifier?");
- return Identifier;
- }
-
- /// Determine whether this template name refers to an overloaded
- /// operator.
- bool isOverloadedOperator() const { return Qualifier.getInt(); }
+ /// Was this template name was preceeded by the template keyword?
+ bool hasTemplateKeyword() const { return Qualifier.getInt(); }
- /// Return the overloaded operator to which this template name refers.
- OverloadedOperatorKind getOperator() const {
- assert(isOverloadedOperator() &&
- "Template name isn't an overloaded operator?");
- return Operator;
- }
+ TemplateNameDependence getDependence() const;
- void Profile(llvm::FoldingSetNodeID &ID) {
- if (isIdentifier())
- Profile(ID, getQualifier(), getIdentifier());
- else
- Profile(ID, getQualifier(), getOperator());
+ void Profile(llvm::FoldingSetNodeID &ID) const {
+ Profile(ID, getQualifier(), getName(), hasTemplateKeyword());
}
static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
- const IdentifierInfo *Identifier) {
+ IdentifierOrOverloadedOperator Name,
+ bool HasTemplateKeyword) {
ID.AddPointer(NNS);
- ID.AddBoolean(false);
- ID.AddPointer(Identifier);
+ ID.AddBoolean(HasTemplateKeyword);
+ Name.Profile(ID);
}
- static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
- OverloadedOperatorKind Operator) {
- ID.AddPointer(NNS);
- ID.AddBoolean(true);
- ID.AddInteger(Operator);
- }
+ void print(raw_ostream &OS, const PrintingPolicy &Policy) const;
+};
+
+class DependentTemplateName : public DependentTemplateStorage,
+ public llvm::FoldingSetNode {
+ friend class ASTContext;
+ using DependentTemplateStorage::DependentTemplateStorage;
+ DependentTemplateName(const DependentTemplateStorage &S)
+ : DependentTemplateStorage(S) {}
};
} // namespace clang.
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index d7b4ffd060e69..86ae335452980 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -7079,21 +7079,17 @@ class DependentTemplateSpecializationType : public TypeWithKeyword,
public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these
- /// The nested name specifier containing the qualifier.
- NestedNameSpecifier *NNS;
-
- /// The identifier of the template.
- const IdentifierInfo *Name;
+ DependentTemplateStorage Name;
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
- NestedNameSpecifier *NNS,
- const IdentifierInfo *Name,
+ const DependentTemplateStorage &Name,
ArrayRef<TemplateArgument> Args,
QualType Canon);
public:
- NestedNameSpecifier *getQualifier() const { return NNS; }
- const IdentifierInfo *getIdentifier() const { return Name; }
+ const DependentTemplateStorage &getDependentTemplateName() const {
+ return Name;
+ }
ArrayRef<TemplateArgument> template_arguments() const {
return {reinterpret_cast<const TemplateArgument *>(this + 1),
@@ -7104,14 +7100,12 @@ class DependentTemplateSpecializationType : public TypeWithKeyword,
QualType desugar() const { return QualType(this, 0); }
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
- Profile(ID, Context, getKeyword(), NNS, Name, template_arguments());
+ Profile(ID, Context, getKeyword(), Name, template_arguments());
}
- static void Profile(llvm::FoldingSetNodeID &ID,
- const ASTContext &Context,
+ static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
ElaboratedTypeKeyword Keyword,
- NestedNameSpecifier *Qualifier,
- const IdentifierInfo *Name,
+ const DependentTemplateStorage &Name,
ArrayRef<TemplateArgument> Args);
static bool classof(const Type *T) {
diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h
index 17ce09fa5da4f..92661b8b13fe0 100644
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -2502,8 +2502,9 @@ class DependentTemplateSpecializationTypeLoc :
if (!getLocalData()->QualifierData)
return NestedNameSpecifierLoc();
- return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
- getLocalData()->QualifierData);
+ return NestedNameSpecifierLoc(
+ getTypePtr()->getDependentTemplateName().getQualifier(),
+ getLocalData()->QualifierData);
}
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
@@ -2516,8 +2517,8 @@ class DependentTemplateSpecializationTypeLoc :
return;
}
- assert(QualifierLoc.getNestedNameSpecifier()
- == getTypePtr()->getQualifier() &&
+ assert(QualifierLoc.getNestedNameSpecifier() ==
+ getTypePtr()->getDependentTemplateName().getQualifier() &&
"Inconsistent nested-name-specifier pointer");
getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
}
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index 93f391e99c5ab..477106a152188 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -774,22 +774,37 @@ let Class = TemplateSpecializationType in {
}
let Class = DependentTemplateSpecializationType in {
- def : Property<"keyword", ElaboratedTypeKeyword> {
- let Read = [{ node->getKeyword() }];
- }
+ def : ReadHelper<[{
+ const auto &dtn = node->getDependentTemplateName();
+ auto name = dtn.getName();
+ }]>;
+
def : Property<"qualifier", NestedNameSpecifier> {
- let Read = [{ node->getQualifier() }];
+ let Read = [{ dtn.getQualifier() }];
+ }
+ def : Property<"identifier", Optional<Identifier>> {
+ let Read = [{ makeOptionalFromPointer(name.getIdentifier()) }];
}
- def : Property<"name", Identifier> {
- let Read = [{ node->getIdentifier() }];
+ def : Property<"operatorKind", OverloadedOperatorKind> {
+ let Conditional = [{ !identifier }];
+ let Read = [{ name.getOperator() }];
+ }
+ def : Property<"HasTemplateKeyword", Bool> {
+ let Read = [{ dtn.hasTemplateKeyword() }];
+ }
+
+ def : Property<"keyword", ElaboratedTypeKeyword> {
+ let Read = [{ node->getKeyword() }];
}
def : Property<"templateArguments", Array<TemplateArgument>> {
let Read = [{ node->template_arguments() }];
}
def : Creator<[{
- return ctx.getDependentTemplateSpecializationType(keyword, qualifier,
- name, templateArguments);
+ DependentTemplateStorage S(qualifier, identifier ? IdentifierOrOverloadedOperator(*identifier) :
+ IdentifierOrOverloadedOperator(*operatorKind),
+ HasTemplateKeyword);
+ return ctx.getDependentTemplateSpecializationType(keyword, S, templateArguments);
}]>;
}
@@ -923,22 +938,10 @@ let Class = DependentNameType in {
def : Property<"qualifier", NestedNameSpecifier> {
let Read = [{ node->getQualifier() }];
}
- def : Property<"name", Identifier> {
- let Read = [{ node->getIdentifier() }];
- }
- def : Property<"underlyingType", Optional<QualType>> {
- let Read = [{
- node->isCanonicalUnqualified()
- ? std::nullopt
- : std::optional<QualType>(node->getCanonicalTypeInternal())
- }];
- }
+ def : Property<"name", Identifier> { let Read = [{ node->getIdentifier() }]; }
def : Creator<[{
- QualType canon = (underlyingType
- ? ctx.getCanonicalType(*underlyingType)
- : QualType());
- return ctx.getDependentNameType(keyword, qualifier, name, canon);
+ return ctx.getDependentNameType(keyword, qualifier, name);
}]>;
}
diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h
index 5f5df3a45d41d..6c4a32c4ac2f0 100644
--- a/clang/include/clang/Sema/DeclSpec.h
+++ b/clang/include/clang/Sema/DeclSpec.h
@@ -107,8 +107,7 @@ class CXXScopeSpec {
/// \param TL The TypeLoc that describes the type preceding the '::'.
///
/// \param ColonColonLoc The location of the trailing '::'.
- void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
- SourceLocation ColonColonLoc);
+ void Extend(ASTContext &Context, TypeLoc TL, SourceLocation ColonColonLoc);
/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'identifier::'.
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index e088e2ea45cc7..36cd93ce0f4b6 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -4033,7 +4033,6 @@ QualType ASTContext::getMemberPointerType(QualType T,
if (!Qualifier) {
assert(Cls && "At least one of Qualifier or Cls must be provided");
Qualifier = NestedNameSpecifier::Create(*this, /*Prefix=*/nullptr,
- /*Template=*/false,
getTypeDeclType(Cls).getTypePtr());
} else if (!Cls) {
Cls = Qualifier->getAsRecordDecl();
@@ -4052,8 +4051,7 @@ QualType ASTContext::getMemberPointerType(QualType T,
if (!Cls)
return getCanonicalNestedNameSpecifier(Qualifier);
NestedNameSpecifier *R = NestedNameSpecifier::Create(
- *this, /*Prefix=*/nullptr, /*Template=*/false,
- Cls->getCanonicalDecl()->getTypeForDecl());
+ *this, /*Prefix=*/nullptr, Cls->getCanonicalDecl()->getTypeForDecl());
assert(R == getCanonicalNestedNameSpecifier(R));
return R;
}();
@@ -5738,24 +5736,26 @@ ASTContext::getMacroQualifiedType(QualType UnderlyingTy,
QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
- const IdentifierInfo *Name,
- QualType Canon) const {
- if (Canon.isNull()) {
- NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
- if (CanonNNS != NNS)
- Canon = getDependentNameType(Keyword, CanonNNS, Name);
- }
-
+ const IdentifierInfo *Name) const {
llvm::FoldingSetNodeID ID;
DependentNameType::Profile(ID, Keyword, NNS, Name);
void *InsertPos = nullptr;
- DependentNameType *T
- = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
- if (T)
+ if (DependentNameType *T =
+ DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(T, 0);
- T = new (*this, alignof(DependentNameType))
+ QualType Canon;
+ if (NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
+ CanonNNS != NNS) {
+ Canon = getDependentNameType(Keyword, CanonNNS, Name);
+ [[maybe_unused]] DependentNameType *T =
+ DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
+ assert(!T && "broken canonicalization");
+ assert(Canon.isCanonical());
+ }
+
+ DependentNameType *T = new (*this, alignof(DependentNameType))
DependentNameType(Keyword, NNS, Name, Canon);
Types.push_back(T);
DependentNameTypes.InsertNode(T, InsertPos);
@@ -5763,27 +5763,20 @@ QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
}
QualType ASTContext::getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
- const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const {
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgumentLoc> Args) const {
// TODO: avoid this copy
SmallVector<TemplateArgument, 16> ArgCopy;
for (unsigned I = 0, E = Args.size(); I != E; ++I)
ArgCopy.push_back(Args[I].getArgument());
- return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
+ return getDependentTemplateSpecializationType(Keyword, Name, ArgCopy);
}
-QualType
-ASTContext::getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword,
- NestedNameSpecifier *NNS,
- const IdentifierInfo *Name,
- ArrayRef<TemplateArgument> Args) const {
- assert((!NNS || NNS->isDependent()) &&
- "nested-name-specifier must be dependent");
-
+QualType ASTContext::getDependentTemplateSpecializationType(
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgument> Args) const {
llvm::FoldingSetNodeID ID;
- DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
- Name, Args);
+ DependentTemplateSpecializationType::Profile(ID, *this, Keyword, Name, Args);
void *InsertPos = nullptr;
DependentTemplateSpecializationType *T
@@ -5791,7 +5784,8 @@ ASTContext::getDependentTemplateSpecializationType(
if (T)
return QualType(T, 0);
- NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
+ NestedNameSpecifier *NNS = Name.getQualifier(),
+ *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
ElaboratedTypeKeyword CanonKeyword = Keyword;
if (Keyword == ElaboratedTypeKeyword::None)
@@ -5802,10 +5796,11 @@ ASTContext::getDependentTemplateSpecializationType(
::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
QualType Canon;
- if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
- Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
- Name,
- CanonArgs);
+ if (AnyNonCanonArgs || CanonNNS != NNS || !Name.hasTemplateKeyword() ||
+ CanonKeyword != Keyword) {
+ Canon = getDependentTemplateSpecializationType(
+ CanonKeyword, {CanonNNS, Name.getName(), /*HasTemplateKeyword=*/true},
+ CanonArgs);
// Find the insert position again.
[[maybe_unused]] auto *Nothing =
@@ -5816,8 +5811,7 @@ ASTContext::getDependentTemplateSpecializationType(
void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
sizeof(TemplateArgument) * Args.size()),
alignof(DependentTemplateSpecializationType));
- T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
- Name, Args, Canon);
+ T = new (Mem) DependentTemplateSpecializationType(Keyword, Name, Args, Canon);
Types.push_back(T);
DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
@@ -6915,12 +6909,13 @@ ASTContext::getNameForTemplate(TemplateName Name,
case TemplateName::DependentTemplate: {
DependentTemplateName *DTN = Name.getAsDependentTemplateName();
+ IdentifierOrOverloadedOperator TN = DTN->getName();
DeclarationName DName;
- if (DTN->isIdentifier()) {
- DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
+ if (const IdentifierInfo *II = TN.getIdentifier()) {
+ DName = DeclarationNames.getIdentifier(II);
return DeclarationNameInfo(DName, NameLoc);
} else {
- DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
+ DName = DeclarationNames.getCXXOperatorName(TN.getOperator());
// DNInfo work in progress: FIXME: source locations?
DeclarationNameLoc DNLoc =
DeclarationNameLoc::makeCXXOperatorNameLoc(SourceRange());
@@ -6995,7 +6990,13 @@ TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name,
case TemplateName::DependentTemplate: {
DependentTemplateName *DTN = Name.getAsDependentTemplateName();
assert(DTN && "Non-dependent template names must refer to template decls.");
- return DTN->CanonicalTemplateName;
+ NestedNameSpecifier *Qualifier = DTN->getQualifier();
+ NestedNameSpecifier *CanonQualifier =
+ getCanonicalNestedNameSpecifier(Qualifier);
+ if (Qualifier != CanonQualifier || !DTN->hasTemplateKeyword())
+ return getDependentTemplateName({CanonQualifier, DTN->getName(),
+ /*HasTemplateKeyword=*/true});
+ return Name;
}
case TemplateName::SubstTemplateTemplateParmPack: {
@@ -7228,7 +7229,6 @@ static bool isSameQualifier(const NestedNameSpecifier *X,
// We've already checked that we named the same namespace.
break;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
if (X->getAsType()->getCanonicalTypeInternal() !=
Y->getAsType()->getCanonicalTypeInternal())
return false;
@@ -7607,8 +7607,7 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
// The difference between TypeSpec and TypeSpecWithTemplate is that the
// latter will have the 'template' keyword when printed.
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
const Type *T = getCanonicalType(NNS->getAsType());
// If we have some kind of dependent-named type (e.g., "typename T::type"),
@@ -7621,11 +7620,19 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
if (const auto *DNT = T->getAs<DependentNameType>())
return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
DNT->getIdentifier());
- if (const auto *DTST = T->getAs<DependentTemplateSpecializationType>())
- return NestedNameSpecifier::Create(*this, DTST->getQualifier(), true, T);
-
- // TODO: Set 'Template' parameter to true for other template types.
- return NestedNameSpecifier::Create(*this, nullptr, false, T);
+ if (const auto *DTST = T->getAs<DependentTemplateSpecializationType>()) {
+ const DependentTemplateStorage &DTN = DTST->getDependentTemplateName();
+ QualType NewT = getDependentTemplateSpecializationType(
+ ElaboratedTypeKeyword::Typename,
+ {/*NNS=*/nullptr, DTN.getName(), /*HasTemplateKeyword=*/true},
+ DTST->template_arguments());
+ assert(NewT.isCanonical());
+ NestedNameSpecifier *Prefix = DTN.getQualifier();
+ if (!Prefix)
+ Prefix = getCanonicalNestedNameSpecifier(NNS->getPrefix());
+ return NestedNameSpecifier::Create(*this, Prefix, NewT.getTypePtr());
+ }
+ return NestedNameSpecifier::Create(*this, nullptr, T);
}
case NestedNameSpecifier::Global:
@@ -10055,75 +10062,20 @@ TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
return TemplateName(QTN);
}
-/// Retrieve the template name that represents a dependent
-/// template name such as \c MetaFun::template apply.
-TemplateName
-ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
- const IdentifierInfo *Name) const {
- assert((!NNS || NNS->isDependent()) &&
- "Nested name specifier must be dependent");
-
- llvm::FoldingSetNodeID ID;
- DependentTemplateName::Profile(ID, NNS, Name);
-
- void *InsertPos = nullptr;
- DependentTemplateName *QTN =
- DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
-
- if (QTN)
- return TemplateName(QTN);
-
- NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
- if (CanonNNS == NNS) {
- QTN = new (*this, alignof(DependentTemplateName))
- DependentTemplateName(NNS, Name);
- } else {
- TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
- QTN = new (*this, alignof(DependentTemplateName))
- DependentTemplateName(NNS, Name, Canon);
- DependentTemplateName *CheckQTN =
- DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
- assert(!CheckQTN && "Dependent type name canonicalization broken");
- (void)CheckQTN;
- }
-
- DependentTemplateNames.InsertNode(QTN, InsertPos);
- return TemplateName(QTN);
-}
-
/// Retrieve the template name that represents a dependent
/// template name such as \c MetaFun::template operator+.
TemplateName
-ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
- OverloadedOperatorKind Operator) const {
- assert((!NNS || NNS->isDependent()) &&
- "Nested name specifier must be dependent");
-
+ASTContext::getDependentTemplateName(const DependentTemplateStorage &S) const {
llvm::FoldingSetNodeID ID;
- DependentTemplateName::Profile(ID, NNS, Operator);
+ S.Profile(ID);
void *InsertPos = nullptr;
- DependentTemplateName *QTN
- = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
-
- if (QTN)
+ if (DependentTemplateName *QTN =
+ DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos))
return TemplateName(QTN);
- NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
- if (CanonNNS == NNS) {
- QTN = new (*this, alignof(DependentTemplateName))
- DependentTemplateName(NNS, Operator);
- } else {
- TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
- QTN = new (*this, alignof(DependentTemplateName))
- DependentTemplateName(NNS, Operator, Canon);
-
- DependentTemplateName *CheckQTN
- = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
- assert(!CheckQTN && "Dependent template name canonicalization broken");
- (void)CheckQTN;
- }
-
+ DependentTemplateName *QTN =
+ new (*this, alignof(DependentTemplateName)) DependentTemplateName(S);
DependentTemplateNames.InsertNode(QTN, InsertPos);
return TemplateName(QTN);
}
@@ -13542,19 +13494,12 @@ static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx,
R = NestedNameSpecifier::Create(Ctx, P, ::getCommonDeclChecked(N1, N2));
break;
}
- case NestedNameSpecifier::SpecifierKind::TypeSpec:
- case NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::SpecifierKind::TypeSpec: {
// FIXME: See comment below, on Super case.
if (K2 == NestedNameSpecifier::SpecifierKind::Super)
return Ctx.getCanonicalNestedNameSpecifier(NNS1);
- assert(K2 == NestedNameSpecifier::SpecifierKind::TypeSpec ||
- K2 == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate);
-
- // Only keep the template keyword if both sides have it.
- bool Template =
- K1 == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate &&
- K2 == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate;
+ assert(K2 == NestedNameSpecifier::SpecifierKind::TypeSpec);
const Type *T1 = NNS1->getAsType(), *T2 = NNS2->getAsType();
if (T1 == T2) {
@@ -13568,13 +13513,12 @@ static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx,
bool IsSame = isa<DependentTemplateSpecializationType>(T1);
NestedNameSpecifier *P =
::getCommonNNS(Ctx, NNS1->getPrefix(), NNS2->getPrefix(), IsSame);
- R = NestedNameSpecifier::Create(Ctx, P, Template, T1);
+ R = NestedNameSpecifier::Create(Ctx, P, T1);
break;
}
// TODO: Try to salvage the original prefix.
// If getCommonSugaredType removed any top level sugar, the original prefix
// is not applicable anymore.
- NestedNameSpecifier *P = nullptr;
const Type *T = Ctx.getCommonSugaredType(QualType(T1, 0), QualType(T2, 0),
/*Unqualified=*/true)
.getTypePtr();
@@ -13584,7 +13528,7 @@ static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx,
case Type::Elaborated: {
// An ElaboratedType is stripped off, it's Qualifier becomes the prefix.
auto *ET = cast<ElaboratedType>(T);
- R = NestedNameSpecifier::Create(Ctx, ET->getQualifier(), Template,
+ R = NestedNameSpecifier::Create(Ctx, ET->getQualifier(),
ET->getNamedType().getTypePtr());
break;
}
@@ -13599,16 +13543,17 @@ static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx,
// A DependentTemplateSpecializationType loses it's Qualifier, which
// is turned into the prefix.
auto *DTST = cast<DependentTemplateSpecializationType>(T);
- T = Ctx.getDependentTemplateSpecializationType(
- DTST->getKeyword(), /*NNS=*/nullptr, DTST->getIdentifier(),
- DTST->template_arguments())
+ const DependentTemplateStorage &DTN = DTST->getDependentTemplateName();
+ DependentTemplateStorage NewDTN(/*Qualifier=*/nullptr, DTN.getName(),
+ DTN.hasTemplateKeyword());
+ T = Ctx.getDependentTemplateSpecializationType(DTST->getKeyword(), NewDTN,
+ DTST->template_arguments())
.getTypePtr();
- P = DTST->getQualifier();
- R = NestedNameSpecifier::Create(Ctx, DTST->getQualifier(), Template, T);
+ R = NestedNameSpecifier::Create(Ctx, DTN.getQualifier(), T);
break;
}
default:
- R = NestedNameSpecifier::Create(Ctx, P, Template, T);
+ R = NestedNameSpecifier::Create(Ctx, /*Prefix=*/nullptr, T);
break;
}
break;
@@ -14051,19 +13996,22 @@ static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X,
assert(NX->getIdentifier() == NY->getIdentifier());
return Ctx.getDependentNameType(
getCommonTypeKeyword(NX, NY),
- getCommonQualifier(Ctx, NX, NY, /*IsSame=*/true), NX->getIdentifier(),
- NX->getCanonicalTypeInternal());
+ getCommonQualifier(Ctx, NX, NY, /*IsSame=*/true), NX->getIdentifier());
}
case Type::DependentTemplateSpecialization: {
const auto *TX = cast<DependentTemplateSpecializationType>(X),
*TY = cast<DependentTemplateSpecializationType>(Y);
- assert(TX->getIdentifier() == TY->getIdentifier());
auto As = getCommonTemplateArguments(Ctx, TX->template_arguments(),
TY->template_arguments());
+ const DependentTemplateStorage &SX = TX->getDependentTemplateName(),
+ &SY = TY->getDependentTemplateName();
+ assert(SX.getName() == SY.getName());
+ DependentTemplateStorage Name(
+ getCommonNNS(Ctx, SX.getQualifier(), SY.getQualifier(),
+ /*IsSame=*/true),
+ SX.getName(), SX.hasTemplateKeyword() || SY.hasTemplateKeyword());
return Ctx.getDependentTemplateSpecializationType(
- getCommonTypeKeyword(TX, TY),
- getCommonQualifier(Ctx, TX, TY, /*IsSame=*/true), TX->getIdentifier(),
- As);
+ getCommonTypeKeyword(TX, TY), Name, As);
}
case Type::UnaryTransform: {
const auto *TX = cast<UnaryTransformType>(X),
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 4e27f9d884a83..893160e8f5ba9 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1707,11 +1707,10 @@ ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
const DependentTemplateSpecializationType *T) {
- auto ToQualifierOrErr = import(T->getQualifier());
- if (!ToQualifierOrErr)
- return ToQualifierOrErr.takeError();
-
- IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
+ const DependentTemplateStorage &DTN = T->getDependentTemplateName();
+ auto QualifierOrErr = import(DTN.getQualifier());
+ if (!QualifierOrErr)
+ return QualifierOrErr.takeError();
SmallVector<TemplateArgument, 2> ToPack;
ToPack.reserve(T->template_arguments().size());
@@ -1719,7 +1718,10 @@ ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
return std::move(Err);
return Importer.getToContext().getDependentTemplateSpecializationType(
- T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
+ T->getKeyword(),
+ {*QualifierOrErr, Importer.Import(DTN.getName()),
+ DTN.hasTemplateKeyword()},
+ ToPack);
}
ExpectedType
@@ -1729,18 +1731,8 @@ ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
return ToQualifierOrErr.takeError();
IdentifierInfo *Name = Importer.Import(T->getIdentifier());
-
- QualType Canon;
- if (T != T->getCanonicalTypeInternal().getTypePtr()) {
- if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
- Canon = (*TyOrErr).getCanonicalType();
- else
- return TyOrErr.takeError();
- }
-
return Importer.getToContext().getDependentNameType(T->getKeyword(),
- *ToQualifierOrErr,
- Name, Canon);
+ *ToQualifierOrErr, Name);
}
ExpectedType
@@ -9790,12 +9782,8 @@ ASTImporter::Import(NestedNameSpecifier *FromNNS) {
return RDOrErr.takeError();
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
if (ExpectedTypePtr TyOrErr = Import(FromNNS->getAsType())) {
- bool TSTemplate =
- FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
- return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate,
- *TyOrErr);
+ return NestedNameSpecifier::Create(ToContext, Prefix, *TyOrErr);
} else {
return TyOrErr.takeError();
}
@@ -9853,21 +9841,13 @@ ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
ToLocalBeginLoc, ToLocalEndLoc);
break;
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
SourceLocation ToTLoc;
if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
return std::move(Err);
TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
- QualType(Spec->getAsType(), 0), ToTLoc);
- if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
- // ToLocalBeginLoc is here the location of the 'template' keyword.
- Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
- ToLocalEndLoc);
- else
- // No location for 'template' keyword here.
- Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
- ToLocalEndLoc);
+ QualType(Spec->getAsType(), 0), ToTLoc);
+ Builder.Extend(getToContext(), TSI->getTypeLoc(), ToLocalEndLoc);
break;
}
@@ -9936,14 +9916,8 @@ Expected<TemplateName> ASTImporter::Import(TemplateName From) {
auto QualifierOrErr = Import(DTN->getQualifier());
if (!QualifierOrErr)
return QualifierOrErr.takeError();
-
- if (DTN->isIdentifier()) {
- return ToContext.getDependentTemplateName(*QualifierOrErr,
- Import(DTN->getIdentifier()));
- }
-
- return ToContext.getDependentTemplateName(*QualifierOrErr,
- DTN->getOperator());
+ return ToContext.getDependentTemplateName(
+ {*QualifierOrErr, Import(DTN->getName()), DTN->hasTemplateKeyword()});
}
case TemplateName::SubstTemplateTemplateParm: {
@@ -10314,6 +10288,13 @@ IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
return ToId;
}
+IdentifierOrOverloadedOperator
+ASTImporter::Import(IdentifierOrOverloadedOperator FromIO) {
+ if (const IdentifierInfo *FromII = FromIO.getIdentifier())
+ return Import(FromII);
+ return FromIO.getOperator();
+}
+
Expected<Selector> ASTImporter::Import(Selector FromSel) {
if (FromSel.isNull())
return Selector{};
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp
index a4349bdaaf682..c769722521d9c 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -566,7 +566,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
return IsStructurallyEquivalent(Context, NNS1->getAsNamespaceAlias(),
NNS2->getAsNamespaceAlias());
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
return IsStructurallyEquivalent(Context, QualType(NNS1->getAsType(), 0),
QualType(NNS2->getAsType(), 0));
case NestedNameSpecifier::Global:
@@ -578,6 +577,19 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
return false;
}
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+ const DependentTemplateStorage &S1,
+ const DependentTemplateStorage &S2) {
+ if (!IsStructurallyEquivalent(Context, S1.getQualifier(), S2.getQualifier()))
+ return false;
+
+ IdentifierOrOverloadedOperator IO1 = S1.getName(), IO2 = S2.getName();
+ const IdentifierInfo *II1 = IO1.getIdentifier(), *II2 = IO2.getIdentifier();
+ if (!II1 || !II2)
+ return IO1.getOperator() == IO2.getOperator();
+ return IsStructurallyEquivalent(II1, II2);
+}
+
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
const TemplateName &N1,
const TemplateName &N2) {
@@ -614,19 +626,9 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
return TN1->getDeclName() == TN2->getDeclName();
}
- case TemplateName::DependentTemplate: {
- DependentTemplateName *DN1 = N1.getAsDependentTemplateName(),
- *DN2 = N2.getAsDependentTemplateName();
- if (!IsStructurallyEquivalent(Context, DN1->getQualifier(),
- DN2->getQualifier()))
- return false;
- if (DN1->isIdentifier() && DN2->isIdentifier())
- return IsStructurallyEquivalent(DN1->getIdentifier(),
- DN2->getIdentifier());
- else if (DN1->isOverloadedOperator() && DN2->isOverloadedOperator())
- return DN1->getOperator() == DN2->getOperator();
- return false;
- }
+ case TemplateName::DependentTemplate:
+ return IsStructurallyEquivalent(Context, *N1.getAsDependentTemplateName(),
+ *N2.getAsDependentTemplateName());
case TemplateName::SubstTemplateTemplateParmPack: {
SubstTemplateTemplateParmPackStorage
@@ -1315,11 +1317,10 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
case Type::DependentTemplateSpecialization: {
const auto *Spec1 = cast<DependentTemplateSpecializationType>(T1);
const auto *Spec2 = cast<DependentTemplateSpecializationType>(T2);
- if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(),
- Spec2->getQualifier()))
+ if (Spec1->getKeyword() != Spec2->getKeyword())
return false;
- if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
- Spec2->getIdentifier()))
+ if (!IsStructurallyEquivalent(Context, Spec1->getDependentTemplateName(),
+ Spec2->getDependentTemplateName()))
return false;
if (!IsStructurallyEquivalent(Context, Spec1->template_arguments(),
Spec2->template_arguments()))
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index 981cdb3c806b1..a81b06d2bba40 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -1327,7 +1327,7 @@ void CXXNameMangler::manglePrefix(QualType type) {
type->getAs<DependentTemplateSpecializationType>()) {
if (!mangleSubstitution(QualType(DTST, 0))) {
TemplateName Template = getASTContext().getDependentTemplateName(
- DTST->getQualifier(), DTST->getIdentifier());
+ DTST->getDependentTemplateName());
mangleTemplatePrefix(Template);
// FIXME: GCC does not appear to mangle the template arguments when
@@ -1395,8 +1395,7 @@ void CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
mangleSourceNameWithAbiTags(qualifier->getAsNamespaceAlias());
break;
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
const Type *type = qualifier->getAsType();
// We only want to use an unresolved-type encoding if this is one of:
@@ -2181,7 +2180,17 @@ void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
return;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
+ if (NestedNameSpecifier *Prefix = qualifier->getPrefix()) {
+ const auto *DTST =
+ cast<DependentTemplateSpecializationType>(qualifier->getAsType());
+ QualType NewT = getASTContext().getDependentTemplateSpecializationType(
+ DTST->getKeyword(),
+ {Prefix, DTST->getDependentTemplateName().getName(),
+ /*HasTemplateKeyword=*/true},
+ DTST->template_arguments());
+ manglePrefix(NewT);
+ return;
+ }
manglePrefix(QualType(qualifier->getAsType(), 0));
return;
@@ -2265,10 +2274,11 @@ void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
if (Clang11Compat && mangleSubstitution(Template))
return;
- if (const IdentifierInfo *Id = Dependent->getIdentifier())
+ if (IdentifierOrOverloadedOperator Name = Dependent->getName();
+ const IdentifierInfo *Id = Name.getIdentifier())
mangleSourceName(Id);
else
- mangleOperatorName(Dependent->getOperator(), UnknownArity);
+ mangleOperatorName(Name.getOperator(), UnknownArity);
addSubstitution(Template);
}
@@ -2376,12 +2386,13 @@ void CXXNameMangler::mangleType(TemplateName TN) {
case TemplateName::DependentTemplate: {
const DependentTemplateName *Dependent = TN.getAsDependentTemplateName();
- assert(Dependent->isIdentifier());
+ const IdentifierInfo *II = Dependent->getName().getIdentifier();
+ assert(II);
// <class-enum-type> ::= <name>
// <name> ::= <nested-name>
mangleUnresolvedPrefix(Dependent->getQualifier());
- mangleSourceName(Dependent->getIdentifier());
+ mangleSourceName(II);
break;
}
@@ -2572,8 +2583,8 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty,
const DependentTemplateSpecializationType *DTST =
cast<DependentTemplateSpecializationType>(Ty);
TemplateName Template = getASTContext().getDependentTemplateName(
- DTST->getQualifier(), DTST->getIdentifier());
- mangleSourceName(DTST->getIdentifier());
+ DTST->getDependentTemplateName());
+ mangleTemplatePrefix(Template);
mangleTemplateArgs(Template, DTST->template_arguments());
break;
}
@@ -4481,10 +4492,8 @@ void CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) {
// Dependently-scoped template types are nested if they have a prefix.
Out << 'N';
- // TODO: avoid making this TemplateName.
TemplateName Prefix =
- getASTContext().getDependentTemplateName(T->getQualifier(),
- T->getIdentifier());
+ getASTContext().getDependentTemplateName(T->getDependentTemplateName());
mangleTemplatePrefix(Prefix);
// FIXME: GCC does not appear to mangle the template arguments when
diff --git a/clang/lib/AST/NestedNameSpecifier.cpp b/clang/lib/AST/NestedNameSpecifier.cpp
index d3195e6487f0b..51aa2d69d0f0d 100644
--- a/clang/lib/AST/NestedNameSpecifier.cpp
+++ b/clang/lib/AST/NestedNameSpecifier.cpp
@@ -98,14 +98,13 @@ NestedNameSpecifier::Create(const ASTContext &Context,
return FindOrInsert(Context, Mockup);
}
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context,
- NestedNameSpecifier *Prefix,
- bool Template, const Type *T) {
+NestedNameSpecifier *NestedNameSpecifier::Create(const ASTContext &Context,
+ NestedNameSpecifier *Prefix,
+ const Type *T) {
assert(T && "Type cannot be NULL");
NestedNameSpecifier Mockup;
Mockup.Prefix.setPointer(Prefix);
- Mockup.Prefix.setInt(Template? StoredTypeSpecWithTemplate : StoredTypeSpec);
+ Mockup.Prefix.setInt(StoredTypeSpec);
Mockup.Specifier = const_cast<Type*>(T);
return FindOrInsert(Context, Mockup);
}
@@ -155,9 +154,6 @@ NestedNameSpecifier::SpecifierKind NestedNameSpecifier::getKind() const {
case StoredTypeSpec:
return TypeSpec;
-
- case StoredTypeSpecWithTemplate:
- return TypeSpecWithTemplate;
}
llvm_unreachable("Invalid NNS Kind!");
@@ -189,7 +185,6 @@ CXXRecordDecl *NestedNameSpecifier::getAsRecordDecl() const {
return dyn_cast<CXXRecordDecl>(static_cast<NamedDecl *>(Specifier));
case StoredTypeSpec:
- case StoredTypeSpecWithTemplate:
return getAsType()->getAsCXXRecordDecl();
}
@@ -222,9 +217,13 @@ NestedNameSpecifierDependence NestedNameSpecifier::getDependence() const {
return NestedNameSpecifierDependence::None;
}
- case TypeSpec:
- case TypeSpecWithTemplate:
- return toNestedNameSpecifierDependendence(getAsType()->getDependence());
+ case TypeSpec: {
+ NestedNameSpecifierDependence Dep =
+ toNestedNameSpecifierDependendence(getAsType()->getDependence());
+ if (NestedNameSpecifier *Prefix = getPrefix())
+ Dep |= Prefix->getDependence();
+ return Dep;
+ }
}
llvm_unreachable("Invalid NNS Kind!");
}
@@ -254,17 +253,17 @@ NestedNameSpecifier::translateToType(const ASTContext &Context) const {
.getDependentNameType(ElaboratedTypeKeyword::None, Prefix,
getAsIdentifier())
.getTypePtr();
- case SpecifierKind::TypeSpec:
- case SpecifierKind::TypeSpecWithTemplate: {
+ case SpecifierKind::TypeSpec: {
const Type *T = getAsType();
switch (T->getTypeClass()) {
case Type::DependentTemplateSpecialization: {
const auto *DT = cast<DependentTemplateSpecializationType>(T);
- // FIXME: The type node can't represent the template keyword.
+ const DependentTemplateStorage &DTN = DT->getDependentTemplateName();
return Context
- .getDependentTemplateSpecializationType(ElaboratedTypeKeyword::None,
- Prefix, DT->getIdentifier(),
- DT->template_arguments())
+ .getDependentTemplateSpecializationType(
+ ElaboratedTypeKeyword::None,
+ {Prefix, DTN.getName(), DTN.hasTemplateKeyword()},
+ DT->template_arguments())
.getTypePtr();
}
case Type::Record:
@@ -324,59 +323,11 @@ void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy,
OS << "__super";
break;
- case TypeSpecWithTemplate:
- OS << "template ";
- // Fall through to print the type.
- [[fallthrough]];
-
case TypeSpec: {
- const auto *Record =
- dyn_cast_or_null<ClassTemplateSpecializationDecl>(getAsRecordDecl());
- if (ResolveTemplateArguments && Record) {
- // Print the type trait with resolved template parameters.
- Record->printName(OS, Policy);
- printTemplateArgumentList(
- OS, Record->getTemplateArgs().asArray(), Policy,
- Record->getSpecializedTemplate()->getTemplateParameters());
- break;
- }
- const Type *T = getAsType();
-
PrintingPolicy InnerPolicy(Policy);
InnerPolicy.SuppressScope = true;
InnerPolicy.SuppressTagKeyword = true;
-
- // Nested-name-specifiers are intended to contain minimally-qualified
- // types. An actual ElaboratedType will not occur, since we'll store
- // just the type that is referred to in the nested-name-specifier (e.g.,
- // a TypedefType, TagType, etc.). However, when we are dealing with
- // dependent template-id types (e.g., Outer<T>::template Inner<U>),
- // the type requires its own nested-name-specifier for uniqueness, so we
- // suppress that nested-name-specifier during printing.
- assert(!isa<ElaboratedType>(T) &&
- "Elaborated type in nested-name-specifier");
- if (const TemplateSpecializationType *SpecType
- = dyn_cast<TemplateSpecializationType>(T)) {
- // Print the template name without its corresponding
- // nested-name-specifier.
- SpecType->getTemplateName().print(OS, InnerPolicy,
- TemplateName::Qualified::None);
-
- // Print the template argument list.
- printTemplateArgumentList(OS, SpecType->template_arguments(),
- InnerPolicy);
- } else if (const auto *DepSpecType =
- dyn_cast<DependentTemplateSpecializationType>(T)) {
- // Print the template name without its corresponding
- // nested-name-specifier.
- OS << DepSpecType->getIdentifier()->getName();
- // Print the template argument list.
- printTemplateArgumentList(OS, DepSpecType->template_arguments(),
- InnerPolicy);
- } else {
- // Print the type normally
- QualType(T, 0).print(OS, InnerPolicy);
- }
+ QualType(getAsType(), 0).print(OS, InnerPolicy);
break;
}
}
@@ -421,7 +372,6 @@ NestedNameSpecifierLoc::getLocalDataLength(NestedNameSpecifier *Qualifier) {
Length += sizeof(SourceLocation::UIntTy);
break;
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::TypeSpec:
// The "void*" that points at the TypeLoc data.
// Note: the 'template' keyword is part of the TypeLoc.
@@ -485,7 +435,6 @@ SourceRange NestedNameSpecifierLoc::getLocalSourceRange() const {
LoadSourceLocation(Data, Offset),
LoadSourceLocation(Data, Offset + sizeof(SourceLocation::UIntTy)));
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::TypeSpec: {
// The "void*" that points at the TypeLoc data.
// Note: the 'template' keyword is part of the TypeLoc.
@@ -500,8 +449,7 @@ SourceRange NestedNameSpecifierLoc::getLocalSourceRange() const {
}
TypeLoc NestedNameSpecifierLoc::getTypeLoc() const {
- if (Qualifier->getKind() != NestedNameSpecifier::TypeSpec &&
- Qualifier->getKind() != NestedNameSpecifier::TypeSpecWithTemplate)
+ if (Qualifier->getKind() != NestedNameSpecifier::TypeSpec)
return TypeLoc();
// The "void*" that points at the TypeLoc data.
@@ -609,13 +557,10 @@ operator=(const NestedNameSpecifierLocBuilder &Other) {
return *this;
}
-void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context,
- SourceLocation TemplateKWLoc,
- TypeLoc TL,
+void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context, TypeLoc TL,
SourceLocation ColonColonLoc) {
- Representation = NestedNameSpecifier::Create(Context, Representation,
- TemplateKWLoc.isValid(),
- TL.getTypePtr());
+ Representation =
+ NestedNameSpecifier::Create(Context, Representation, TL.getTypePtr());
// Push source-location info into the buffer.
SavePointer(TL.getOpaqueData(), Buffer, BufferSize, BufferCapacity);
@@ -697,8 +642,7 @@ void NestedNameSpecifierLocBuilder::MakeTrivial(ASTContext &Context,
SaveSourceLocation(R.getBegin(), Buffer, BufferSize, BufferCapacity);
break;
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
TypeSourceInfo *TSInfo
= Context.getTrivialTypeSourceInfo(QualType(NNS->getAsType(), 0),
R.getBegin());
diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp
index 4c428cce32475..f8446dfbc6859 100644
--- a/clang/lib/AST/ODRHash.cpp
+++ b/clang/lib/AST/ODRHash.cpp
@@ -128,7 +128,6 @@ void ODRHash::AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
AddDecl(NNS->getAsNamespaceAlias());
break;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
AddType(NNS->getAsType());
break;
case NestedNameSpecifier::Global:
@@ -137,6 +136,16 @@ void ODRHash::AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
}
}
+void ODRHash::AddDependentTemplateName(const DependentTemplateStorage &Name) {
+ if (NestedNameSpecifier *NNS = Name.getQualifier())
+ AddNestedNameSpecifier(NNS);
+ if (IdentifierOrOverloadedOperator IO = Name.getName();
+ const IdentifierInfo *II = IO.getIdentifier())
+ AddIdentifierInfo(II);
+ else
+ ID.AddInteger(IO.getOperator());
+}
+
void ODRHash::AddTemplateName(TemplateName Name) {
auto Kind = Name.getKind();
ID.AddInteger(Kind);
@@ -153,10 +162,13 @@ void ODRHash::AddTemplateName(TemplateName Name) {
AddTemplateName(QTN->getUnderlyingTemplate());
break;
}
+ case TemplateName::DependentTemplate: {
+ AddDependentTemplateName(*Name.getAsDependentTemplateName());
+ break;
+ }
// TODO: Support these cases.
case TemplateName::OverloadedTemplate:
case TemplateName::AssumedTemplate:
- case TemplateName::DependentTemplate:
case TemplateName::SubstTemplateTemplateParm:
case TemplateName::SubstTemplateTemplateParmPack:
case TemplateName::UsingTemplate:
@@ -1221,8 +1233,7 @@ class ODRTypeVisitor : public TypeVisitor<ODRTypeVisitor> {
void VisitDependentTemplateSpecializationType(
const DependentTemplateSpecializationType *T) {
- AddIdentifierInfo(T->getIdentifier());
- AddNestedNameSpecifier(T->getQualifier());
+ Hash.AddDependentTemplateName(T->getDependentTemplateName());
ID.AddInteger(T->template_arguments().size());
for (const auto &TA : T->template_arguments()) {
Hash.AddTemplateArgument(TA);
diff --git a/clang/lib/AST/QualTypeNames.cpp b/clang/lib/AST/QualTypeNames.cpp
index 3c814b777f8ab..d8ab1092d3ea4 100644
--- a/clang/lib/AST/QualTypeNames.cpp
+++ b/clang/lib/AST/QualTypeNames.cpp
@@ -212,6 +212,7 @@ static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
bool WithGlobalNsPrefix) {
switch (Scope->getKind()) {
case NestedNameSpecifier::Global:
+ case NestedNameSpecifier::Super:
// Already fully qualified
return Scope;
case NestedNameSpecifier::Namespace:
@@ -232,9 +233,7 @@ static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
// but use the name of it's prefix.
return getFullyQualifiedNestedNameSpecifier(
Ctx, Scope->getPrefix(), WithGlobalNsPrefix);
- case NestedNameSpecifier::Super:
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
const Type *Type = Scope->getAsType();
// Find decl context.
const TagDecl *TD = nullptr;
@@ -366,8 +365,7 @@ NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
}
return NestedNameSpecifier::Create(
- Ctx, createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),
- false /*No TemplateKeyword*/, TypePtr);
+ Ctx, createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix), TypePtr);
}
/// Return the fully qualified type, including fully-qualified
diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp
index 109cc3c4771ee..f8ba5a24c7519 100644
--- a/clang/lib/AST/TemplateName.cpp
+++ b/clang/lib/AST/TemplateName.cpp
@@ -124,6 +124,31 @@ void SubstTemplateTemplateParmPackStorage::Profile(
ID.AddBoolean(Final);
}
+IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
+ const IdentifierInfo *II)
+ : PtrOrOp(reinterpret_cast<uintptr_t>(II)) {
+ static_assert(NUM_OVERLOADED_OPERATORS <= 4096,
+ "NUM_OVERLOADED_OPERATORS is too large");
+ assert(II);
+ assert(getIdentifier() == II);
+}
+IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
+ OverloadedOperatorKind OOK)
+ : PtrOrOp(-uintptr_t(OOK)) {
+ assert(OOK != OO_None);
+ assert(getOperator() == OOK);
+}
+
+void IdentifierOrOverloadedOperator::Profile(llvm::FoldingSetNodeID &ID) const {
+ if (auto *Identifier = getIdentifier()) {
+ ID.AddBoolean(false);
+ ID.AddPointer(Identifier);
+ } else {
+ ID.AddBoolean(true);
+ ID.AddInteger(getOperator());
+ }
+}
+
TemplateName::TemplateName(void *Ptr) {
Storage = StorageType::getFromOpaqueValue(Ptr);
}
@@ -277,6 +302,36 @@ UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const {
return nullptr;
}
+DependentTemplateStorage::DependentTemplateStorage(
+ NestedNameSpecifier *Qualifier, IdentifierOrOverloadedOperator Name,
+ bool HasTemplateKeyword)
+ : Qualifier(Qualifier, HasTemplateKeyword), Name(Name) {
+ assert((!Qualifier || Qualifier->isDependent()) &&
+ "Qualifier must be dependent");
+}
+
+TemplateNameDependence DependentTemplateStorage::getDependence() const {
+ auto D = TemplateNameDependence::DependentInstantiation;
+ if (NestedNameSpecifier *Qualifier = getQualifier())
+ D |= toTemplateNameDependence(Qualifier->getDependence());
+ return D;
+}
+
+void DependentTemplateStorage::print(raw_ostream &OS,
+ const PrintingPolicy &Policy) const {
+ if (NestedNameSpecifier *NNS = getQualifier())
+ NNS->print(OS, Policy);
+
+ if (hasTemplateKeyword())
+ OS << "template ";
+
+ IdentifierOrOverloadedOperator Name = getName();
+ if (const IdentifierInfo *II = Name.getIdentifier())
+ OS << II->getName();
+ else
+ OS << "operator " << getOperatorSpelling(Name.getOperator());
+}
+
DeducedTemplateStorage *TemplateName::getAsDeducedTemplateName() const {
if (UncommonTemplateNameStorage *Uncommon =
dyn_cast_if_present<UncommonTemplateNameStorage *>(Storage))
@@ -315,7 +370,8 @@ TemplateNameDependence TemplateName::getDependence() const {
case NameKind::DependentTemplate: {
DependentTemplateName *S = getAsDependentTemplateName();
auto D = TemplateNameDependence::DependentInstantiation;
- D |= toTemplateNameDependence(S->getQualifier()->getDependence());
+ if (NestedNameSpecifier *Qualifier = S->getQualifier())
+ D |= toTemplateNameDependence(Qualifier->getDependence());
return D;
}
case NameKind::SubstTemplateTemplateParm: {
@@ -403,14 +459,7 @@ void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
else
OS << *UTD;
} else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
- if (NestedNameSpecifier *NNS = DTN->getQualifier())
- NNS->print(OS, Policy);
- OS << "template ";
-
- if (DTN->isIdentifier())
- OS << DTN->getIdentifier()->getName();
- else
- OS << "operator " << getOperatorSpelling(DTN->getOperator());
+ DTN->print(OS, Policy);
} else if (SubstTemplateTemplateParmStorage *subst =
getAsSubstTemplateTemplateParm()) {
subst->getReplacement().print(OS, Policy, Qual);
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 02373e8072536..d35b2f5d9ab6d 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -1027,10 +1027,6 @@ void clang::TextNodeDumper::dumpNestedNameSpecifier(const NestedNameSpecifier *N
OS << " TypeSpec";
dumpType(QualType(NNS->getAsType(), 0));
break;
- case NestedNameSpecifier::TypeSpecWithTemplate:
- OS << " TypeSpecWithTemplate";
- dumpType(QualType(NNS->getAsType(), 0));
- break;
case NestedNameSpecifier::Global:
OS << " Global";
break;
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index c47096839e101..4669bf5541493 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -3270,16 +3270,13 @@ StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
}
DependentTemplateSpecializationType::DependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
- const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args, QualType Canon)
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgument> Args, QualType Canon)
: TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon,
- TypeDependence::DependentInstantiation |
- (NNS ? toTypeDependence(NNS->getDependence())
- : TypeDependence::None)),
- NNS(NNS), Name(Name) {
+
+ toTypeDependence(Name.getDependence())),
+ Name(Name) {
DependentTemplateSpecializationTypeBits.NumArgs = Args.size();
- assert((!NNS || NNS->isDependent()) &&
- "DependentTemplateSpecializatonType requires dependent qualifier");
auto *ArgBuffer = const_cast<TemplateArgument *>(template_arguments().data());
for (const TemplateArgument &Arg : Args) {
addDependence(toTypeDependence(Arg.getDependence() &
@@ -3289,16 +3286,12 @@ DependentTemplateSpecializationType::DependentTemplateSpecializationType(
}
}
-void
-DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
- const ASTContext &Context,
- ElaboratedTypeKeyword Keyword,
- NestedNameSpecifier *Qualifier,
- const IdentifierInfo *Name,
- ArrayRef<TemplateArgument> Args) {
+void DependentTemplateSpecializationType::Profile(
+ llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgument> Args) {
ID.AddInteger(llvm::to_underlying(Keyword));
- ID.AddPointer(Qualifier);
- ID.AddPointer(Name);
+ Name.Profile(ID);
for (const TemplateArgument &Arg : Args)
Arg.Profile(ID, Context);
}
diff --git a/clang/lib/AST/TypeLoc.cpp b/clang/lib/AST/TypeLoc.cpp
index fbb7fc5cd7690..24726901b8f55 100644
--- a/clang/lib/AST/TypeLoc.cpp
+++ b/clang/lib/AST/TypeLoc.cpp
@@ -569,9 +569,10 @@ void
DependentTemplateSpecializationTypeLoc::initializeLocal(ASTContext &Context,
SourceLocation Loc) {
setElaboratedKeywordLoc(Loc);
- if (getTypePtr()->getQualifier()) {
+ if (NestedNameSpecifier *Qualifier =
+ getTypePtr()->getDependentTemplateName().getQualifier()) {
NestedNameSpecifierLocBuilder Builder;
- Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
+ Builder.MakeTrivial(Context, Qualifier, Loc);
setQualifierLoc(Builder.getWithLocInContext(Context));
} else {
setQualifierLoc(NestedNameSpecifierLoc());
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index 3982ca3b50604..4ec252e3f89b5 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -1793,9 +1793,7 @@ void TypePrinter::printDependentTemplateSpecializationBefore(
if (T->getKeyword() != ElaboratedTypeKeyword::None)
OS << " ";
- if (T->getQualifier())
- T->getQualifier()->print(OS, Policy);
- OS << "template " << T->getIdentifier()->getName();
+ T->getDependentTemplateName().print(OS, Policy);
printTemplateArgumentList(OS, T->template_arguments(), Policy);
spaceBeforePlaceHolder(OS);
}
@@ -2498,14 +2496,18 @@ void clang::printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgument> Args,
const PrintingPolicy &Policy,
const TemplateParameterList *TPL) {
- printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
+ PrintingPolicy InnerPolicy = Policy;
+ InnerPolicy.SuppressScope = false;
+ printTo(OS, Args, InnerPolicy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
}
void clang::printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgumentLoc> Args,
const PrintingPolicy &Policy,
const TemplateParameterList *TPL) {
- printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
+ PrintingPolicy InnerPolicy = Policy;
+ InnerPolicy.SuppressScope = false;
+ printTo(OS, Args, InnerPolicy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
}
std::string Qualifiers::getAsString() const {
diff --git a/clang/lib/ExtractAPI/DeclarationFragments.cpp b/clang/lib/ExtractAPI/DeclarationFragments.cpp
index 480e33f607bb0..d7eebcbc3c2f9 100644
--- a/clang/lib/ExtractAPI/DeclarationFragments.cpp
+++ b/clang/lib/ExtractAPI/DeclarationFragments.cpp
@@ -249,13 +249,6 @@ DeclarationFragmentsBuilder::getFragmentsForNNS(const NestedNameSpecifier *NNS,
Fragments.append("__super", DeclarationFragments::FragmentKind::Keyword);
break;
- case NestedNameSpecifier::TypeSpecWithTemplate:
- // A type prefixed by the `template` keyword.
- Fragments.append("template", DeclarationFragments::FragmentKind::Keyword);
- Fragments.appendSpace();
- // Fallthrough after adding the keyword to handle the actual type.
- [[fallthrough]];
-
case NestedNameSpecifier::TypeSpec: {
const Type *T = NNS->getAsType();
// FIXME: Handle C++ template specialization type
diff --git a/clang/lib/Index/IndexTypeSourceInfo.cpp b/clang/lib/Index/IndexTypeSourceInfo.cpp
index d5d0a3c422871..98b5513128fbe 100644
--- a/clang/lib/Index/IndexTypeSourceInfo.cpp
+++ b/clang/lib/Index/IndexTypeSourceInfo.cpp
@@ -277,7 +277,6 @@ void IndexingContext::indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
break;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
indexTypeLoc(NNS.getTypeLoc(), Parent, DC);
break;
}
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
index 26be78ee8ca15..941e681247de1 100644
--- a/clang/lib/Parse/ParseExprCXX.cpp
+++ b/clang/lib/Parse/ParseExprCXX.cpp
@@ -587,12 +587,12 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
<< II.getName()
<< FixItHint::CreateInsertion(Tok.getLocation(), "template ");
}
-
- SourceLocation TemplateNameLoc = ConsumeToken();
+ ConsumeToken();
TemplateNameKind TNK = Actions.ActOnTemplateName(
- getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,
- EnteringContext, Template, /*AllowInjectedClassName*/ true);
+ getCurScope(), SS, /*TemplateKWLoc=*/SourceLocation(), TemplateName,
+ ObjectType, EnteringContext, Template,
+ /*AllowInjectedClassName=*/true);
if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
TemplateName, false))
return true;
diff --git a/clang/lib/Sema/DeclSpec.cpp b/clang/lib/Sema/DeclSpec.cpp
index 95e14ca0fa3b7..ee5a862c32509 100644
--- a/clang/lib/Sema/DeclSpec.cpp
+++ b/clang/lib/Sema/DeclSpec.cpp
@@ -48,9 +48,9 @@ void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
EndLocation = TemplateId->RAngleLoc;
}
-void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
- TypeLoc TL, SourceLocation ColonColonLoc) {
- Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
+void CXXScopeSpec::Extend(ASTContext &Context, TypeLoc TL,
+ SourceLocation ColonColonLoc) {
+ Builder.Extend(Context, TL, ColonColonLoc);
if (Range.getBegin().isInvalid())
Range.setBegin(TL.getBeginLoc());
Range.setEnd(ColonColonLoc);
diff --git a/clang/lib/Sema/HeuristicResolver.cpp b/clang/lib/Sema/HeuristicResolver.cpp
index 4544d75ea73c4..f6ee000a58f4b 100644
--- a/clang/lib/Sema/HeuristicResolver.cpp
+++ b/clang/lib/Sema/HeuristicResolver.cpp
@@ -365,9 +365,10 @@ HeuristicResolverImpl::resolveDependentNameType(const DependentNameType *DNT) {
std::vector<const NamedDecl *>
HeuristicResolverImpl::resolveTemplateSpecializationType(
const DependentTemplateSpecializationType *DTST) {
+ const DependentTemplateStorage &DTN = DTST->getDependentTemplateName();
return resolveDependentMember(
- resolveNestedNameSpecifierToType(DTST->getQualifier()),
- DTST->getIdentifier(), TemplateFilter);
+ resolveNestedNameSpecifierToType(DTN.getQualifier()),
+ DTN.getName().getIdentifier(), TemplateFilter);
}
std::vector<const NamedDecl *>
@@ -409,7 +410,6 @@ QualType HeuristicResolverImpl::resolveNestedNameSpecifierToType(
// the TypeSpec cases too.
switch (NNS->getKind()) {
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
return QualType(NNS->getAsType(), 0);
case NestedNameSpecifier::Identifier: {
return resolveDeclsToType(
diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp
index f04f7f9929442..545da5c295832 100644
--- a/clang/lib/Sema/SemaCXXScopeSpec.cpp
+++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp
@@ -145,8 +145,7 @@ DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
case NestedNameSpecifier::NamespaceAlias:
return NNS->getAsNamespaceAlias()->getNamespace();
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
+ case NestedNameSpecifier::TypeSpec: {
const TagType *Tag = NNS->getAsType()->getAs<TagType>();
assert(Tag && "Non-tag type in nested-name-specifier");
return Tag->getDecl();
@@ -687,8 +686,7 @@ bool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier");
}
- SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
- IdInfo.CCLoc);
+ SS.Extend(Context, TLB.getTypeLocInContext(Context, T), IdInfo.CCLoc);
return false;
}
@@ -735,8 +733,8 @@ bool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
QualType T = Context.getTypeDeclType(ContainingClass);
TypeLocBuilder TLB;
TLB.pushTrivial(Context, T, IdInfo.IdentifierLoc);
- SS.Extend(Context, /*TemplateKWLoc=*/SourceLocation(),
- TLB.getTypeLocInContext(Context, T), IdInfo.IdentifierLoc);
+ SS.Extend(Context, TLB.getTypeLocInContext(Context, T),
+ IdInfo.IdentifierLoc);
// Add the identifier to form a dependent name.
SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc,
IdInfo.CCLoc);
@@ -804,8 +802,7 @@ bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
DecltypeTL.setDecltypeLoc(DS.getTypeSpecTypeLoc());
DecltypeTL.setRParenLoc(DS.getTypeofParensRange().getEnd());
- SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
- ColonColonLoc);
+ SS.Extend(Context, TLB.getTypeLocInContext(Context, T), ColonColonLoc);
return false;
}
@@ -827,8 +824,7 @@ bool Sema::ActOnCXXNestedNameSpecifierIndexedPack(CXXScopeSpec &SS,
DS.getBeginLoc());
PackIndexingTypeLoc PIT = TLB.push<PackIndexingTypeLoc>(Type);
PIT.setEllipsisLoc(DS.getEllipsisLoc());
- SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, Type),
- ColonColonLoc);
+ SS.Extend(Context, TLB.getTypeLocInContext(Context, Type), ColonColonLoc);
return false;
}
@@ -862,12 +858,14 @@ bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
translateTemplateArguments(TemplateArgsIn, TemplateArgs);
DependentTemplateName *DTN = Template.getAsDependentTemplateName();
- if (DTN && DTN->isIdentifier()) {
+ if (DTN && DTN->getName().getIdentifier()) {
// Handle a dependent template specialization for which we cannot resolve
// the template name.
assert(DTN->getQualifier() == SS.getScopeRep());
QualType T = Context.getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword::None, DTN->getQualifier(), DTN->getIdentifier(),
+ ElaboratedTypeKeyword::None,
+ {/*Qualifier=*/nullptr, DTN->getName().getIdentifier(),
+ TemplateKWLoc.isValid()},
TemplateArgs.arguments());
// Create source-location information for this type.
@@ -875,7 +873,6 @@ bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
DependentTemplateSpecializationTypeLoc SpecTL
= Builder.push<DependentTemplateSpecializationTypeLoc>(T);
SpecTL.setElaboratedKeywordLoc(SourceLocation());
- SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateNameLoc);
SpecTL.setLAngleLoc(LAngleLoc);
@@ -883,8 +880,7 @@ bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
- SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
- CCLoc);
+ SS.Extend(Context, Builder.getTypeLocInContext(Context, T), CCLoc);
return false;
}
@@ -932,9 +928,7 @@ bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
-
- SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
- CCLoc);
+ SS.Extend(Context, Builder.getTypeLocInContext(Context, T), CCLoc);
return false;
}
@@ -1007,7 +1001,6 @@ bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::Super:
// These are never namespace scopes.
return true;
diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp
index db4ddfeaccdc2..44a49a6e3148e 100644
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -755,7 +755,7 @@ getRequiredQualification(ASTContext &Context, const DeclContext *CurContext,
Result = NestedNameSpecifier::Create(Context, Result, Namespace);
} else if (const auto *TD = dyn_cast<TagDecl>(Parent))
Result = NestedNameSpecifier::Create(
- Context, Result, false, Context.getTypeDeclType(TD).getTypePtr());
+ Context, Result, Context.getTypeDeclType(TD).getTypePtr());
}
return Result;
}
@@ -1216,7 +1216,7 @@ void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
R.Qualifier = NestedNameSpecifier::Create(
- SemaRef.Context, nullptr, false,
+ SemaRef.Context, nullptr,
SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
else
R.QualifierIsInformative = false;
@@ -1405,7 +1405,7 @@ void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
else if (const auto *Tag = dyn_cast<TagDecl>(Ctx))
R.Qualifier = NestedNameSpecifier::Create(
- SemaRef.Context, nullptr, false,
+ SemaRef.Context, nullptr,
SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
else
R.QualifierIsInformative = false;
diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp
index 53536b0d14037..6f873cafa98fd 100644
--- a/clang/lib/Sema/SemaCoroutine.cpp
+++ b/clang/lib/Sema/SemaCoroutine.cpp
@@ -116,8 +116,7 @@ static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
auto buildElaboratedType = [&]() {
auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, S.getStdNamespace());
- NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
- CoroTrait.getTypePtr());
+ NNS = NestedNameSpecifier::Create(S.Context, NNS, CoroTrait.getTypePtr());
return S.Context.getElaboratedType(ElaboratedTypeKeyword::None, NNS,
PromiseType);
};
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index ed3c8ed4194ae..4d4762ae1581d 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -252,8 +252,8 @@ static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
S.Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
ASTContext &Context = S.Context;
- auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
- cast<Type>(Context.getRecordType(RD)));
+ auto *NNS = NestedNameSpecifier::Create(
+ Context, nullptr, cast<Type>(Context.getRecordType(RD)));
QualType T =
Context.getDependentNameType(ElaboratedTypeKeyword::Typename, NNS, &II);
@@ -580,10 +580,10 @@ synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
auto *ND = dyn_cast<NamespaceDecl>(DC);
if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
return NestedNameSpecifier::Create(Context, nullptr, ND);
- else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
- return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
+ if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
+ return NestedNameSpecifier::Create(Context, nullptr,
RD->getTypeForDecl());
- else if (isa<TranslationUnitDecl>(DC))
+ if (isa<TranslationUnitDecl>(DC))
return NestedNameSpecifier::GlobalSpecifier(Context);
}
llvm_unreachable("something isn't in TU scope?");
@@ -624,8 +624,7 @@ ParsedType Sema::ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
findRecordWithDependentBasesOfEnclosingMethod(CurContext)) {
// Build a DependentNameType that will perform lookup into RD at
// instantiation time.
- NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
- RD->getTypeForDecl());
+ NNS = NestedNameSpecifier::Create(Context, nullptr, RD->getTypeForDecl());
// Diagnose that this identifier was undeclared, and retry the lookup during
// template instantiation.
@@ -6243,11 +6242,12 @@ bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
do {
- if (SpecLoc.getNestedNameSpecifier()->getKind() ==
- NestedNameSpecifier::TypeSpecWithTemplate)
- Diag(Loc, diag::ext_template_after_declarative_nns)
- << FixItHint::CreateRemoval(
- SpecLoc.getTypeLoc().getTemplateKeywordLoc());
+ if (TypeLoc TL = SpecLoc.getTypeLoc()) {
+ if (SourceLocation TemplateKeywordLoc = TL.getTemplateKeywordLoc();
+ TemplateKeywordLoc.isValid())
+ Diag(Loc, diag::ext_template_after_declarative_nns)
+ << FixItHint::CreateRemoval(TemplateKeywordLoc);
+ }
if (const Type *T = SpecLoc.getNestedNameSpecifier()->getAsType()) {
if (const auto *TST = T->getAsAdjusted<TemplateSpecializationType>()) {
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 676d53a1f4b45..a557d32b8df05 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -14795,8 +14795,7 @@ buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
CXXScopeSpec SS;
const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
SS.MakeTrivial(S.Context,
- NestedNameSpecifier::Create(S.Context, nullptr, false,
- CanonicalT),
+ NestedNameSpecifier::Create(S.Context, nullptr, CanonicalT),
Loc);
// Create the reference to operator=.
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 48dab1c1c94a8..3025f04927734 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -2684,7 +2684,7 @@ recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
// perform name lookup during template instantiation.
CXXScopeSpec SS;
auto *NNS =
- NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl());
+ NestedNameSpecifier::Create(Context, nullptr, RD->getTypeForDecl());
SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
return DependentScopeDeclRefExpr::Create(
Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 8c0dd6ea749c0..47f5ed66445d8 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -508,7 +508,6 @@ bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
switch (SS.getScopeRep()->getKind()) {
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
// Per C++11 [over.literal]p2, literal operators can only be declared at
// namespace scope. Therefore, this unqualified-id cannot name anything.
// Reject it early, because we have no AST representation for this in the
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index 876340010cf5f..a77ca779a9ee3 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -4530,7 +4530,6 @@ static void getNestedNameSpecifierIdentifiers(
II = NNS->getAsNamespaceAlias()->getIdentifier();
break;
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::TypeSpec:
II = QualType(NNS->getAsType(), 0).getBaseTypeIdentifier();
break;
@@ -4895,8 +4894,7 @@ TypoCorrectionConsumer::NamespaceSpecifierSet::buildNestedNameSpecifier(
NNS = NestedNameSpecifier::Create(Context, NNS, ND);
++NumSpecifiers;
} else if (auto *RD = dyn_cast_or_null<RecordDecl>(C)) {
- NNS = NestedNameSpecifier::Create(Context, NNS, RD->isTemplateDecl(),
- RD->getTypeForDecl());
+ NNS = NestedNameSpecifier::Create(Context, NNS, RD->getTypeForDecl());
++NumSpecifiers;
}
}
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 3928d93a9abf7..3d880125765f6 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -364,8 +364,8 @@ bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
// The code is missing a 'template' keyword prior to the dependent template
// name.
NestedNameSpecifier *Qualifier = (NestedNameSpecifier *)SS->getScopeRep();
- SuggestedTemplate
- = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
+ SuggestedTemplate = TemplateTy::make(Context.getDependentTemplateName(
+ {Qualifier, &II, /*HasTemplateKeyword=*/false}));
Diag(IILoc, diag::err_template_kw_missing)
<< SuggestedTemplate.get()
<< FixItHint::CreateInsertion(IILoc, "template ");
@@ -2776,7 +2776,8 @@ TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
// Look one step prior in a dependent template specialization type.
if (const DependentTemplateSpecializationType *DependentTST
= T->getAs<DependentTemplateSpecializationType>()) {
- if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
+ if (NestedNameSpecifier *NNS =
+ DependentTST->getDependentTemplateName().getQualifier())
T = QualType(NNS->getAsType(), 0);
else
T = QualType();
@@ -3481,14 +3482,13 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
TemplateArgumentListInfo &TemplateArgs) {
DependentTemplateName *DTN =
Name.getUnderlying().getAsDependentTemplateName();
- if (DTN && DTN->isIdentifier())
+ if (DTN && DTN->getName().getIdentifier())
// When building a template-id where the template-name is dependent,
// assume the template is a type template. Either our assumption is
// correct, or the code is ill-formed and will be diagnosed when the
// dependent name is substituted.
return Context.getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword::None, DTN->getQualifier(), DTN->getIdentifier(),
- TemplateArgs.arguments());
+ ElaboratedTypeKeyword::None, *DTN, TemplateArgs.arguments());
if (Name.getAsAssumedTemplateName() &&
resolveAssumedTemplateNameAsType(/*Scope=*/nullptr, Name, TemplateLoc))
@@ -3817,8 +3817,7 @@ TypeResult Sema::ActOnTemplateIdType(
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
assert(SS.getScopeRep() == DTN->getQualifier());
QualType T = Context.getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword::None, DTN->getQualifier(), DTN->getIdentifier(),
- TemplateArgs.arguments());
+ ElaboratedTypeKeyword::None, *DTN, TemplateArgs.arguments());
// Build type-source information.
TypeLocBuilder TLB;
DependentTemplateSpecializationTypeLoc SpecTL
@@ -3887,8 +3886,7 @@ TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
assert(SS.getScopeRep() == DTN->getQualifier());
QualType T = Context.getDependentTemplateSpecializationType(
- Keyword, DTN->getQualifier(), DTN->getIdentifier(),
- TemplateArgs.arguments());
+ Keyword, *DTN, TemplateArgs.arguments());
// Build type-source information.
TypeLocBuilder TLB;
@@ -4808,13 +4806,14 @@ TemplateNameKind Sema::ActOnTemplateName(Scope *S,
switch (Name.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
- Result = TemplateTy::make(
- Context.getDependentTemplateName(Qualifier, Name.Identifier));
+ Result = TemplateTy::make(Context.getDependentTemplateName(
+ {Qualifier, Name.Identifier, TemplateKWLoc.isValid()}));
return TNK_Dependent_template_name;
case UnqualifiedIdKind::IK_OperatorFunctionId:
Result = TemplateTy::make(Context.getDependentTemplateName(
- Qualifier, Name.OperatorFunctionId.Operator));
+ {Qualifier, Name.OperatorFunctionId.Operator,
+ TemplateKWLoc.isValid()}));
return TNK_Function_template;
case UnqualifiedIdKind::IK_LiteralOperatorId:
@@ -5328,7 +5327,7 @@ bool Sema::CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &ArgLoc,
// know that we need a non-type template argument, convert this
// template name into an expression.
- DeclarationNameInfo NameInfo(DTN->getIdentifier(),
+ DeclarationNameInfo NameInfo(DTN->getName().getIdentifier(),
ArgLoc.getTemplateNameLoc());
CXXScopeSpec SS;
@@ -6067,8 +6066,9 @@ bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
const DependentTemplateSpecializationType* T) {
- if (auto *Q = T->getQualifier())
+ if (auto *Q = T->getDependentTemplateName().getQualifier())
return VisitNestedNameSpecifier(Q);
+
return false;
}
@@ -6150,7 +6150,6 @@ bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
return false;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
return Visit(QualType(NNS->getAsType(), 0));
}
llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
@@ -7522,9 +7521,8 @@ ExprResult Sema::BuildExpressionFromDeclTemplateArgument(
isa<IndirectFieldDecl>(VD)));
QualType ClassType
= Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
- NestedNameSpecifier *Qualifier
- = NestedNameSpecifier::Create(Context, nullptr, false,
- ClassType.getTypePtr());
+ NestedNameSpecifier *Qualifier =
+ NestedNameSpecifier::Create(Context, nullptr, ClassType.getTypePtr());
SS.MakeTrivial(Context, Qualifier, Loc);
}
@@ -10690,15 +10688,14 @@ Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
assert(DTN && "dependent template has non-dependent name?");
assert(DTN->getQualifier() == SS.getScopeRep());
- if (!DTN->isIdentifier()) {
+ if (!DTN->getName().getIdentifier()) {
Diag(TemplateIILoc, diag::err_template_id_not_a_type) << Template;
NoteAllFoundTemplates(Template);
return true;
}
QualType T = Context.getDependentTemplateSpecializationType(
- ElaboratedTypeKeyword::Typename, DTN->getQualifier(),
- DTN->getIdentifier(), TemplateArgs.arguments());
+ ElaboratedTypeKeyword::Typename, *DTN, TemplateArgs.arguments());
// Create source-location information for this type.
TypeLocBuilder Builder;
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 6398778dcb77f..0351b756be846 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -7033,7 +7033,8 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
const DependentTemplateSpecializationType *Spec
= cast<DependentTemplateSpecializationType>(T);
- MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
+ MarkUsedTemplateParameters(Ctx,
+ Spec->getDependentTemplateName().getQualifier(),
OnlyDeduced, Depth, Used);
for (const auto &Arg : Spec->template_arguments())
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 7b29f06373d32..51f361cb46279 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -705,7 +705,7 @@ class TreeTransform {
QualType TransformDependentTemplateSpecializationType(
TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
- NestedNameSpecifierLoc QualifierLoc);
+ CXXScopeSpec &SS);
/// Transforms the parameters of a function type into the
/// given vectors.
@@ -1132,38 +1132,21 @@ class TreeTransform {
/// nested-name-specifier and the given type. Subclasses may override
/// this routine to provide different behavior.
QualType RebuildDependentTemplateSpecializationType(
- ElaboratedTypeKeyword Keyword,
- NestedNameSpecifierLoc QualifierLoc,
- SourceLocation TemplateKWLoc,
- const IdentifierInfo *Name,
- SourceLocation NameLoc,
- TemplateArgumentListInfo &Args,
- bool AllowInjectedClassName) {
- // Rebuild the template name.
- // TODO: avoid TemplateName abstraction
- CXXScopeSpec SS;
- SS.Adopt(QualifierLoc);
- TemplateName InstName = getDerived().RebuildTemplateName(
- SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
- AllowInjectedClassName);
-
- if (InstName.isNull())
- return QualType();
-
+ ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+ SourceLocation TemplateKWLoc, TemplateName Name, SourceLocation NameLoc,
+ TemplateArgumentListInfo &Args, bool AllowInjectedClassName) {
// If it's still dependent, make a dependent specialization.
- if (InstName.getAsDependentTemplateName())
+ if (const DependentTemplateStorage *S = Name.getAsDependentTemplateName())
return SemaRef.Context.getDependentTemplateSpecializationType(
- Keyword, QualifierLoc.getNestedNameSpecifier(), Name,
- Args.arguments());
+ Keyword, *S, Args.arguments());
// Otherwise, make an elaborated type wrapping a non-dependent
// specialization.
QualType T =
- getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
+ getDerived().RebuildTemplateSpecializationType(Name, NameLoc, Args);
if (T.isNull())
return QualType();
- return SemaRef.Context.getElaboratedType(
- Keyword, QualifierLoc.getNestedNameSpecifier(), T);
+ return SemaRef.Context.getElaboratedType(Keyword, NNS, T);
}
/// Build a new typename type that refers to an identifier.
@@ -1332,6 +1315,13 @@ class TreeTransform {
SourceLocation NameLoc, QualType ObjectType,
bool AllowInjectedClassName);
+ TemplateName RebuildTemplateName(CXXScopeSpec &SS,
+ SourceLocation TemplateKWLoc,
+ IdentifierOrOverloadedOperator IO,
+ SourceLocation NameLoc, QualType ObjectType,
+ NamedDecl *FirstQualifierInScope,
+ bool AllowInjectedClassName);
+
/// Build a new template name given a template template parameter pack
/// and the
///
@@ -4634,7 +4624,6 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
break;
}
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::TypeSpec: {
TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
FirstQualifierInScope, SS);
@@ -4654,8 +4643,7 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
TL = ETL.getNamedTypeLoc();
}
- SS.Extend(SemaRef.Context, TL.getTemplateKeywordLoc(), TL,
- Q.getLocalEndLoc());
+ SS.Extend(SemaRef.Context, TL, Q.getLocalEndLoc());
break;
}
// If the nested-name-specifier is an invalid type def, don't emit an
@@ -4753,6 +4741,22 @@ ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
llvm_unreachable("Unknown name kind.");
}
+template <typename Derived>
+TemplateName TreeTransform<Derived>::RebuildTemplateName(
+ CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
+ IdentifierOrOverloadedOperator IO, SourceLocation NameLoc,
+ QualType ObjectType, NamedDecl *FirstQualifierInScope,
+ bool AllowInjectedClassName) {
+ if (const IdentifierInfo *II = IO.getIdentifier()) {
+ return getDerived().RebuildTemplateName(SS, TemplateKWLoc, *II, NameLoc,
+ ObjectType, FirstQualifierInScope,
+ AllowInjectedClassName);
+ }
+ return getDerived().RebuildTemplateName(SS, TemplateKWLoc, IO.getOperator(),
+ NameLoc, ObjectType,
+ AllowInjectedClassName);
+}
+
template<typename Derived>
TemplateName
TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
@@ -4794,20 +4798,9 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
// FIXME: Preserve the location of the "template" keyword.
SourceLocation TemplateKWLoc = NameLoc;
-
- if (DTN->isIdentifier()) {
- return getDerived().RebuildTemplateName(SS,
- TemplateKWLoc,
- *DTN->getIdentifier(),
- NameLoc,
- ObjectType,
- FirstQualifierInScope,
- AllowInjectedClassName);
- }
-
- return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
- DTN->getOperator(), NameLoc,
- ObjectType, AllowInjectedClassName);
+ return getDerived().RebuildTemplateName(
+ SS, TemplateKWLoc, DTN->getName(), NameLoc, ObjectType,
+ FirstQualifierInScope, AllowInjectedClassName);
}
// FIXME: Try to preserve more of the TemplateName.
@@ -5401,13 +5394,14 @@ TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
DependentTemplateSpecializationTypeLoc SpecTL =
TL.castAs<DependentTemplateSpecializationTypeLoc>();
- TemplateName Template
- = getDerived().RebuildTemplateName(SS,
- SpecTL.getTemplateKeywordLoc(),
- *SpecTL.getTypePtr()->getIdentifier(),
- SpecTL.getTemplateNameLoc(),
- ObjectType, UnqualLookup,
- /*AllowInjectedClassName*/true);
+ const IdentifierInfo *II = SpecTL.getTypePtr()
+ ->getDependentTemplateName()
+ .getName()
+ .getIdentifier();
+ TemplateName Template = getDerived().RebuildTemplateName(
+ SS, SpecTL.getTemplateKeywordLoc(), *II, SpecTL.getTemplateNameLoc(),
+ ObjectType, UnqualLookup,
+ /*AllowInjectedClassName*/ true);
if (Template.isNull())
return nullptr;
@@ -7431,9 +7425,9 @@ QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
// FIXME: maybe don't rebuild if all the template arguments are the same.
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
+ assert(DTN->getQualifier() == SS.getScopeRep());
QualType Result = getSema().Context.getDependentTemplateSpecializationType(
- TL.getTypePtr()->getKeyword(), DTN->getQualifier(),
- DTN->getIdentifier(), NewTemplateArgs.arguments());
+ TL.getTypePtr()->getKeyword(), *DTN, NewTemplateArgs.arguments());
DependentTemplateSpecializationTypeLoc NewTL
= TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
@@ -7756,15 +7750,15 @@ QualType TreeTransform<Derived>::
return QualType();
}
- return getDerived()
- .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
+ CXXScopeSpec SS;
+ SS.Adopt(QualifierLoc);
+ return getDerived().TransformDependentTemplateSpecializationType(TLB, TL, SS);
}
-template<typename Derived>
-QualType TreeTransform<Derived>::
-TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
- DependentTemplateSpecializationTypeLoc TL,
- NestedNameSpecifierLoc QualifierLoc) {
+template <typename Derived>
+QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
+ TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
+ CXXScopeSpec &SS) {
const DependentTemplateSpecializationType *T = TL.getTypePtr();
TemplateArgumentListInfo NewTemplateArgs;
@@ -7778,13 +7772,25 @@ TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
NewTemplateArgs))
return QualType();
- QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
- T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
- T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
- /*AllowInjectedClassName*/ false);
- if (Result.isNull())
- return QualType();
+ const DependentTemplateStorage &DTN = T->getDependentTemplateName();
+ QualType Result = TL.getType();
+ if (getDerived().AlwaysRebuild() || SS.getScopeRep() != DTN.getQualifier()) {
+ TemplateName Name = getDerived().RebuildTemplateName(
+ SS, TL.getTemplateKeywordLoc(), DTN.getName(), TL.getTemplateNameLoc(),
+ /*ObjectType=*/QualType(), /*FirstQualifierInScope=*/nullptr,
+ /*AllowInjectedClassName=*/false);
+ if (Name.isNull())
+ return QualType();
+ Result = getDerived().RebuildDependentTemplateSpecializationType(
+ T->getKeyword(), SS.getScopeRep(), TL.getTemplateKeywordLoc(), Name,
+ TL.getTemplateNameLoc(), NewTemplateArgs,
+ /*AllowInjectedClassName=*/false);
+ if (Result.isNull())
+ return QualType();
+ }
+
+ NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(SemaRef.Context);
if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
QualType NamedT = ElabT->getNamedType();
@@ -7802,7 +7808,8 @@ TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
NewTL.setQualifierLoc(QualifierLoc);
- } else if (isa<DependentTemplateSpecializationType>(Result)) {
+ } else {
+ assert(isa<DependentTemplateSpecializationType>(Result));
DependentTemplateSpecializationTypeLoc SpecTL
= TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
@@ -7813,15 +7820,6 @@ TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
SpecTL.setRAngleLoc(TL.getRAngleLoc());
for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
- } else {
- TemplateSpecializationTypeLoc SpecTL
- = TLB.push<TemplateSpecializationTypeLoc>(Result);
- SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
- SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
- SpecTL.setLAngleLoc(TL.getLAngleLoc());
- SpecTL.setRAngleLoc(TL.getRAngleLoc());
- for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
- SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
}
return Result;
}
@@ -17533,8 +17531,7 @@ TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
<< ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
return ExprError();
}
- SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
- CCLoc);
+ SS.Extend(SemaRef.Context, ScopeType->getTypeLoc(), CCLoc);
}
SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 0cd2cedb48dd9..58a57d6c54523 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -9914,18 +9914,12 @@ ASTRecordReader::readNestedNameSpecifierLoc() {
break;
}
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate: {
- bool Template = readBool();
+ case NestedNameSpecifier::TypeSpec: {
TypeSourceInfo *T = readTypeSourceInfo();
if (!T)
return NestedNameSpecifierLoc();
SourceLocation ColonColonLoc = readSourceLocation();
-
- // FIXME: 'template' keyword location not saved anywhere, so we fake it.
- Builder.Extend(Context,
- Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
- T->getTypeLoc(), ColonColonLoc);
+ Builder.Extend(Context, T->getTypeLoc(), ColonColonLoc);
break;
}
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index 99ac26cb43cac..84f7f2bc5fce4 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -7022,8 +7022,6 @@ void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
break;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
- Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
AddTypeRef(NNS.getTypeLoc().getType());
AddTypeLoc(NNS.getTypeLoc());
AddSourceLocation(NNS.getLocalSourceRange().getEnd());
diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp
index 3e50d67f4d6ef..8b746c02dbfc9 100644
--- a/clang/lib/Tooling/Syntax/BuildTree.cpp
+++ b/clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -959,8 +959,6 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Identifier:
return syntax::NodeKind::IdentifierNameSpecifier;
- case NestedNameSpecifier::TypeSpecWithTemplate:
- return syntax::NodeKind::SimpleTemplateNameSpecifier;
case NestedNameSpecifier::TypeSpec: {
const auto *NNSType = NNS.getAsType();
assert(NNSType);
diff --git a/clang/test/AST/ast-dump-decl.cpp b/clang/test/AST/ast-dump-decl.cpp
index d79051fb6efaa..08d8fba795daa 100644
--- a/clang/test/AST/ast-dump-decl.cpp
+++ b/clang/test/AST/ast-dump-decl.cpp
@@ -351,8 +351,8 @@ namespace testClassTemplateDecl {
// CHECK-NEXT: | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:24> col:5 used ~TestClassTemplate 'void () noexcept' implicit_instantiation instantiated_from 0x[[#TEMPLATE_DESTRUCTOR_DECL]]{{$}}
// CHECK-NEXT: | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:11> col:9 j 'int ()' implicit_instantiation instantiated_from 0x[[#TEMPLATE_METHOD_DECL]]{{$}}
// CHECK-NEXT: | |-FieldDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:9> col:9 i 'int'{{$}}
-// CHECK-NEXT: | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-73]]:30> col:30 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
-// CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const TestClassTemplate<A> &'{{$}}
+// CHECK-NEXT: | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-73]]:30> col:30 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<testClassTemplateDecl::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
+// CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const TestClassTemplate<testClassTemplateDecl::A> &'{{$}}
// CHECK-NEXT: |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}}
// CHECK-NEXT: |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}}
// CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}}
@@ -654,10 +654,10 @@ namespace testCanonicalTemplate {
// CHECK-NEXT: | `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'{{$}}
// CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-36]]:31> col:31 implicit used constexpr TestClassTemplate 'void () noexcept' inline default trivial{{$}}
// CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:31>{{$}}
- // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
- // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate<A> &'{{$}}
- // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (TestClassTemplate<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
- // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate<A> &&'{{$}}
+ // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
+ // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate<testCanonicalTemplate::A> &'{{$}}
+ // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (TestClassTemplate<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
+ // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate<testCanonicalTemplate::A> &&'{{$}}
template<typename T1> class TestClassTemplate2;
@@ -682,10 +682,10 @@ namespace testCanonicalTemplate {
// CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2{{$}}
// CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit used constexpr TestClassTemplate2 'void () noexcept' inline default trivial{{$}}
// CHECK-NEXT: | `-CompoundStmt 0x{{.+}} <col:31>{{$}}
- // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const TestClassTemplate2<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
- // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate2<A> &'{{$}}
- // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (TestClassTemplate2<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
- // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate2<A> &&'{{$}}
+ // CHECK-NEXT: |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const TestClassTemplate2<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
+ // CHECK-NEXT: | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate2<testCanonicalTemplate::A> &'{{$}}
+ // CHECK-NEXT: `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (TestClassTemplate2<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}{{$}}
+ // CHECK-NEXT: `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate2<testCanonicalTemplate::A> &&'{{$}}
// CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-26]]:3, col:31> col:31 TestClassTemplate2{{$}}
// CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1{{$}}
diff --git a/clang/test/AST/ast-dump-expr.cpp b/clang/test/AST/ast-dump-expr.cpp
index 5da025c229ea3..2efd0b5e8ac21 100644
--- a/clang/test/AST/ast-dump-expr.cpp
+++ b/clang/test/AST/ast-dump-expr.cpp
@@ -229,11 +229,10 @@ void PostfixExpressions(S a, S *p, U<int> *r) {
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
- // FIXME: there is no mention that this used the template keyword.
r->template U<int>::~U();
// CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:26> 'void'
// CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:24> '<bound member function type>' ->~U 0x{{[^ ]*}}
- // CHECK-NEXT: NestedNameSpecifier TypeSpecWithTemplate 'template U<int>':'U<int>'
+ // CHECK-NEXT: NestedNameSpecifier TypeSpec 'template U<int>':'U<int>'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'U<int> *' lvalue ParmVar 0x{{[^ ]*}} 'r' 'U<int> *'
diff --git a/clang/test/AST/ast-dump-templates.cpp b/clang/test/AST/ast-dump-templates.cpp
index fb0132bf7dbc2..d6982a0927e8c 100644
--- a/clang/test/AST/ast-dump-templates.cpp
+++ b/clang/test/AST/ast-dump-templates.cpp
@@ -174,7 +174,7 @@ namespace TestDependentMemberPointer {
// DUMP-NEXT: | `-BuiltinType {{.+}} 'int'
// DUMP-NEXT: `-TypeAliasDecl {{.+}} Z 'int U::template V<int>::*'{{$}}
// DUMP-NEXT: `-MemberPointerType {{.+}} 'int U::template V<int>::*' dependent
-// DUMP-NEXT: |-DependentTemplateSpecializationType {{.+}} 'U::template V<int>' dependent
+// DUMP-NEXT: |-DependentTemplateSpecializationType {{.+}} 'template V<int>' dependent
// DUMP-NEXT: `-BuiltinType {{.+}} 'int'
} // namespace TestDependentMemberPointer
@@ -6588,7 +6588,7 @@ namespace TestDependentMemberPointer {
// JSON-NEXT: "tokLen": 9
// JSON-NEXT: },
// JSON-NEXT: "end": {
-// JSON-NEXT: "offset": 6359,
+// JSON-NEXT: "offset": 6356,
// JSON-NEXT: "line": 179,
// JSON-NEXT: "col": 1,
// JSON-NEXT: "tokLen": 1
@@ -6896,7 +6896,7 @@ namespace TestDependentMemberPointer {
// JSON-NEXT: "id": "0x{{.*}}",
// JSON-NEXT: "kind": "DependentTemplateSpecializationType",
// JSON-NEXT: "type": {
-// JSON-NEXT: "qualType": "U::template V<int>"
+// JSON-NEXT: "qualType": "template V<int>"
// JSON-NEXT: },
// JSON-NEXT: "isDependent": true,
// JSON-NEXT: "isInstantiationDependent": true
diff --git a/clang/test/CXX/class.access/p6.cpp b/clang/test/CXX/class.access/p6.cpp
index 6f266728faa6b..15f2644f6ac1d 100644
--- a/clang/test/CXX/class.access/p6.cpp
+++ b/clang/test/CXX/class.access/p6.cpp
@@ -92,7 +92,7 @@ namespace test3 {
template <class T> class Outer::A<T, typename T::nature> {
public:
- static void foo(); // expected-note {{'Outer::A<B, Green>::foo' declared here}}
+ static void foo(); // expected-note {{'Outer::A<test3::B, test3::Green>::foo' declared here}}
};
class B {
@@ -102,7 +102,7 @@ namespace test3 {
void test() {
Outer::A<B, Green>::foo();
- Outer::A<B, Blue>::foo(); // expected-error {{no member named 'foo' in 'test3::Outer::A<test3::B, test3::Blue>'; did you mean 'Outer::A<B, Green>::foo'?}}
+ Outer::A<B, Blue>::foo(); // expected-error {{no member named 'foo' in 'test3::Outer::A<test3::B, test3::Blue>'; did you mean 'Outer::A<test3::B, test3::Green>::foo'?}}
}
}
diff --git a/clang/test/CXX/drs/cwg2xx.cpp b/clang/test/CXX/drs/cwg2xx.cpp
index b621318a9ce41..b2ae8f88ead74 100644
--- a/clang/test/CXX/drs/cwg2xx.cpp
+++ b/clang/test/CXX/drs/cwg2xx.cpp
@@ -98,8 +98,8 @@ template <class T> class Templ { // #cwg203-ex3-Templ
void foo() { Templ<Derived> x(&Derived::func); }
// expected-error at -1 {{no matching constructor for initialization of 'Templ<Derived>'}}
-// expected-note@#cwg203-ex3-Templ {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'const Templ<Derived>' for 1st argument}}
-// since-cxx11-note@#cwg203-ex3-Templ {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'Templ<Derived>' for 1st argument}}
+// expected-note@#cwg203-ex3-Templ {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'const Templ<cwg203::ex3::Derived>' for 1st argument}}
+// since-cxx11-note@#cwg203-ex3-Templ {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'Templ<cwg203::ex3::Derived>' for 1st argument}}
// expected-note@#cwg203-ex3-Templ-ctor {{candidate template ignored: could not match 'cwg203::ex3::Derived' against 'cwg203::ex3::Base'}}
} // namespace ex3
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
index 763d983d20f61..651cca927d513 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
@@ -150,7 +150,7 @@ void func() {
// expected-note@#bar {{while substituting template arguments into constraint expression here}}
// expected-note@#bar {{while checking the satisfaction of nested requirement requested here}}
// expected-note@#bar {{candidate template ignored: constraints not satisfied [with T = False]}}
- // expected-note@#bar {{because 'X<False>::value' evaluated to false}}
+ // expected-note@#bar {{because 'X<SubstitutionFailureNestedRequires::ErrorExpressions_NotSF::False>::value' evaluated to false}}
bar<int>();
// expected-note at -1 {{while checking constraint satisfaction for template 'bar<int>' required here}} \
diff --git a/clang/test/SemaCXX/static-assert.cpp b/clang/test/SemaCXX/static-assert.cpp
index 0d384b6b499f7..bf6a2eeb432a3 100644
--- a/clang/test/SemaCXX/static-assert.cpp
+++ b/clang/test/SemaCXX/static-assert.cpp
@@ -196,8 +196,10 @@ struct NestedTemplates1 {
template <typename T, typename U, int a>
void foo2() {
+ // FIXME: Here the template keyword is dropped because the failed condition
+ // for a static assert is always printed with canonical types.
static_assert(::ns::NestedTemplates1<T, a>::NestedTemplates2::template NestedTemplates3<U>::value, "message");
- // expected-error at -1{{static assertion failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::template NestedTemplates3<float>::value': message}}
+ // expected-error at -1{{static assertion failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value': message}}
}
template void foo2<int, float, 3>();
// expected-note at -1{{in instantiation of function template specialization 'foo2<int, float, 3>' requested here}}
diff --git a/clang/test/SemaTemplate/aggregate-deduction-candidate.cpp b/clang/test/SemaTemplate/aggregate-deduction-candidate.cpp
index 0854ac9178b4f..2ecd2694ce09d 100644
--- a/clang/test/SemaTemplate/aggregate-deduction-candidate.cpp
+++ b/clang/test/SemaTemplate/aggregate-deduction-candidate.cpp
@@ -331,7 +331,7 @@ namespace DeduceArity {
// CHECK: | |-ParmVarDecl {{.*}} 'Types<T...>'
// CHECK: | `-ParmVarDecl {{.*}} 'T...' pack
// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for F>
- // CHECK-SAME: 'auto (Types<X, Y, Z>, DeduceArity::X, DeduceArity::Y, DeduceArity::Z) ->
+ // CHECK-SAME: 'auto (Types<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>, DeduceArity::X, DeduceArity::Y, DeduceArity::Z) ->
// CHECK-SAME: DeduceArity::F<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>'
// CHECK: | |-TemplateArgument pack
// CHECK: | | |-TemplateArgument type 'DeduceArity::X'
@@ -343,16 +343,16 @@ namespace DeduceArity {
// CHECK: | | `-TemplateArgument type 'DeduceArity::Z'
// CHECK: | | `-RecordType {{.*}} 'DeduceArity::Z'
// CHECK: | | `-CXXRecord {{.*}} 'Z'
- // CHECK: | |-ParmVarDecl {{.*}} 'Types<X, Y, Z>':'DeduceArity::Types<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>'
+ // CHECK: | |-ParmVarDecl {{.*}} 'Types<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>':'DeduceArity::Types<DeduceArity::X, DeduceArity::Y, DeduceArity::Z>'
// CHECK: | |-ParmVarDecl {{.*}} 'DeduceArity::X'
// CHECK: | |-ParmVarDecl {{.*}} 'DeduceArity::Y'
// CHECK: | `-ParmVarDecl {{.*}} 'DeduceArity::Z'
- // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (Types<X>, DeduceArity::X) -> DeduceArity::F<DeduceArity::X>'
+ // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (Types<DeduceArity::X>, DeduceArity::X) -> DeduceArity::F<DeduceArity::X>'
// CHECK: |-TemplateArgument pack
// CHECK: | `-TemplateArgument type 'DeduceArity::X'
// CHECK: | `-RecordType {{.*}} 'DeduceArity::X'
// CHECK: | `-CXXRecord {{.*}} 'X'
- // CHECK: |-ParmVarDecl {{.*}} 'Types<X>':'DeduceArity::Types<DeduceArity::X>'
+ // CHECK: |-ParmVarDecl {{.*}} 'Types<DeduceArity::X>':'DeduceArity::Types<DeduceArity::X>'
// CHECK: `-ParmVarDecl {{.*}} 'DeduceArity::X'
// CHECK: FunctionProtoType {{.*}} 'auto (Types<T...>, T...) -> F<T...>' dependent trailing_return cdecl
// CHECK: |-InjectedClassNameType {{.*}} 'F<T...>' dependent
diff --git a/clang/test/SemaTemplate/dependent-template-recover.cpp b/clang/test/SemaTemplate/dependent-template-recover.cpp
index c7e27e8da25f1..251a8f9816417 100644
--- a/clang/test/SemaTemplate/dependent-template-recover.cpp
+++ b/clang/test/SemaTemplate/dependent-template-recover.cpp
@@ -134,3 +134,21 @@ namespace PR9401 {
const D<typename C<S, T>::template B<U>::template E<D<F> > >
A<S, T>::B<U>::a = typename C<S, T>::template B<U>::template E<D<F> >(g);
}
+
+namespace templ_spec {
+ template <class U> using A = void; // expected-note 2{{template parameter is declared here}}
+ template <class T> struct B {
+ A<typename T::template X<int>> t1;
+ // expected-error at -1 {{'A<typename T::template X<int>>' (aka 'void')}}
+
+ A<typename T::X<int>> t2; // expected-error {{use 'template' keyword}}
+ // expected-error at -1 {{'A<typename T::X<int>>' (aka 'void')}}
+
+ // FIXME: Why error recovery for the non-typename case is so bad?
+ A<T::template X<int>> t3; // expected-error {{did you forget 'typename'}}
+ // expected-error at -1 {{'A<typename T::X>' (aka 'void')}}
+
+ A<T::X<int>> t4; // expected-error {{use 'template' keyword}} expected-error {{did you forget 'typename'}}
+ // expected-error at -1 {{'A<typename T::X>' (aka 'void')}}
+ };
+} // namespace templ_spec
diff --git a/clang/test/SemaTemplate/instantiate-requires-expr.cpp b/clang/test/SemaTemplate/instantiate-requires-expr.cpp
index a1f5456156a06..ab5fac1f9e63e 100644
--- a/clang/test/SemaTemplate/instantiate-requires-expr.cpp
+++ b/clang/test/SemaTemplate/instantiate-requires-expr.cpp
@@ -72,8 +72,8 @@ namespace type_requirement {
template<typename T> requires
false_v<requires { typename T::template temp<T>; }>
- // expected-note at -1 {{because 'false_v<requires { typename contains_template<int>::template temp<contains_template<int> >; }>' evaluated to false}}
- // expected-note at -2 {{because 'false_v<requires { typename contains_template<short>::template temp<contains_template<short> >; }>' evaluated to false}}
+ // expected-note at -1 {{because 'false_v<requires { typename contains_template<int>::template temp<type_requirement::contains_template<int> >; }>' evaluated to false}}
+ // expected-note at -2 {{because 'false_v<requires { typename contains_template<short>::template temp<type_requirement::contains_template<short> >; }>' evaluated to false}}
struct r2 {};
using r2i1 = r2<contains_template<int>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template<int>]}}
diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp
index e498a875bbbe8..197ba2cd6856e 100644
--- a/clang/tools/libclang/CIndex.cpp
+++ b/clang/tools/libclang/CIndex.cpp
@@ -1457,7 +1457,6 @@ bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
break;
}
- case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::Super:
@@ -1492,7 +1491,6 @@ bool CursorVisitor::VisitNestedNameSpecifierLoc(
break;
case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
if (Visit(Q.getTypeLoc()))
return true;
diff --git a/libcxx/test/std/containers/sequences/array/array.overview/nttp.verify.cpp b/libcxx/test/std/containers/sequences/array/array.overview/nttp.verify.cpp
index 3eb8e2596f85b..f50febf5f2485 100644
--- a/libcxx/test/std/containers/sequences/array/array.overview/nttp.verify.cpp
+++ b/libcxx/test/std/containers/sequences/array/array.overview/nttp.verify.cpp
@@ -61,7 +61,7 @@ using E = test<std::array<NotALiteral, 1>{}>;
// expected-error at -1 {{non-type template parameter has non-literal type 'std::array<NotALiteral, 1>'}}
using F = test<std::array<std::string, 2>{}>;
-// expected-error at -1 {{type 'std::array<string, 2>' (aka 'std::array<std::string, 2>') of non-type template parameter is not a structural type}}
+// expected-error-re at -1 {{type 'std::array<{{(std::)?}}string, 2>'{{( \(aka 'std::array<std::string, 2>'\))?}} of non-type template parameter is not a structural type}}
} // namespace test_ctad
namespace test_auto {
diff --git a/libcxx/test/std/utilities/smartptr/adapt/inout_ptr/inout_ptr.verify.cpp b/libcxx/test/std/utilities/smartptr/adapt/inout_ptr/inout_ptr.verify.cpp
index d6d70782c5eb5..fba0f61b76060 100644
--- a/libcxx/test/std/utilities/smartptr/adapt/inout_ptr/inout_ptr.verify.cpp
+++ b/libcxx/test/std/utilities/smartptr/adapt/inout_ptr/inout_ptr.verify.cpp
@@ -26,7 +26,7 @@ int main(int, char**) {
// expected-error-re@*:* {{static assertion failed due to requirement {{.*}}std::shared_ptr<> is not supported}}
std::ignore = std::inout_ptr(sPtr);
- // expected-error@*:* {{no matching conversion for functional-style cast from 'std::shared_ptr<int>' to 'std::inout_ptr_t<shared_ptr<int>, _Ptr>' (aka 'inout_ptr_t<std::shared_ptr<int>, int *>'}}
+ // expected-error-re@*:* {{no matching conversion for functional-style cast from 'std::shared_ptr<int>' to 'std::inout_ptr_t<{{(std::)?}}shared_ptr<int>, _Ptr>'{{( \(aka 'inout_ptr_t<std::shared_ptr<int>, int *>')?}}}}
std::ignore = std::inout_ptr<int*>(sPtr);
}
diff --git a/libcxx/test/std/utilities/smartptr/adapt/out_ptr/out_ptr.verify.cpp b/libcxx/test/std/utilities/smartptr/adapt/out_ptr/out_ptr.verify.cpp
index 1fe78ecb22789..da3ffbba94a8f 100644
--- a/libcxx/test/std/utilities/smartptr/adapt/out_ptr/out_ptr.verify.cpp
+++ b/libcxx/test/std/utilities/smartptr/adapt/out_ptr/out_ptr.verify.cpp
@@ -26,7 +26,7 @@ int main(int, char**) {
// expected-error-re@*:* {{static assertion failed due to requirement {{.*}}Using std::shared_ptr<> without a deleter in std::out_ptr is not supported.}}
std::ignore = std::out_ptr(sPtr);
- // expected-error@*:* {{no matching conversion for functional-style cast from 'std::shared_ptr<int>' to 'std::out_ptr_t<shared_ptr<int>, _Ptr>' (aka 'out_ptr_t<std::shared_ptr<int>, int *>')}}
+ // expected-error-re@*:* {{no matching conversion for functional-style cast from 'std::shared_ptr<int>' to 'std::out_ptr_t<{{(std::)?}}shared_ptr<int>, _Ptr>'{{( \(aka 'out_ptr_t<std::shared_ptr<int>, int *>'\))?}}}}
std::ignore = std::out_ptr<int*>(sPtr);
}
diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.pair/nttp.verify.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.pair/nttp.verify.cpp
index b9b5432a30b21..9a39c18f138fb 100644
--- a/libcxx/test/std/utilities/utility/pairs/pairs.pair/nttp.verify.cpp
+++ b/libcxx/test/std/utilities/utility/pairs/pairs.pair/nttp.verify.cpp
@@ -74,7 +74,7 @@ using H = test<std::pair<NotALiteral, NotALiteral>{}>;
// expected-error at -1 {{non-type template parameter has non-literal type 'std::pair<NotALiteral, NotALiteral>'}}
using I = test<std::pair<std::string, std::string>{}>;
-// expected-error at -1 {{type 'std::pair<string, string>' (aka 'std::pair<std::string, std::string>') of non-type template parameter is not a structural type}}
+// expected-error-re at -1 {{type 'std::pair<{{(std::)?}}string, {{(std::)?}}string>'{{( \(aka 'std::pair<std::string, std::string>'\))?}} of non-type template parameter is not a structural type}}
} // namespace test_ctad
namespace test_auto {
>From ce6a2db688d2635ee624207e5dedcc05443b26ca Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sun, 30 Mar 2025 16:23:31 -0300
Subject: [PATCH 9/9] WIP
---
clang/include/clang/AST/ASTContext.h | 7 ++--
clang/lib/AST/ASTContext.cpp | 63 ++++++++++++++++------------
clang/lib/AST/ItaniumMangle.cpp | 2 +-
3 files changed, 40 insertions(+), 32 deletions(-)
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 36d06f3af7eb3..c4c8f2034a8b1 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1840,10 +1840,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType getDependentTemplateSpecializationType(
ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
ArrayRef<TemplateArgumentLoc> Args) const;
- QualType
- getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
- const DependentTemplateStorage &Name,
- ArrayRef<TemplateArgument> Args) const;
+ QualType getDependentTemplateSpecializationType(
+ ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+ ArrayRef<TemplateArgument> Args, bool IsCanonical = false) const;
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const;
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 36cd93ce0f4b6..efec3d03ecbd8 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -5774,44 +5774,53 @@ QualType ASTContext::getDependentTemplateSpecializationType(
QualType ASTContext::getDependentTemplateSpecializationType(
ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
- ArrayRef<TemplateArgument> Args) const {
+ ArrayRef<TemplateArgument> Args, bool IsCanonical) const {
llvm::FoldingSetNodeID ID;
DependentTemplateSpecializationType::Profile(ID, *this, Keyword, Name, Args);
void *InsertPos = nullptr;
- DependentTemplateSpecializationType *T
- = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
- if (T)
+ if (auto *T = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(
+ ID, InsertPos))
return QualType(T, 0);
- NestedNameSpecifier *NNS = Name.getQualifier(),
- *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
-
- ElaboratedTypeKeyword CanonKeyword = Keyword;
- if (Keyword == ElaboratedTypeKeyword::None)
- CanonKeyword = ElaboratedTypeKeyword::Typename;
-
- bool AnyNonCanonArgs = false;
- auto CanonArgs =
- ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+ NestedNameSpecifier *NNS = Name.getQualifier();
QualType Canon;
- if (AnyNonCanonArgs || CanonNNS != NNS || !Name.hasTemplateKeyword() ||
- CanonKeyword != Keyword) {
- Canon = getDependentTemplateSpecializationType(
- CanonKeyword, {CanonNNS, Name.getName(), /*HasTemplateKeyword=*/true},
- CanonArgs);
-
- // Find the insert position again.
- [[maybe_unused]] auto *Nothing =
- DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
- assert(!Nothing && "canonical type broken");
+ if (!IsCanonical) {
+ ElaboratedTypeKeyword CanonKeyword = Keyword != ElaboratedTypeKeyword::None
+ ? Keyword
+ : ElaboratedTypeKeyword::Typename;
+ NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
+ bool AnyNonCanonArgs = false;
+ auto CanonArgs =
+ ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+
+ if (AnyNonCanonArgs || CanonNNS != NNS || !Name.hasTemplateKeyword() ||
+ CanonKeyword != Keyword) {
+ Canon = getDependentTemplateSpecializationType(
+ CanonKeyword, {CanonNNS, Name.getName(), /*HasTemplateKeyword=*/true},
+ CanonArgs, /*IsCanonical=*/true);
+ // Find the insert position again.
+ [[maybe_unused]] auto *Nothing =
+ DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID,
+ InsertPos);
+ assert(!Nothing && "canonical type broken");
+ }
+ } else {
+ assert(Keyword != ElaboratedTypeKeyword::None);
+ assert(Name.hasTemplateKeyword());
+ assert(NNS == getCanonicalNestedNameSpecifier(NNS));
+#ifndef NDEBUG
+ bool AnyNonCanonArgs = false;
+ ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+ assert(!AnyNonCanonArgs);
+#endif
}
-
void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
sizeof(TemplateArgument) * Args.size()),
alignof(DependentTemplateSpecializationType));
- T = new (Mem) DependentTemplateSpecializationType(Keyword, Name, Args, Canon);
+ auto *T =
+ new (Mem) DependentTemplateSpecializationType(Keyword, Name, Args, Canon);
Types.push_back(T);
DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
@@ -7625,7 +7634,7 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
QualType NewT = getDependentTemplateSpecializationType(
ElaboratedTypeKeyword::Typename,
{/*NNS=*/nullptr, DTN.getName(), /*HasTemplateKeyword=*/true},
- DTST->template_arguments());
+ DTST->template_arguments(), /*IsCanonical=*/true);
assert(NewT.isCanonical());
NestedNameSpecifier *Prefix = DTN.getQualifier();
if (!Prefix)
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index a81b06d2bba40..70ab592cd23ba 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -2187,7 +2187,7 @@ void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
DTST->getKeyword(),
{Prefix, DTST->getDependentTemplateName().getName(),
/*HasTemplateKeyword=*/true},
- DTST->template_arguments());
+ DTST->template_arguments(), /*IsCanonical=*/true);
manglePrefix(NewT);
return;
}
More information about the cfe-commits
mailing list