[clang] 8383c2a - Revert "[clang] Implement sugared substitution changes to infrastructure"
Matheus Izvekov via cfe-commits
cfe-commits at lists.llvm.org
Wed Oct 26 01:15:59 PDT 2022
Author: Matheus Izvekov
Date: 2022-10-26T10:14:31+02:00
New Revision: 8383c2a435ecf9a86dc8f903a3d0b0b561422eeb
URL: https://github.com/llvm/llvm-project/commit/8383c2a435ecf9a86dc8f903a3d0b0b561422eeb
DIFF: https://github.com/llvm/llvm-project/commit/8383c2a435ecf9a86dc8f903a3d0b0b561422eeb.diff
LOG: Revert "[clang] Implement sugared substitution changes to infrastructure"
This reverts commit c4c2a3c65684e062efcd101a957c6cae0a304a7a.
Added:
Modified:
clang/include/clang/AST/ASTContext.h
clang/include/clang/AST/PropertiesBase.td
clang/include/clang/AST/TemplateName.h
clang/include/clang/AST/Type.h
clang/include/clang/AST/TypeProperties.td
clang/include/clang/Sema/Sema.h
clang/include/clang/Sema/Template.h
clang/lib/AST/ASTContext.cpp
clang/lib/AST/ASTImporter.cpp
clang/lib/AST/TemplateName.cpp
clang/lib/AST/Type.cpp
clang/lib/Sema/SemaConcept.cpp
clang/lib/Sema/SemaExprCXX.cpp
clang/lib/Sema/SemaTemplate.cpp
clang/lib/Sema/SemaTemplateDeduction.cpp
clang/lib/Sema/SemaTemplateInstantiate.cpp
clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
clang/lib/Sema/SemaType.cpp
clang/lib/Sema/TreeTransform.h
clang/lib/Sema/TypeLocBuilder.cpp
clang/lib/Sema/TypeLocBuilder.h
clang/test/SemaTemplate/nested-name-spec-template.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 2a21f2d1f37ee..a6b3301f2a73a 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1621,7 +1621,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
Decl *AssociatedDecl, unsigned Index,
Optional<unsigned> PackIndex) const;
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
- unsigned Index, bool Final,
+ unsigned Index,
const TemplateArgument &ArgPack);
QualType
@@ -2207,8 +2207,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
Optional<unsigned> PackIndex) const;
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
Decl *AssociatedDecl,
- unsigned Index,
- bool Final) const;
+ unsigned Index) const;
enum GetBuiltinTypeError {
/// No error
diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td
index f952b08502db1..9fe80440953f4 100644
--- a/clang/include/clang/AST/PropertiesBase.td
+++ b/clang/include/clang/AST/PropertiesBase.td
@@ -730,11 +730,8 @@ let Class = PropertyTypeCase<TemplateName, "SubstTemplateTemplateParmPack"> in {
def : Property<"index", UInt32> {
let Read = [{ parm->getIndex() }];
}
- def : Property<"final", Bool> {
- let Read = [{ parm->getFinal() }];
- }
def : Creator<[{
- return ctx.getSubstTemplateTemplateParmPack(argumentPack, associatedDecl, index, final);
+ return ctx.getSubstTemplateTemplateParmPack(argumentPack, associatedDecl, index);
}]>;
}
diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h
index 82bbe72d22e58..25aa991d3b841 100644
--- a/clang/include/clang/AST/TemplateName.h
+++ b/clang/include/clang/AST/TemplateName.h
@@ -139,24 +139,25 @@ class OverloadedTemplateStorage : public UncommonTemplateNameStorage {
class SubstTemplateTemplateParmPackStorage : public UncommonTemplateNameStorage,
public llvm::FoldingSetNode {
const TemplateArgument *Arguments;
- llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
+ Decl *AssociatedDecl;
public:
SubstTemplateTemplateParmPackStorage(ArrayRef<TemplateArgument> ArgPack,
- Decl *AssociatedDecl, unsigned Index,
- bool Final);
+ Decl *AssociatedDecl, unsigned Index)
+ : UncommonTemplateNameStorage(SubstTemplateTemplateParmPack, Index,
+ ArgPack.size()),
+ Arguments(ArgPack.data()), AssociatedDecl(AssociatedDecl) {
+ assert(AssociatedDecl != nullptr);
+ }
/// A template-like entity which owns the whole pattern being substituted.
/// This will own a set of template parameters.
- Decl *getAssociatedDecl() const;
+ Decl *getAssociatedDecl() const { return AssociatedDecl; }
/// Returns the index of the replaced parameter in the associated declaration.
/// This should match the result of `getParameterPack()->getIndex()`.
unsigned getIndex() const { return Bits.Index; }
- // When true the substitution will be 'Final' (subst node won't be placed).
- bool getFinal() const;
-
/// Retrieve the template template parameter pack being substituted.
TemplateTemplateParmDecl *getParameterPack() const;
@@ -168,7 +169,7 @@ class SubstTemplateTemplateParmPackStorage : public UncommonTemplateNameStorage,
static void Profile(llvm::FoldingSetNodeID &ID, ASTContext &Context,
const TemplateArgument &ArgPack, Decl *AssociatedDecl,
- unsigned Index, bool Final);
+ unsigned Index);
};
/// Represents a C++ template name within the type system.
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index fc673a8f9dd00..a288241fe99ba 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -5158,10 +5158,10 @@ class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;
- llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
+ Decl *AssociatedDecl;
SubstTemplateTypeParmPackType(QualType Canon, Decl *AssociatedDecl,
- unsigned Index, bool Final,
+ unsigned Index,
const TemplateArgument &ArgPack);
public:
@@ -5170,7 +5170,7 @@ class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
/// A template-like entity which owns the whole pattern being substituted.
/// This will usually own a set of template parameters, or in some
/// cases might even be a template parameter itself.
- Decl *getAssociatedDecl() const;
+ Decl *getAssociatedDecl() const { return AssociatedDecl; }
/// Gets the template parameter declaration that was substituted for.
const TemplateTypeParmDecl *getReplacedParameter() const;
@@ -5179,9 +5179,6 @@ 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).
- bool getFinal() const;
-
unsigned getNumArgs() const {
return SubstTemplateTypeParmPackTypeBits.NumArgs;
}
@@ -5193,8 +5190,7 @@ class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID, const Decl *AssociatedDecl,
- unsigned Index, bool Final,
- const TemplateArgument &ArgPack);
+ unsigned Index, const TemplateArgument &ArgPack);
static bool classof(const Type *T) {
return T->getTypeClass() == SubstTemplateTypeParmPack;
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index 89bbc0fde7096..0961fb9ad4cd3 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -773,16 +773,13 @@ let Class = SubstTemplateTypeParmPackType in {
def : Property<"Index", UInt32> {
let Read = [{ node->getIndex() }];
}
- def : Property<"Final", Bool> {
- let Read = [{ node->getFinal() }];
- }
def : Property<"replacementPack", TemplateArgument> {
let Read = [{ node->getArgumentPack() }];
}
def : Creator<[{
return ctx.getSubstTemplateTypeParmPackType(
- associatedDecl, Index, Final, replacementPack);
+ associatedDecl, Index, replacementPack);
}]>;
}
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index d0757f874303f..0fdc69ef7e1df 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -9074,12 +9074,10 @@ class Sema final {
// C++ Template Instantiation
//
- MultiLevelTemplateArgumentList
- getTemplateInstantiationArgs(const NamedDecl *D, bool Final = false,
- const TemplateArgumentList *Innermost = nullptr,
- bool RelativeToPrimary = false,
- const FunctionDecl *Pattern = nullptr,
- bool ForConstraintInstantiation = false);
+ MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
+ const NamedDecl *D, const TemplateArgumentList *Innermost = nullptr,
+ bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr,
+ bool ForConstraintInstantiation = false);
/// A context in which code is being synthesized (where a source location
/// alone is not sufficient to identify the context). This covers template
@@ -10173,12 +10171,16 @@ class Sema final {
bool FailOnError = false);
/// Build an Objective-C object pointer type.
- QualType BuildObjCObjectType(
- QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc,
- ArrayRef<TypeSourceInfo *> TypeArgs, SourceLocation TypeArgsRAngleLoc,
- SourceLocation ProtocolLAngleLoc, ArrayRef<ObjCProtocolDecl *> Protocols,
- ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc,
- bool FailOnError, bool Rebuilding);
+ QualType BuildObjCObjectType(QualType BaseType,
+ SourceLocation Loc,
+ SourceLocation TypeArgsLAngleLoc,
+ ArrayRef<TypeSourceInfo *> TypeArgs,
+ SourceLocation TypeArgsRAngleLoc,
+ SourceLocation ProtocolLAngleLoc,
+ ArrayRef<ObjCProtocolDecl *> Protocols,
+ ArrayRef<SourceLocation> ProtocolLocs,
+ SourceLocation ProtocolRAngleLoc,
+ bool FailOnError = false);
/// Ensure attributes are consistent with type.
/// \param [in, out] Attributes The attributes to check; they will
diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h
index 7afe0d2afcafc..2250ac373c4b2 100644
--- a/clang/include/clang/Sema/Template.h
+++ b/clang/include/clang/Sema/Template.h
@@ -77,7 +77,7 @@ enum class TemplateSubstitutionKind : char {
using ArgList = ArrayRef<TemplateArgument>;
struct ArgumentListLevel {
- llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
+ Decl *AssociatedDecl;
ArgList Args;
};
using ContainerType = SmallVector<ArgumentListLevel, 4>;
@@ -101,8 +101,8 @@ enum class TemplateSubstitutionKind : char {
MultiLevelTemplateArgumentList() = default;
/// Construct a single-level template argument list.
- MultiLevelTemplateArgumentList(Decl *D, ArgList Args, bool Final) {
- addOuterTemplateArguments(D, Args, Final);
+ MultiLevelTemplateArgumentList(Decl *D, ArgList Args) {
+ addOuterTemplateArguments(D, Args);
}
void setKind(TemplateSubstitutionKind K) { Kind = K; }
@@ -160,11 +160,9 @@ enum class TemplateSubstitutionKind : char {
/// A template-like entity which owns the whole pattern being substituted.
/// This will usually own a set of template parameters, or in some
/// cases might even be a template parameter itself.
- std::pair<Decl *, bool> getAssociatedDecl(unsigned Depth) const {
+ Decl *getAssociatedDecl(unsigned Depth) const {
assert(NumRetainedOuterLevels <= Depth && Depth < getNumLevels());
- auto AD = TemplateArgumentLists[getNumLevels() - Depth - 1]
- .AssociatedDeclAndFinal;
- return {AD.getPointer(), AD.getInt()};
+ return TemplateArgumentLists[getNumLevels() - Depth - 1].AssociatedDecl;
}
/// Determine whether there is a non-NULL template argument at the
@@ -204,22 +202,21 @@ enum class TemplateSubstitutionKind : char {
/// Add a new outmost level to the multi-level template argument
/// list.
- /// A 'Final' substitution means that Subst* nodes won't be built
- /// for the replacements.
- void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args,
- bool Final) {
+ void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args) {
assert(!NumRetainedOuterLevels &&
"substituted args outside retained args?");
assert(getKind() == TemplateSubstitutionKind::Specialization);
+ assert(AssociatedDecl != nullptr || Args.size() == 0);
TemplateArgumentLists.push_back(
- {{AssociatedDecl->getCanonicalDecl(), Final}, Args});
+ {AssociatedDecl ? AssociatedDecl->getCanonicalDecl() : nullptr,
+ Args});
}
void addOuterTemplateArguments(ArgList Args) {
assert(!NumRetainedOuterLevels &&
"substituted args outside retained args?");
assert(getKind() == TemplateSubstitutionKind::Rewrite);
- TemplateArgumentLists.push_back({{}, Args});
+ TemplateArgumentLists.push_back({nullptr, Args});
}
void addOuterTemplateArguments(llvm::NoneType) {
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index a8585a6d84adc..e8a9c7efa3964 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -3045,18 +3045,6 @@ ASTContext::getASTObjCImplementationLayout(
return getObjCLayout(D->getClassInterface(), D);
}
-static auto getCanonicalTemplateArguments(const ASTContext &C,
- ArrayRef<TemplateArgument> Args,
- bool &AnyNonCanonArgs) {
- SmallVector<TemplateArgument, 16> CanonArgs(Args);
- for (auto &Arg : CanonArgs) {
- TemplateArgument OrigArg = Arg;
- Arg = C.getCanonicalTemplateArgument(Arg);
- AnyNonCanonArgs |= !Arg.structurallyEquals(OrigArg);
- }
- return CanonArgs;
-}
-
//===----------------------------------------------------------------------===//
// Type creation/memoization methods
//===----------------------------------------------------------------------===//
@@ -4864,38 +4852,31 @@ ASTContext::getSubstTemplateTypeParmType(QualType Replacement,
}
/// Retrieve a
-QualType
-ASTContext::getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
- unsigned Index, bool Final,
- const TemplateArgument &ArgPack) {
+QualType ASTContext::getSubstTemplateTypeParmPackType(
+ Decl *AssociatedDecl, unsigned Index, const TemplateArgument &ArgPack) {
#ifndef NDEBUG
- for (const auto &P : ArgPack.pack_elements())
+ for (const auto &P : ArgPack.pack_elements()) {
assert(P.getKind() == TemplateArgument::Type && "Pack contains a non-type");
+ assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
+ }
#endif
llvm::FoldingSetNodeID ID;
- SubstTemplateTypeParmPackType::Profile(ID, AssociatedDecl, Index, Final,
- ArgPack);
+ SubstTemplateTypeParmPackType::Profile(ID, AssociatedDecl, Index, ArgPack);
void *InsertPos = nullptr;
if (SubstTemplateTypeParmPackType *SubstParm =
SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(SubstParm, 0);
QualType Canon;
- {
- TemplateArgument CanonArgPack = getCanonicalTemplateArgument(ArgPack);
- if (!AssociatedDecl->isCanonicalDecl() ||
- !CanonArgPack.structurallyEquals(ArgPack)) {
- Canon = getSubstTemplateTypeParmPackType(
- AssociatedDecl->getCanonicalDecl(), Index, Final, CanonArgPack);
- [[maybe_unused]] const auto *Nothing =
- SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
- assert(!Nothing);
- }
+ if (!AssociatedDecl->isCanonicalDecl()) {
+ Canon = getSubstTemplateTypeParmPackType(AssociatedDecl->getCanonicalDecl(),
+ Index, ArgPack);
+ SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
}
- auto *SubstParm = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(
- Canon, AssociatedDecl, Index, Final, ArgPack);
+ auto *SubstParm = new (*this, TypeAlignment)
+ SubstTemplateTypeParmPackType(Canon, AssociatedDecl, Index, ArgPack);
Types.push_back(SubstParm);
SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
return QualType(SubstParm, 0);
@@ -5020,6 +5001,23 @@ ASTContext::getTemplateSpecializationType(TemplateName Template,
return QualType(Spec, 0);
}
+static bool
+getCanonicalTemplateArguments(const ASTContext &C,
+ ArrayRef<TemplateArgument> OrigArgs,
+ SmallVectorImpl<TemplateArgument> &CanonArgs) {
+ bool AnyNonCanonArgs = false;
+ unsigned NumArgs = OrigArgs.size();
+ CanonArgs.resize(NumArgs);
+ for (unsigned I = 0; I != NumArgs; ++I) {
+ const TemplateArgument &OrigArg = OrigArgs[I];
+ TemplateArgument &CanonArg = CanonArgs[I];
+ CanonArg = C.getCanonicalTemplateArgument(OrigArg);
+ if (!CanonArg.structurallyEquals(OrigArg))
+ AnyNonCanonArgs = true;
+ }
+ return AnyNonCanonArgs;
+}
+
QualType ASTContext::getCanonicalTemplateSpecializationType(
TemplateName Template, ArrayRef<TemplateArgument> Args) const {
assert(!Template.getAsDependentTemplateName() &&
@@ -5031,9 +5029,8 @@ QualType ASTContext::getCanonicalTemplateSpecializationType(
// Build the canonical template specialization type.
TemplateName CanonTemplate = getCanonicalTemplateName(Template);
- bool AnyNonCanonArgs = false;
- auto CanonArgs =
- ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+ SmallVector<TemplateArgument, 4> CanonArgs;
+ ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
// Determine whether this canonical template specialization type already
// exists.
@@ -5187,9 +5184,9 @@ ASTContext::getDependentTemplateSpecializationType(
ElaboratedTypeKeyword CanonKeyword = Keyword;
if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
- bool AnyNonCanonArgs = false;
- auto CanonArgs =
- ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+ SmallVector<TemplateArgument, 16> CanonArgs;
+ bool AnyNonCanonArgs =
+ ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
QualType Canon;
if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
@@ -6288,7 +6285,7 @@ ASTContext::getCanonicalTemplateName(const TemplateName &Name) const {
getCanonicalTemplateArgument(subst->getArgumentPack());
return getSubstTemplateTemplateParmPack(
canonArgPack, subst->getAssociatedDecl()->getCanonicalDecl(),
- subst->getFinal(), subst->getIndex());
+ subst->getIndex());
}
}
@@ -6796,13 +6793,17 @@ ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
return TemplateArgument(getCanonicalType(Arg.getAsType()));
case TemplateArgument::Pack: {
- bool AnyNonCanonArgs = false;
- auto CanonArgs = ::getCanonicalTemplateArguments(
- *this, Arg.pack_elements(), AnyNonCanonArgs);
- if (!AnyNonCanonArgs)
+ if (Arg.pack_size() == 0)
return Arg;
- return TemplateArgument::CreatePackCopy(const_cast<ASTContext &>(*this),
- CanonArgs);
+
+ auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
+ unsigned Idx = 0;
+ for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
+ AEnd = Arg.pack_end();
+ A != AEnd; (void)++A, ++Idx)
+ CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
+
+ return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
}
}
@@ -9310,11 +9311,11 @@ ASTContext::getSubstTemplateTemplateParm(TemplateName Replacement,
TemplateName
ASTContext::getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
Decl *AssociatedDecl,
- unsigned Index, bool Final) const {
+ unsigned Index) const {
auto &Self = const_cast<ASTContext &>(*this);
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmPackStorage::Profile(ID, Self, ArgPack,
- AssociatedDecl, Index, Final);
+ AssociatedDecl, Index);
void *InsertPos = nullptr;
SubstTemplateTemplateParmPackStorage *Subst
@@ -9322,7 +9323,7 @@ ASTContext::getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
if (!Subst) {
Subst = new (*this) SubstTemplateTemplateParmPackStorage(
- ArgPack.pack_elements(), AssociatedDecl, Index, Final);
+ ArgPack.pack_elements(), AssociatedDecl, Index);
SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index a5eeb54f5471c..0606c5ca0785c 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1542,7 +1542,7 @@ ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
return ToArgumentPack.takeError();
return Importer.getToContext().getSubstTemplateTypeParmPackType(
- *ReplacedOrErr, T->getIndex(), T->getFinal(), *ToArgumentPack);
+ *ReplacedOrErr, T->getIndex(), *ToArgumentPack);
}
ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
@@ -9439,8 +9439,7 @@ Expected<TemplateName> ASTImporter::Import(TemplateName From) {
return AssociatedDeclOrErr.takeError();
return ToContext.getSubstTemplateTemplateParmPack(
- *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->getIndex(),
- SubstPack->getFinal());
+ *ArgPackOrErr, *AssociatedDeclOrErr, SubstPack->getIndex());
}
case TemplateName::UsingTemplate: {
auto UsingOrError = Import(From.getAsUsingShadowDecl());
diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp
index c348d76ed5606..f301133eef804 100644
--- a/clang/lib/AST/TemplateName.cpp
+++ b/clang/lib/AST/TemplateName.cpp
@@ -67,37 +67,17 @@ void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID,
ID.AddInteger(PackIndex ? *PackIndex + 1 : 0);
}
-SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
- ArrayRef<TemplateArgument> ArgPack, Decl *AssociatedDecl, unsigned Index,
- bool Final)
- : UncommonTemplateNameStorage(SubstTemplateTemplateParmPack, Index,
- ArgPack.size()),
- Arguments(ArgPack.data()), AssociatedDeclAndFinal(AssociatedDecl, Final) {
- assert(AssociatedDecl != nullptr);
-}
-
void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
ASTContext &Context) {
- Profile(ID, Context, getArgumentPack(), getAssociatedDecl(), getIndex(),
- getFinal());
-}
-
-Decl *SubstTemplateTemplateParmPackStorage::getAssociatedDecl() const {
- return AssociatedDeclAndFinal.getPointer();
-}
-
-bool SubstTemplateTemplateParmPackStorage::getFinal() const {
- return AssociatedDeclAndFinal.getInt();
+ Profile(ID, Context, getArgumentPack(), getAssociatedDecl(), getIndex());
}
void SubstTemplateTemplateParmPackStorage::Profile(
llvm::FoldingSetNodeID &ID, ASTContext &Context,
- const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
- bool Final) {
+ const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index) {
ArgPack.Profile(ID, Context);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
- ID.AddBoolean(Final);
}
TemplateName::TemplateName(void *Ptr) {
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index e723bb3612e84..e27ef7bfab390 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -3666,26 +3666,17 @@ SubstTemplateTypeParmType::getReplacedParameter() const {
}
SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
- QualType Canon, Decl *AssociatedDecl, unsigned Index, bool Final,
+ QualType Canon, Decl *AssociatedDecl, unsigned Index,
const TemplateArgument &ArgPack)
: Type(SubstTemplateTypeParmPack, Canon,
TypeDependence::DependentInstantiation |
TypeDependence::UnexpandedPack),
- Arguments(ArgPack.pack_begin()),
- AssociatedDeclAndFinal(AssociatedDecl, Final) {
+ Arguments(ArgPack.pack_begin()), AssociatedDecl(AssociatedDecl) {
SubstTemplateTypeParmPackTypeBits.Index = Index;
SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size();
assert(AssociatedDecl != nullptr);
}
-Decl *SubstTemplateTypeParmPackType::getAssociatedDecl() const {
- return AssociatedDeclAndFinal.getPointer();
-}
-
-bool SubstTemplateTypeParmPackType::getFinal() const {
- return AssociatedDeclAndFinal.getInt();
-}
-
const TemplateTypeParmDecl *
SubstTemplateTypeParmPackType::getReplacedParameter() const {
return ::getReplacedParameter(getAssociatedDecl(), getIndex());
@@ -3700,16 +3691,15 @@ TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
}
void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
- Profile(ID, getAssociatedDecl(), getIndex(), getFinal(), getArgumentPack());
+ Profile(ID, getAssociatedDecl(), getIndex(), getArgumentPack());
}
void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
const Decl *AssociatedDecl,
- unsigned Index, bool Final,
+ unsigned Index,
const TemplateArgument &ArgPack) {
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
- ID.AddBoolean(Final);
ID.AddInteger(ArgPack.pack_size());
for (const auto &P : ArgPack.pack_elements())
ID.AddPointer(P.getAsType().getAsOpaquePtr());
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index 83b23b249d4e8..e5ee950e67997 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -454,8 +454,7 @@ bool Sema::SetupConstraintScope(
// the list of current template arguments to the list so that they also can
// be picked out of the map.
if (auto *SpecArgs = FD->getTemplateSpecializationArgs()) {
- MultiLevelTemplateArgumentList JustTemplArgs(FD, SpecArgs->asArray(),
- /*Final=*/false);
+ MultiLevelTemplateArgumentList JustTemplArgs(FD, SpecArgs->asArray());
if (addInstantiatedParametersToScope(
FD, PrimaryTemplate->getTemplatedDecl(), Scope, JustTemplArgs))
return true;
@@ -508,11 +507,10 @@ Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
// Collect the list of template arguments relative to the 'primary' template.
// We need the entire list, since the constraint is completely uninstantiated
// at this point.
- MLTAL =
- getTemplateInstantiationArgs(FD, /*Final=*/false, /*Innermost=*/nullptr,
- /*RelativeToPrimary=*/true,
- /*Pattern=*/nullptr,
- /*ForConstraintInstantiation=*/true);
+ MLTAL = getTemplateInstantiationArgs(FD, /*Innermost=*/nullptr,
+ /*RelativeToPrimary=*/true,
+ /*Pattern=*/nullptr,
+ /*ForConstraintInstantiation=*/true);
if (SetupConstraintScope(FD, TemplateArgs, MLTAL, Scope))
return llvm::None;
@@ -589,7 +587,7 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
static unsigned CalculateTemplateDepthForConstraints(Sema &S,
const NamedDecl *ND) {
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
- ND, /*Final=*/false, /*Innermost=*/nullptr, /*RelativeToPrimary=*/true,
+ ND, /*Innermost=*/nullptr, /*RelativeToPrimary=*/true,
/*Pattern=*/nullptr,
/*ForConstraintInstantiation=*/true);
return MLTAL.getNumSubstitutedLevels();
@@ -602,10 +600,8 @@ namespace {
using inherited = TreeTransform<AdjustConstraintDepth>;
AdjustConstraintDepth(Sema &SemaRef, unsigned TemplateDepth)
: inherited(SemaRef), TemplateDepth(TemplateDepth) {}
-
- using inherited::TransformTemplateTypeParmType;
QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL, bool) {
+ TemplateTypeParmTypeLoc TL) {
const TemplateTypeParmType *T = TL.getTypePtr();
TemplateTypeParmDecl *NewTTPDecl = nullptr;
@@ -1076,11 +1072,11 @@ static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
const ConceptSpecializationExpr *CSE) {
TemplateArgumentList TAL{TemplateArgumentList::OnStack,
CSE->getTemplateArguments()};
- MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
- CSE->getNamedConcept(), /*Final=*/false, &TAL,
- /*RelativeToPrimary=*/true,
- /*Pattern=*/nullptr,
- /*ForConstraintInstantiation=*/true);
+ MultiLevelTemplateArgumentList MLTAL =
+ S.getTemplateInstantiationArgs(CSE->getNamedConcept(), &TAL,
+ /*RelativeToPrimary=*/true,
+ /*Pattern=*/nullptr,
+ /*ForConstraintInstantiation=*/true);
return substituteParameterMappings(S, N, CSE->getNamedConcept(), MLTAL,
CSE->getTemplateArgsAsWritten());
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 25eeab370eeb8..470bdfd47fa33 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -8964,8 +8964,7 @@ Sema::BuildExprRequirement(
auto *Param = cast<TemplateTypeParmDecl>(TPL->getParam(0));
TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args);
- MultiLevelTemplateArgumentList MLTAL(Param, TAL.asArray(),
- /*Final=*/false);
+ MultiLevelTemplateArgumentList MLTAL(Param, TAL.asArray());
MLTAL.addOuterRetainedLevels(TPL->getDepth());
Expr *IDC = Param->getTypeConstraint()->getImmediatelyDeclaredConstraint();
ExprResult Constraint = SubstExpr(IDC, MLTAL);
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 73c681035b161..9c22fd91dd0ff 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -1720,17 +1720,14 @@ class ConstraintRefersToContainingTemplateChecker
// SubstTempalteTypeParmPack, SubstNonTypeTemplateParmPack, and
// FunctionParmPackExpr are all partially substituted, which cannot happen
// with concepts at this point in translation.
- using inherited::TransformTemplateTypeParmType;
QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL, bool) {
+ TemplateTypeParmTypeLoc TL) {
assert(TL.getDecl()->getDepth() <= TemplateDepth &&
"Nothing should reference a value below the actual template depth, "
"depth is likely wrong");
if (TL.getDecl()->getDepth() != TemplateDepth)
Result = true;
- return inherited::TransformTemplateTypeParmType(
- TLB, TL,
- /*SuppressObjCLifetime=*/false);
+ return inherited::TransformTemplateTypeParmType(TLB, TL);
}
Decl *TransformDecl(SourceLocation Loc, Decl *D) {
@@ -3852,10 +3849,13 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
if (Pattern->isInvalidDecl())
return QualType();
+ TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
+ CanonicalConverted);
+
// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
- TemplateArgLists.addOuterTemplateArguments(Template, CanonicalConverted,
- /*Final=*/false);
+ TemplateArgLists.addOuterTemplateArguments(Template,
+ StackTemplateArgs.asArray());
TemplateArgLists.addOuterRetainedLevels(
AliasTemplate->getTemplateParameters()->getDepth());
@@ -3981,9 +3981,9 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
ClassTemplate->getTemplatedDecl()->hasAttrs()) {
InstantiatingTemplate Inst(*this, TemplateLoc, Decl);
if (!Inst.isInvalid()) {
- MultiLevelTemplateArgumentList TemplateArgLists(Template,
- CanonicalConverted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList TemplateArgLists;
+ TemplateArgLists.addOuterTemplateArguments(Template,
+ CanonicalConverted);
InstantiateAttrsForDecl(TemplateArgLists,
ClassTemplate->getTemplatedDecl(), Decl);
}
@@ -4866,8 +4866,7 @@ Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
bool AreArgsDependent =
TemplateSpecializationType::anyDependentTemplateArguments(
*TemplateArgs, CanonicalConverted);
- MultiLevelTemplateArgumentList MLTAL(NamedConcept, CanonicalConverted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList MLTAL(NamedConcept, CanonicalConverted);
LocalInstantiationScope Scope(*this);
EnterExpressionEvaluationContext EECtx{
@@ -5279,9 +5278,11 @@ SubstDefaultTemplateArgument(Sema &SemaRef,
if (Inst.isInvalid())
return nullptr;
+ TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
+
// Only substitute for the innermost template argument list.
- MultiLevelTemplateArgumentList TemplateArgLists(Template, Converted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList TemplateArgLists(Template,
+ TemplateArgs.asArray());
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
TemplateArgLists.addOuterTemplateArguments(None);
@@ -5333,9 +5334,11 @@ SubstDefaultTemplateArgument(Sema &SemaRef,
if (Inst.isInvalid())
return ExprError();
+ TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
+
// Only substitute for the innermost template argument list.
- MultiLevelTemplateArgumentList TemplateArgLists(Template, Converted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList TemplateArgLists(Template,
+ TemplateArgs.asArray());
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
TemplateArgLists.addOuterTemplateArguments(None);
@@ -5384,9 +5387,11 @@ SubstDefaultTemplateArgument(Sema &SemaRef,
if (Inst.isInvalid())
return TemplateName();
+ TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
+
// Only substitute for the innermost template argument list.
- MultiLevelTemplateArgumentList TemplateArgLists(Template, Converted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList TemplateArgLists(Template,
+ TemplateArgs.asArray());
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
TemplateArgLists.addOuterTemplateArguments(None);
@@ -5567,8 +5572,10 @@ bool Sema::CheckTemplateArgument(
if (Inst.isInvalid())
return true;
- MultiLevelTemplateArgumentList MLTAL(Template, CanonicalConverted,
- /*Final=*/false);
+ TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
+ CanonicalConverted);
+
+ MultiLevelTemplateArgumentList MLTAL(Template, TemplateArgs.asArray());
// If the parameter is a pack expansion, expand this slice of the pack.
if (auto *PET = NTTPType->getAs<PackExpansionType>()) {
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this,
@@ -5730,10 +5737,9 @@ bool Sema::CheckTemplateArgument(
if (Inst.isInvalid())
return true;
- Params =
- SubstTemplateParams(Params, CurContext,
- MultiLevelTemplateArgumentList(
- Template, CanonicalConverted, /*Final=*/false));
+ Params = SubstTemplateParams(
+ Params, CurContext,
+ MultiLevelTemplateArgumentList(Template, CanonicalConverted));
if (!Params)
return true;
}
@@ -6132,8 +6138,7 @@ bool Sema::CheckTemplateArgumentList(
CXXThisScopeRAII(*this, RD, ThisQuals, RD != nullptr);
MultiLevelTemplateArgumentList MLTAL = getTemplateInstantiationArgs(
- Template, /*Final=*/false, &StackTemplateArgs,
- /*RelativeToPrimary=*/true,
+ Template, &StackTemplateArgs, /*RelativeToPrimary=*/true,
/*Pattern=*/nullptr,
/*ForConceptInstantiation=*/true);
if (EnsureTemplateArgumentListConstraints(
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 19f76e5d249c5..24629162ecfce 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -2687,8 +2687,9 @@ static bool ConvertDeducedTemplateArgument(
// itself, in case that substitution fails.
if (SugaredPackedArgsBuilder.empty()) {
LocalInstantiationScope Scope(S);
- MultiLevelTemplateArgumentList Args(Template, CanonicalOutput,
- /*Final=*/false);
+ TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
+ CanonicalOutput);
+ MultiLevelTemplateArgumentList Args(Template, TemplateArgs.asArray());
if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
@@ -2889,8 +2890,7 @@ CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
CanonicalDeducedArgs};
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
- Template, /*Final=*/false,
- /*InnerMost=*/NeedsReplacement ? nullptr : &DeducedTAL,
+ Template, /*InnerMost=*/NeedsReplacement ? nullptr : &DeducedTAL,
/*RelativeToPrimary=*/true, /*Pattern=*/
nullptr, /*ForConstraintInstantiation=*/true);
@@ -2959,12 +2959,11 @@ FinishTemplateArgumentDeduction(
TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
PartialTemplArgInfo->RAngleLoc);
- if (S.SubstTemplateArguments(PartialTemplArgInfo->arguments(),
- MultiLevelTemplateArgumentList(
- Partial,
- CanonicalDeducedArgumentList->asArray(),
- /*Final=*/false),
- InstArgs)) {
+ if (S.SubstTemplateArguments(
+ PartialTemplArgInfo->arguments(),
+ MultiLevelTemplateArgumentList(
+ Partial, CanonicalDeducedArgumentList->asArray()),
+ InstArgs)) {
unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
if (ParamIdx >= Partial->getTemplateParameters()->size())
ParamIdx = Partial->getTemplateParameters()->size() - 1;
@@ -3302,18 +3301,17 @@ Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
ExtParameterInfoBuilder ExtParamInfos;
- MultiLevelTemplateArgumentList MLTAL(FunctionTemplate,
- CanonicalExplicitArgumentList->asArray(),
- /*Final=*/false);
-
// Instantiate the types of each of the function parameters given the
// explicitly-specified template arguments. If the function has a trailing
// return type, substitute it after the arguments to ensure we substitute
// in lexical order.
if (Proto->hasTrailingReturn()) {
- if (SubstParmTypes(Function->getLocation(), Function->parameters(),
- Proto->getExtParameterInfosOrNull(), MLTAL, ParamTypes,
- /*params=*/nullptr, ExtParamInfos))
+ if (SubstParmTypes(
+ Function->getLocation(), Function->parameters(),
+ Proto->getExtParameterInfosOrNull(),
+ MultiLevelTemplateArgumentList(
+ FunctionTemplate, CanonicalExplicitArgumentList->asArray()),
+ ParamTypes, /*params=*/nullptr, ExtParamInfos))
return TDK_SubstitutionFailure;
}
@@ -3336,9 +3334,11 @@ Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
getLangOpts().CPlusPlus11);
- ResultType =
- SubstType(Proto->getReturnType(), MLTAL,
- Function->getTypeSpecStartLoc(), Function->getDeclName());
+ ResultType = SubstType(
+ Proto->getReturnType(),
+ MultiLevelTemplateArgumentList(
+ FunctionTemplate, CanonicalExplicitArgumentList->asArray()),
+ Function->getTypeSpecStartLoc(), Function->getDeclName());
if (ResultType.isNull() || Trap.hasErrorOccurred())
return TDK_SubstitutionFailure;
// CUDA: Kernel function must have 'void' return type.
@@ -3353,9 +3353,12 @@ Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
// Instantiate the types of each of the function parameters given the
// explicitly-specified template arguments if we didn't do so earlier.
if (!Proto->hasTrailingReturn() &&
- SubstParmTypes(Function->getLocation(), Function->parameters(),
- Proto->getExtParameterInfosOrNull(), MLTAL, ParamTypes,
- /*params*/ nullptr, ExtParamInfos))
+ SubstParmTypes(
+ Function->getLocation(), Function->parameters(),
+ Proto->getExtParameterInfosOrNull(),
+ MultiLevelTemplateArgumentList(
+ FunctionTemplate, CanonicalExplicitArgumentList->asArray()),
+ ParamTypes, /*params*/ nullptr, ExtParamInfos))
return TDK_SubstitutionFailure;
if (FunctionType) {
@@ -3367,8 +3370,10 @@ Sema::TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
// specification.
SmallVector<QualType, 4> ExceptionStorage;
if (getLangOpts().CPlusPlus17 &&
- SubstExceptionSpec(Function->getLocation(), EPI.ExceptionSpec,
- ExceptionStorage, MLTAL))
+ SubstExceptionSpec(
+ Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage,
+ MultiLevelTemplateArgumentList(
+ FunctionTemplate, CanonicalExplicitArgumentList->asArray())))
return TDK_SubstitutionFailure;
*FunctionType = BuildFunctionType(ResultType, ParamTypes,
@@ -3611,8 +3616,7 @@ Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
if (FunctionTemplate->getFriendObjectKind())
Owner = FunctionTemplate->getLexicalDeclContext();
MultiLevelTemplateArgumentList SubstArgs(
- FunctionTemplate, CanonicalDeducedArgumentList->asArray(),
- /*Final=*/false);
+ FunctionTemplate, CanonicalDeducedArgumentList->asArray());
Specialization = cast_or_null<FunctionDecl>(
SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs));
if (!Specialization || Specialization->isInvalidDecl())
@@ -4673,8 +4677,7 @@ static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
/*PartialTemplateArgs=*/false,
SugaredConverted, CanonicalConverted))
return true;
- MultiLevelTemplateArgumentList MLTAL(Concept, CanonicalConverted,
- /*Final=*/false);
+ MultiLevelTemplateArgumentList MLTAL(Concept, CanonicalConverted);
if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()},
MLTAL, TypeLoc.getLocalSourceRange(),
Satisfaction))
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 6d89f5e968aff..c19714c7a8b4d 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -94,15 +94,13 @@ HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
if (VarTemplatePartialSpecializationDecl *Partial =
Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
Result.addOuterTemplateArguments(
- Partial, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
- /*Final=*/false);
+ Partial, VarTemplSpec->getTemplateInstantiationArgs().asArray());
if (Partial->isMemberSpecialization())
return Response::Done();
} else {
VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
Result.addOuterTemplateArguments(
- Tmpl, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
- /*Final=*/false);
+ Tmpl, VarTemplSpec->getTemplateInstantiationArgs().asArray());
if (Tmpl->isMemberSpecialization())
return Response::Done();
}
@@ -135,8 +133,7 @@ HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
Result.addOuterTemplateArguments(
const_cast<ClassTemplateSpecializationDecl *>(ClassTemplSpec),
- ClassTemplSpec->getTemplateInstantiationArgs().asArray(),
- /*Final=*/false);
+ ClassTemplSpec->getTemplateInstantiationArgs().asArray());
// If this class template specialization was instantiated from a
// specialized member that is a class template, we're done.
@@ -167,8 +164,7 @@ Response HandleFunction(const FunctionDecl *Function,
Function->getTemplateSpecializationArgs()) {
// Add the template arguments for this specialization.
Result.addOuterTemplateArguments(const_cast<FunctionDecl *>(Function),
- TemplateArgs->asArray(),
- /*Final=*/false);
+ TemplateArgs->asArray());
// If this function was instantiated from a specialized member that is
// a function template, we're done.
@@ -214,8 +210,7 @@ Response HandleRecordDecl(const CXXRecordDecl *Rec,
->getInjectedSpecializationType();
const auto *InjectedType = cast<TemplateSpecializationType>(Injected);
Result.addOuterTemplateArguments(const_cast<CXXRecordDecl *>(Rec),
- InjectedType->template_arguments(),
- /*Final=*/false);
+ InjectedType->template_arguments());
}
}
@@ -241,8 +236,7 @@ Response HandleImplicitConceptSpecializationDecl(
MultiLevelTemplateArgumentList &Result) {
Result.addOuterTemplateArguments(
const_cast<ImplicitConceptSpecializationDecl *>(CSD),
- CSD->getTemplateArguments(),
- /*Final=*/false);
+ CSD->getTemplateArguments());
return Response::UseNextDecl(CSD);
}
@@ -277,7 +271,7 @@ Response HandleGenericDeclContext(const Decl *CurDecl) {
/// arguments on an enclosing class template.
MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
- const NamedDecl *ND, bool Final, const TemplateArgumentList *Innermost,
+ const NamedDecl *ND, const TemplateArgumentList *Innermost,
bool RelativeToPrimary, const FunctionDecl *Pattern,
bool ForConstraintInstantiation) {
assert(ND && "Can't find arguments for a decl if one isn't provided");
@@ -286,7 +280,7 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
if (Innermost)
Result.addOuterTemplateArguments(const_cast<NamedDecl *>(ND),
- Innermost->asArray(), Final);
+ Innermost->asArray());
const Decl *CurDecl = ND;
@@ -1126,13 +1120,6 @@ namespace {
return TemplateArgs.getNewDepth(Depth);
}
- Optional<unsigned> getPackIndex(TemplateArgument Pack) {
- int Index = getSema().ArgumentPackSubstitutionIndex;
- if (Index == -1)
- return None;
- return Pack.pack_size() - 1 - Index;
- }
-
bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
SourceRange PatternRange,
ArrayRef<UnexpandedParameterPack> Unexpanded,
@@ -1301,26 +1288,16 @@ namespace {
Optional<unsigned> NumExpansions,
bool ExpectParameterPack);
- using inherited::TransformTemplateTypeParmType;
/// Transforms a template type parameter type by performing
/// substitution of the corresponding template type argument.
QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL,
- bool SuppressObjCLifetime);
-
- QualType BuildSubstTemplateTypeParmType(
- TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final,
- Decl *AssociatedDecl, unsigned Index, Optional<unsigned> PackIndex,
- TemplateArgument Arg, SourceLocation NameLoc);
+ TemplateTypeParmTypeLoc TL);
/// Transforms an already-substituted template type parameter pack
/// into either itself (if we aren't substituting into its pack expansion)
/// or the appropriate substituted argument.
- using inherited::TransformSubstTemplateTypeParmPackType;
- QualType
- TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
- SubstTemplateTypeParmPackTypeLoc TL,
- bool SuppressObjCLifetime);
+ QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
+ SubstTemplateTypeParmPackTypeLoc TL);
ExprResult TransformLambdaExpr(LambdaExpr *E) {
LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
@@ -1603,8 +1580,7 @@ TemplateName TemplateInstantiator::TransformTemplateName(
return Arg.getAsTemplate();
}
- auto [AssociatedDecl, Final] =
- TemplateArgs.getAssociatedDecl(TTP->getDepth());
+ Decl *AssociatedDecl = TemplateArgs.getAssociatedDecl(TTP->getDepth());
Optional<unsigned> PackIndex;
if (TTP->isParameterPack()) {
assert(Arg.getKind() == TemplateArgument::Pack &&
@@ -1615,11 +1591,11 @@ TemplateName TemplateInstantiator::TransformTemplateName(
// actually expanding the enclosing pack expansion yet. So, just
// keep the entire argument pack.
return getSema().Context.getSubstTemplateTemplateParmPack(
- Arg, AssociatedDecl, TTP->getIndex(), Final);
+ Arg, AssociatedDecl, TTP->getIndex());
}
- PackIndex = getPackIndex(Arg);
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
+ PackIndex = getSema().ArgumentPackSubstitutionIndex;
}
TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
@@ -1627,10 +1603,9 @@ TemplateName TemplateInstantiator::TransformTemplateName(
assert(!Template.getAsQualifiedTemplateName() &&
"template decl to substitute is qualified?");
- if (Final)
- return Template;
- return getSema().Context.getSubstTemplateTemplateParm(
+ Template = getSema().Context.getSubstTemplateTemplateParm(
Template, AssociatedDecl, TTP->getIndex(), PackIndex);
+ return Template;
}
}
@@ -1639,14 +1614,9 @@ TemplateName TemplateInstantiator::TransformTemplateName(
if (getSema().ArgumentPackSubstitutionIndex == -1)
return Name;
- TemplateArgument Pack = SubstPack->getArgumentPack();
- TemplateName Template =
- getPackSubstitutedTemplateArgument(getSema(), Pack).getAsTemplate();
- if (SubstPack->getFinal())
- return Template;
- return getSema().Context.getSubstTemplateTemplateParm(
- Template.getNameToSubstitute(), SubstPack->getAssociatedDecl(),
- SubstPack->getIndex(), getPackIndex(Pack));
+ TemplateArgument Arg = SubstPack->getArgumentPack();
+ Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
+ return Arg.getAsTemplate().getNameToSubstitute();
}
return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
@@ -1690,7 +1660,7 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
return Arg.getAsExpr();
}
- auto [AssociatedDecl, _] = TemplateArgs.getAssociatedDecl(NTTP->getDepth());
+ Decl *AssociatedDecl = TemplateArgs.getAssociatedDecl(NTTP->getDepth());
Optional<unsigned> PackIndex;
if (NTTP->isParameterPack()) {
assert(Arg.getKind() == TemplateArgument::Pack &&
@@ -1709,15 +1679,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());
}
- PackIndex = getPackIndex(Arg);
+ PackIndex = getSema().ArgumentPackSubstitutionIndex;
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
}
- // FIXME: Don't put subst node on Final replacement.
+
return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP, E->getLocation(),
Arg, PackIndex);
}
@@ -1809,7 +1779,6 @@ 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);
@@ -1818,17 +1787,17 @@ ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
ExprResult
TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
SubstNonTypeTemplateParmPackExpr *E) {
- if (getSema().ArgumentPackSubstitutionIndex == -1) {
+ int PackIndex = getSema().ArgumentPackSubstitutionIndex;
+ if (PackIndex == -1) {
// We aren't expanding the parameter pack, so just return ourselves.
return E;
}
- TemplateArgument Pack = E->getArgumentPack();
- TemplateArgument Arg = getPackSubstitutedTemplateArgument(getSema(), Pack);
- // FIXME: Don't put subst node on final replacement.
+ TemplateArgument Arg = E->getArgumentPack();
+ Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
return transformNonTypeTemplateParmRef(
E->getAssociatedDecl(), E->getParameterPack(),
- E->getParameterPackLocation(), Arg, getPackIndex(Pack));
+ E->getParameterPackLocation(), Arg, PackIndex);
}
ExprResult
@@ -1871,7 +1840,7 @@ TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
return true;
return transformNonTypeTemplateParmRef(E->getAssociatedDecl(),
E->getParameter(), E->getExprLoc(),
- SugaredConverted, E->getPackIndex());
+ CanonicalConverted, E->getPackIndex());
}
ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(VarDecl *PD,
@@ -2002,39 +1971,9 @@ TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
return NewParm;
}
-QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
- TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final,
- Decl *AssociatedDecl, unsigned Index, Optional<unsigned> PackIndex,
- TemplateArgument Arg, SourceLocation NameLoc) {
- QualType Replacement = Arg.getAsType();
-
- // If the template parameter had ObjC lifetime qualifiers,
- // then any such qualifiers on the replacement type are ignored.
- if (SuppressObjCLifetime) {
- Qualifiers RQs;
- RQs = Replacement.getQualifiers();
- RQs.removeObjCLifetime();
- Replacement =
- 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);
- SubstTemplateTypeParmTypeLoc NewTL =
- TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
- NewTL.setNameLoc(NameLoc);
- return Result;
-}
-
QualType
TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL,
- bool SuppressObjCLifetime) {
+ TemplateTypeParmTypeLoc TL) {
const TemplateTypeParmType *T = TL.getTypePtr();
if (T->getDepth() < TemplateArgs.getNumLevels()) {
// Replace the template type parameter with its corresponding
@@ -2071,8 +2010,8 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
return NewT;
}
- auto [AssociatedDecl, Final] =
- TemplateArgs.getAssociatedDecl(T->getDepth());
+ Decl *AssociatedDecl =
+ const_cast<Decl *>(TemplateArgs.getAssociatedDecl(T->getDepth()));
Optional<unsigned> PackIndex;
if (T->isParameterPack()) {
assert(Arg.getKind() == TemplateArgument::Pack &&
@@ -2083,7 +2022,7 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
// enclosing pack expansion yet. Just save the template argument
// pack for later substitution.
QualType Result = getSema().Context.getSubstTemplateTypeParmPackType(
- AssociatedDecl, T->getIndex(), Final, Arg);
+ AssociatedDecl, T->getIndex(), Arg);
SubstTemplateTypeParmPackTypeLoc NewTL
= TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
@@ -2091,16 +2030,22 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
}
// PackIndex starts from last element.
- PackIndex = getPackIndex(Arg);
+ PackIndex = Arg.pack_size() - 1 - getSema().ArgumentPackSubstitutionIndex;
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
}
assert(Arg.getKind() == TemplateArgument::Type &&
"Template argument kind mismatch");
- return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
- AssociatedDecl, T->getIndex(),
- PackIndex, Arg, TL.getNameLoc());
+ QualType Replacement = Arg.getAsType();
+
+ // TODO: only do this uniquing once, at the start of instantiation.
+ QualType Result = getSema().Context.getSubstTemplateTypeParmType(
+ Replacement, AssociatedDecl, T->getIndex(), PackIndex);
+ SubstTemplateTypeParmTypeLoc NewTL
+ = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
+ NewTL.setNameLoc(TL.getNameLoc());
+ return Result;
}
// The template type parameter comes from an inner template (e.g.,
@@ -2120,8 +2065,7 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
}
QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
- TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL,
- bool SuppressObjCLifetime) {
+ TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL) {
const SubstTemplateTypeParmPackType *T = TL.getTypePtr();
Decl *NewReplaced = TransformDecl(TL.getNameLoc(), T->getAssociatedDecl());
@@ -2131,7 +2075,7 @@ QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
QualType Result = TL.getType();
if (NewReplaced != T->getAssociatedDecl())
Result = getSema().Context.getSubstTemplateTypeParmPackType(
- NewReplaced, T->getIndex(), T->getFinal(), T->getArgumentPack());
+ NewReplaced, T->getIndex(), T->getArgumentPack());
SubstTemplateTypeParmPackTypeLoc NewTL =
TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
@@ -2140,9 +2084,14 @@ QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
TemplateArgument Pack = T->getArgumentPack();
TemplateArgument Arg = getPackSubstitutedTemplateArgument(getSema(), Pack);
- return BuildSubstTemplateTypeParmType(
- TLB, SuppressObjCLifetime, T->getFinal(), NewReplaced, T->getIndex(),
- getPackIndex(Pack), Arg, TL.getNameLoc());
+ // PackIndex starts from last element.
+ QualType Result = getSema().Context.getSubstTemplateTypeParmType(
+ Arg.getAsType(), NewReplaced, T->getIndex(),
+ Pack.pack_size() - 1 - getSema().ArgumentPackSubstitutionIndex);
+ SubstTemplateTypeParmTypeLoc NewTL =
+ TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
+ NewTL.setNameLoc(TL.getNameLoc());
+ return Result;
}
template<typename EntityPrinter>
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index e471cb3de81c6..112137a2dcfb9 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -4552,8 +4552,8 @@ bool Sema::InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
//
// template<typename T>
// A<T> Foo(int a = A<T>::FooImpl());
- MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
- FD, /*Final=*/false, nullptr, /*RelativeToPrimary=*/true);
+ MultiLevelTemplateArgumentList TemplateArgs
+ = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true);
if (SubstDefaultArgument(CallLoc, Param, TemplateArgs, /*ForCallExpr*/ true))
return true;
@@ -4591,8 +4591,8 @@ void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
Sema::ContextRAII savedContext(*this, Decl);
LocalInstantiationScope Scope(*this);
- MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
- Decl, /*Final=*/false, nullptr, /*RelativeToPrimary*/ true);
+ MultiLevelTemplateArgumentList TemplateArgs =
+ getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
// FIXME: We can't use getTemplateInstantiationPattern(false) in general
// here, because for a non-defining friend declaration in a class template,
@@ -4766,8 +4766,7 @@ Sema::InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
return nullptr;
ContextRAII SavedContext(*this, FD);
- MultiLevelTemplateArgumentList MArgs(FTD, Args->asArray(),
- /*Final=*/false);
+ MultiLevelTemplateArgumentList MArgs(FTD, Args->asArray());
return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
}
@@ -5033,8 +5032,8 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
RebuildTypeSourceInfoForDefaultSpecialMembers();
SetDeclDefaulted(Function, PatternDecl->getLocation());
} else {
- MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
- Function, /*Final=*/false, nullptr, false, PatternDecl);
+ MultiLevelTemplateArgumentList TemplateArgs =
+ getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
// Substitute into the qualifier; we can get a substitution failure here
// through evil use of alias templates.
@@ -5126,13 +5125,13 @@ VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
if (auto *PartialSpec =
dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar)) {
IsMemberSpec = PartialSpec->isMemberSpecialization();
- MultiLevelList.addOuterTemplateArguments(
- PartialSpec, TemplateArgList.asArray(), /*Final=*/false);
+ MultiLevelList.addOuterTemplateArguments(PartialSpec,
+ TemplateArgList.asArray());
} else {
assert(VarTemplate == FromVar->getDescribedVarTemplate());
IsMemberSpec = VarTemplate->isMemberSpecialization();
- MultiLevelList.addOuterTemplateArguments(
- VarTemplate, TemplateArgList.asArray(), /*Final=*/false);
+ MultiLevelList.addOuterTemplateArguments(VarTemplate,
+ TemplateArgList.asArray());
}
if (!IsMemberSpec)
FromVar = FromVar->getFirstDecl();
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 9b2a5c7ef8e27..3fe85a2e837ab 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -829,8 +829,8 @@ static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator,
/// Apply Objective-C type arguments to the given type.
static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type,
ArrayRef<TypeSourceInfo *> typeArgs,
- SourceRange typeArgsRange, bool failOnError,
- bool rebuilding) {
+ SourceRange typeArgsRange,
+ bool failOnError = false) {
// We can only apply type arguments to an Objective-C class type.
const auto *objcObjectType = type->getAs<ObjCObjectType>();
if (!objcObjectType || !objcObjectType->getInterface()) {
@@ -894,9 +894,7 @@ static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type,
}
}
- // When rebuilding, qualifiers might have gotten here through a
- // final substitution.
- if (!rebuilding && !diagnosed) {
+ if (!diagnosed) {
S.Diag(qual.getBeginLoc(), diag::err_objc_type_arg_qualified)
<< typeArg << typeArg.getQualifiers().getAsString()
<< FixItHint::CreateRemoval(rangeToRemove);
@@ -1058,18 +1056,22 @@ QualType Sema::BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
return Result;
}
-QualType Sema::BuildObjCObjectType(
- QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc,
- ArrayRef<TypeSourceInfo *> TypeArgs, SourceLocation TypeArgsRAngleLoc,
- SourceLocation ProtocolLAngleLoc, ArrayRef<ObjCProtocolDecl *> Protocols,
- ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc,
- bool FailOnError, bool Rebuilding) {
+QualType Sema::BuildObjCObjectType(QualType BaseType,
+ SourceLocation Loc,
+ SourceLocation TypeArgsLAngleLoc,
+ ArrayRef<TypeSourceInfo *> TypeArgs,
+ SourceLocation TypeArgsRAngleLoc,
+ SourceLocation ProtocolLAngleLoc,
+ ArrayRef<ObjCProtocolDecl *> Protocols,
+ ArrayRef<SourceLocation> ProtocolLocs,
+ SourceLocation ProtocolRAngleLoc,
+ bool FailOnError) {
QualType Result = BaseType;
if (!TypeArgs.empty()) {
- Result =
- applyObjCTypeArgs(*this, Loc, Result, TypeArgs,
- SourceRange(TypeArgsLAngleLoc, TypeArgsRAngleLoc),
- FailOnError, Rebuilding);
+ Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs,
+ SourceRange(TypeArgsLAngleLoc,
+ TypeArgsRAngleLoc),
+ FailOnError);
if (FailOnError && Result.isNull())
return QualType();
}
@@ -1168,11 +1170,10 @@ TypeResult Sema::actOnObjCTypeArgsAndProtocolQualifiers(
T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(),
TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
ProtocolLAngleLoc,
- llvm::makeArrayRef((ObjCProtocolDecl *const *)Protocols.data(),
+ llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(),
Protocols.size()),
ProtocolLocs, ProtocolRAngleLoc,
- /*FailOnError=*/false,
- /*Rebuilding=*/false);
+ /*FailOnError=*/false);
if (Result == T)
return BaseType;
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index f0d3a5ca089a3..031856ceb56a1 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -636,14 +636,6 @@ class TreeTransform {
QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
#include "clang/AST/TypeLocNodes.def"
- QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
- TemplateTypeParmTypeLoc TL,
- bool SuppressObjCLifetime);
- QualType
- TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
- SubstTemplateTypeParmPackTypeLoc TL,
- bool SuppressObjCLifetime);
-
template<typename Fn>
QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
FunctionProtoTypeLoc TL,
@@ -1293,10 +1285,9 @@ class TreeTransform {
/// template name. Subclasses may override this routine to provide
diff erent
/// behavior.
TemplateName RebuildTemplateName(const TemplateArgument &ArgPack,
- Decl *AssociatedDecl, unsigned Index,
- bool Final) {
+ Decl *AssociatedDecl, unsigned Index) {
return getSema().Context.getSubstTemplateTemplateParmPack(
- ArgPack, AssociatedDecl, Index, Final);
+ ArgPack, AssociatedDecl, Index);
}
/// Build a new compound statement.
@@ -4161,13 +4152,9 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
NestedNameSpecifierLoc NNS, QualType ObjectType,
NamedDecl *FirstQualifierInScope) {
SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
-
- auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) {
- for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
- Qualifier = Qualifier.getPrefix())
- Qualifiers.push_back(Qualifier);
- };
- insertNNS(NNS);
+ for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
+ Qualifier = Qualifier.getPrefix())
+ Qualifiers.push_back(Qualifier);
CXXScopeSpec SS;
while (!Qualifiers.empty()) {
@@ -4224,17 +4211,14 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
if (!TL)
return NestedNameSpecifierLoc();
- QualType T = TL.getType();
- if (T->isDependentType() || T->isRecordType() ||
- (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) {
- if (T->isEnumeralType())
+ if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
+ (SemaRef.getLangOpts().CPlusPlus11 &&
+ TL.getType()->isEnumeralType())) {
+ assert(!TL.getType().hasLocalQualifiers() &&
+ "Can't get cv-qualifiers here");
+ if (TL.getType()->isEnumeralType())
SemaRef.Diag(TL.getBeginLoc(),
diag::warn_cxx98_compat_enum_nested_name_spec);
-
- if (const auto ETL = TL.getAs<ElaboratedTypeLoc>()) {
- SS.Adopt(ETL.getQualifierLoc());
- TL = ETL.getNamedTypeLoc();
- }
SS.Extend(SemaRef.Context, /*FIXME:*/ SourceLocation(), TL,
Q.getLocalEndLoc());
break;
@@ -4244,7 +4228,7 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>();
if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
- << T << SS.getRange();
+ << TL.getType() << SS.getRange();
}
return NestedNameSpecifierLoc();
}
@@ -4407,9 +4391,9 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
if (SubstTemplateTemplateParmPackStorage *SubstPack
= Name.getAsSubstTemplateTemplateParmPack()) {
- return getDerived().RebuildTemplateName(
- SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
- SubstPack->getIndex(), SubstPack->getFinal());
+ return getDerived().RebuildTemplateName(SubstPack->getArgumentPack(),
+ SubstPack->getAssociatedDecl(),
+ SubstPack->getIndex());
}
// These should be getting filtered out before they reach the AST.
@@ -4823,20 +4807,7 @@ template<typename Derived>
QualType
TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
QualifiedTypeLoc T) {
- QualType Result;
- TypeLoc UnqualTL = T.getUnqualifiedLoc();
- auto SuppressObjCLifetime =
- T.getType().getLocalQualifiers().hasObjCLifetime();
- if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) {
- Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
- SuppressObjCLifetime);
- } else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) {
- Result = getDerived().TransformSubstTemplateTypeParmPackType(
- TLB, STTP, SuppressObjCLifetime);
- } else {
- Result = getDerived().TransformType(TLB, UnqualTL);
- }
-
+ QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
if (Result.isNull())
return QualType();
@@ -4899,7 +4870,17 @@ QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
// A lifetime qualifier applied to a substituted template parameter
// overrides the lifetime qualifier from the template argument.
const AutoType *AutoTy;
- if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
+ if (const SubstTemplateTypeParmType *SubstTypeParam
+ = dyn_cast<SubstTemplateTypeParmType>(T)) {
+ QualType Replacement = SubstTypeParam->getReplacementType();
+ Qualifiers Qs = Replacement.getQualifiers();
+ Qs.removeObjCLifetime();
+ Replacement = SemaRef.Context.getQualifiedType(
+ Replacement.getUnqualifiedType(), Qs);
+ T = SemaRef.Context.getSubstTemplateTypeParmType(
+ Replacement, SubstTypeParam->getAssociatedDecl(),
+ SubstTypeParam->getIndex(), SubstTypeParam->getPackIndex());
+ } else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
// 'auto' types behave the same way as template parameters.
QualType Deduced = AutoTy->getDeducedType();
Qualifiers Qs = Deduced.getQualifiers();
@@ -6441,14 +6422,6 @@ template<typename Derived>
QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
TemplateTypeParmTypeLoc TL) {
- return getDerived().TransformTemplateTypeParmType(
- TLB, TL,
- /*SuppressObjCLifetime=*/false);
-}
-
-template <typename Derived>
-QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
- TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
}
@@ -6484,13 +6457,6 @@ template<typename Derived>
QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
TypeLocBuilder &TLB,
SubstTemplateTypeParmPackTypeLoc TL) {
- return getDerived().TransformSubstTemplateTypeParmPackType(
- TLB, TL, /*SuppressObjCLifetime=*/false);
-}
-
-template <typename Derived>
-QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
- TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
}
@@ -7274,8 +7240,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
TypeLocBuilder TypeArgBuilder;
TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
- QualType NewTypeArg =
- getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
+ QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
if (NewTypeArg.isNull())
return QualType();
@@ -14565,11 +14530,11 @@ QualType TreeTransform<Derived>::RebuildObjCObjectType(
ArrayRef<ObjCProtocolDecl *> Protocols,
ArrayRef<SourceLocation> ProtocolLocs,
SourceLocation ProtocolRAngleLoc) {
- return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, TypeArgs,
- TypeArgsRAngleLoc, ProtocolLAngleLoc,
- Protocols, ProtocolLocs, ProtocolRAngleLoc,
- /*FailOnError=*/true,
- /*Rebuilding=*/true);
+ return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
+ TypeArgs, TypeArgsRAngleLoc,
+ ProtocolLAngleLoc, Protocols, ProtocolLocs,
+ ProtocolRAngleLoc,
+ /*FailOnError=*/true);
}
template<typename Derived>
diff --git a/clang/lib/Sema/TypeLocBuilder.cpp b/clang/lib/Sema/TypeLocBuilder.cpp
index fcd090ff20200..3699b5dffe8a3 100644
--- a/clang/lib/Sema/TypeLocBuilder.cpp
+++ b/clang/lib/Sema/TypeLocBuilder.cpp
@@ -41,29 +41,6 @@ void TypeLocBuilder::pushFullCopy(TypeLoc L) {
}
}
-void TypeLocBuilder::pushTrivial(ASTContext &Context, QualType T,
- SourceLocation Loc) {
- auto L = TypeLoc(T, nullptr);
- reserve(L.getFullDataSize());
-
- SmallVector<TypeLoc, 4> TypeLocs;
- for (auto CurTL = L; CurTL; CurTL = CurTL.getNextTypeLoc())
- TypeLocs.push_back(CurTL);
-
- for (const auto &CurTL : llvm::reverse(TypeLocs)) {
- switch (CurTL.getTypeLocClass()) {
-#define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
- case TypeLoc::CLASS: { \
- auto NewTL = push<class CLASS##TypeLoc>(CurTL.getType()); \
- NewTL.initializeLocal(Context, Loc); \
- break; \
- }
-#include "clang/AST/TypeLocNodes.def"
- }
- }
-}
-
void TypeLocBuilder::grow(size_t NewCapacity) {
assert(NewCapacity > Capacity);
diff --git a/clang/lib/Sema/TypeLocBuilder.h b/clang/lib/Sema/TypeLocBuilder.h
index d413d74b74ff9..9e7422ec9906c 100644
--- a/clang/lib/Sema/TypeLocBuilder.h
+++ b/clang/lib/Sema/TypeLocBuilder.h
@@ -64,10 +64,6 @@ class TypeLocBuilder {
/// must be empty for this to work.
void pushFullCopy(TypeLoc L);
- /// Pushes 'T' with all locations pointing to 'Loc'.
- /// The builder must be empty for this to work.
- void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc);
-
/// Pushes space for a typespec TypeLoc. Invalidates any TypeLocs
/// previously retrieved from this builder.
TypeSpecTypeLoc pushTypeSpec(QualType T) {
diff --git a/clang/test/SemaTemplate/nested-name-spec-template.cpp b/clang/test/SemaTemplate/nested-name-spec-template.cpp
index c7763510f6889..07dd41bfe27bf 100644
--- a/clang/test/SemaTemplate/nested-name-spec-template.cpp
+++ b/clang/test/SemaTemplate/nested-name-spec-template.cpp
@@ -147,10 +147,3 @@ namespace PR9449 {
template void f<int>(); // expected-note{{in instantiation of}}
}
-
-namespace sugared_template_instantiation {
- // Test that we ignore local qualifiers.
- template <class A1, class = typename A1::type1> struct A {};
- struct B { typedef int type1; };
- typedef A<const B> type2;
-} // namespace sugated_template_instantiation
More information about the cfe-commits
mailing list