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 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
