From a88f09f34e86125ee4e6949a757aaed314012664 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Mon, 28 Feb 2011 17:23:35 +0000 Subject: [PATCH] Eliminate the last remains of TemplateSpecializationTypes with dependent template names. There is still a lot of redundant code in TreeTransform to cope with TemplateSpecializationTypes, which I'll remove in stages. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@126656 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AST/Type.cpp | 5 +- lib/AST/TypePrinter.cpp | 3 +- lib/Sema/SemaTemplate.cpp | 20 +++++++ lib/Sema/TreeTransform.h | 108 +++++++++++++++++++++++++++++++++----- 4 files changed, 120 insertions(+), 16 deletions(-) diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp index d1136adbab..cde865f5b9 100644 --- a/lib/AST/Type.cpp +++ b/lib/AST/Type.cpp @@ -1357,10 +1357,11 @@ TemplateSpecializationType(TemplateName T, unsigned NumArgs, QualType Canon) : Type(TemplateSpecialization, Canon.isNull()? QualType(this, 0) : Canon, - T.isDependent(), false, - T.containsUnexpandedParameterPack()), + T.isDependent(), false, T.containsUnexpandedParameterPack()), Template(T), NumArgs(NumArgs) { + assert(!T.getAsDependentTemplateName() && + "Use DependentTemplateSpecializationType for dependent template-name"); assert((!Canon.isNull() || T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)) && "No canonical type for non-dependent class template specialization"); diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp index 139073987a..4e966083bb 100644 --- a/lib/AST/TypePrinter.cpp +++ b/lib/AST/TypePrinter.cpp @@ -737,7 +737,8 @@ void TypePrinter::printDependentTemplateSpecialization( if (T->getKeyword() != ETK_None) OS << " "; - T->getQualifier()->print(OS, Policy); + if (T->getQualifier()) + T->getQualifier()->print(OS, Policy); OS << T->getIdentifier()->getName(); OS << TemplateSpecializationType::PrintTemplateArgumentList( T->getArgs(), diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 625944d797..cbfd7b0939 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -1756,6 +1756,26 @@ Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc, TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); translateTemplateArguments(TemplateArgsIn, TemplateArgs); + if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { + QualType T = Context.getDependentTemplateSpecializationType(ETK_None, + DTN->getQualifier(), + DTN->getIdentifier(), + TemplateArgs); + + // Build type-source information. + TypeLocBuilder TLB; + DependentTemplateSpecializationTypeLoc SpecTL + = TLB.push(T); + SpecTL.setKeywordLoc(SourceLocation()); // FIXME: 'template' location + SpecTL.setNameLoc(TemplateLoc); + SpecTL.setLAngleLoc(LAngleLoc); + SpecTL.setRAngleLoc(RAngleLoc); + SpecTL.setQualifierRange(TemplateLoc); // FIXME: nested-name-specifier loc + for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I) + SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); + return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T)); + } + QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs); TemplateArgsIn.release(); diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index fa4637a27e..8f875fbef0 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -488,6 +488,11 @@ public: TemplateSpecializationTypeLoc TL, TemplateName Template); + QualType + TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, + DependentTemplateSpecializationTypeLoc TL, + TemplateName Template); + QualType TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL, @@ -754,11 +759,10 @@ public: getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); if (T.isNull()) return QualType(); - if (Keyword == ETK_None) + if (Keyword == ETK_None && Qualifier == 0) return T; - // NOTE: NNS is already recorded in template specialization type T. - return SemaRef.Context.getElaboratedType(Keyword, /*NNS=*/0, T); + return SemaRef.Context.getElaboratedType(Keyword, Qualifier, T); } /// \brief Build a new typename type that refers to an identifier. @@ -3240,8 +3244,18 @@ TreeTransform::TransformTypeInObjectScope(TypeSourceInfo *TSI, DependentTemplateSpecializationTypeLoc TL = cast(TSI->getTypeLoc()); - Result = getDerived() - .TransformDependentTemplateSpecializationType(TLB, TL, Prefix); + TemplateName Template + = SemaRef.Context.getDependentTemplateName( + TL.getTypePtr()->getQualifier(), + TL.getTypePtr()->getIdentifier()); + + Template = getDerived().TransformTemplateName(Template, ObjectType, + UnqualLookup); + if (Template.isNull()) + return 0; + + Result = getDerived().TransformDependentTemplateSpecializationType(TLB, TL, + Template); } else { // Nothing special needs to be done for these. Result = getDerived().TransformType(TLB, TSI->getTypeLoc()); @@ -3293,9 +3307,19 @@ TreeTransform::TransformTypeInObjectScope(TypeLoc TL, DependentTemplateSpecializationTypeLoc SpecTL = cast(TL); + TemplateName Template + = SemaRef.Context.getDependentTemplateName( + SpecTL.getTypePtr()->getQualifier(), + SpecTL.getTypePtr()->getIdentifier()); + + Template = getDerived().TransformTemplateName(Template, ObjectType, + UnqualLookup); + if (Template.isNull()) + return TypeLoc(); + Result = getDerived().TransformDependentTemplateSpecializationType(TLB, - SpecTL, - SS.getScopeRep()); + SpecTL, + Template); } else { // Nothing special needs to be done for these. Result = getDerived().TransformType(TLB, TL); @@ -4365,6 +4389,62 @@ QualType TreeTransform::TransformTemplateSpecializationType( return Result; } +template +QualType TreeTransform::TransformDependentTemplateSpecializationType( + TypeLocBuilder &TLB, + DependentTemplateSpecializationTypeLoc TL, + TemplateName Template) { + TemplateArgumentListInfo NewTemplateArgs; + NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); + NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); + typedef TemplateArgumentLocContainerIterator< + DependentTemplateSpecializationTypeLoc> ArgIterator; + if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), + ArgIterator(TL, TL.getNumArgs()), + NewTemplateArgs)) + return QualType(); + + // FIXME: maybe don't rebuild if all the template arguments are the same. + + if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { + QualType Result + = getSema().Context.getDependentTemplateSpecializationType( + TL.getTypePtr()->getKeyword(), + DTN->getQualifier(), + DTN->getIdentifier(), + NewTemplateArgs); + + DependentTemplateSpecializationTypeLoc NewTL + = TLB.push(Result); + NewTL.setKeywordLoc(TL.getKeywordLoc()); + NewTL.setQualifierRange(TL.getQualifierRange()); + NewTL.setNameLoc(TL.getNameLoc()); + NewTL.setLAngleLoc(TL.getLAngleLoc()); + NewTL.setRAngleLoc(TL.getRAngleLoc()); + for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) + NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); + return Result; + } + + QualType Result + = getDerived().RebuildTemplateSpecializationType(Template, + TL.getNameLoc(), + NewTemplateArgs); + + if (!Result.isNull()) { + /// FIXME: Wrap this in an elaborated-type-specifier? + TemplateSpecializationTypeLoc NewTL + = TLB.push(Result); + NewTL.setTemplateNameLoc(TL.getNameLoc()); + NewTL.setLAngleLoc(TL.getLAngleLoc()); + NewTL.setRAngleLoc(TL.getRAngleLoc()); + for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) + NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); + } + + return Result; +} + template QualType TreeTransform::TransformElaboratedType(TypeLocBuilder &TLB, @@ -4502,12 +4582,14 @@ QualType TreeTransform:: DependentTemplateSpecializationTypeLoc TL) { const DependentTemplateSpecializationType *T = TL.getTypePtr(); - NestedNameSpecifier *NNS - = getDerived().TransformNestedNameSpecifier(T->getQualifier(), - TL.getQualifierRange()); - if (!NNS) - return QualType(); - + NestedNameSpecifier *NNS = 0; + if (T->getQualifier()) { + NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(), + TL.getQualifierRange()); + if (!NNS) + return QualType(); + } + return getDerived() .TransformDependentTemplateSpecializationType(TLB, TL, NNS); } -- 2.40.0