Skip to content

Commit de6aa08

Browse files
akyrtziakyrtzi
committed
Rename ExplicitTemplateArgumentList -> ASTTemplateArgumentListInfo, no functionality change.
llvm-svn: 140330
1 parent 34a1d37 commit de6aa08

File tree

8 files changed

+70
-68
lines changed

8 files changed

+70
-68
lines changed

‎clang/include/clang/AST/Expr.h

Lines changed: 14 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -690,7 +690,9 @@ class OpaqueValueExpr : public Expr {
690690

691691
/// \brief Represents an explicit template argument list in C++, e.g.,
692692
/// the "<int>" in "sort<int>".
693-
struct ExplicitTemplateArgumentList {
693+
/// This is safe to be used inside an AST node, in contrast with
694+
/// TemplateArgumentListInfo.
695+
struct ASTTemplateArgumentListInfo {
694696
/// \brief The source location of the left angle bracket ('<');
695697
SourceLocation LAngleLoc;
696698

@@ -887,29 +889,29 @@ class DeclRefExpr : public Expr {
887889

888890
/// \brief Retrieve the explicit template argument list that followed the
889891
/// member template name.
890-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
892+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
891893
assert(hasExplicitTemplateArgs());
892894
if (hasFoundDecl())
893-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(
895+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(
894896
&getInternalFoundDecl() + 1);
895897

896898
if (hasQualifier())
897-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(
899+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(
898900
&getInternalQualifierLoc() + 1);
899901

900-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(this + 1);
902+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
901903
}
902904

903905
/// \brief Retrieve the explicit template argument list that followed the
904906
/// member template name.
905-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
907+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
906908
return const_cast<DeclRefExpr *>(this)->getExplicitTemplateArgs();
907909
}
908910

909911
/// \brief Retrieves the optional explicit template arguments.
910912
/// This points to the same data as getExplicitTemplateArgs(), but
911913
/// returns null if there are no explicit template arguments.
912-
const ExplicitTemplateArgumentList *getExplicitTemplateArgsOpt() const {
914+
const ASTTemplateArgumentListInfo *getExplicitTemplateArgsOpt() const {
913915
if (!hasExplicitTemplateArgs()) return 0;
914916
return &getExplicitTemplateArgs();
915917
}
@@ -2162,26 +2164,26 @@ class MemberExpr : public Expr {
21622164
/// \brief Retrieve the explicit template argument list that
21632165
/// follow the member template name. This must only be called on an
21642166
/// expression with explicit template arguments.
2165-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
2167+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
21662168
assert(HasExplicitTemplateArgumentList);
21672169
if (!HasQualifierOrFoundDecl)
2168-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(this + 1);
2170+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
21692171

2170-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(
2172+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(
21712173
getMemberQualifier() + 1);
21722174
}
21732175

21742176
/// \brief Retrieve the explicit template argument list that
21752177
/// followed the member template name. This must only be called on
21762178
/// an expression with explicit template arguments.
2177-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
2179+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
21782180
return const_cast<MemberExpr *>(this)->getExplicitTemplateArgs();
21792181
}
21802182

21812183
/// \brief Retrieves the optional explicit template arguments.
21822184
/// This points to the same data as getExplicitTemplateArgs(), but
21832185
/// returns null if there are no explicit template arguments.
2184-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() const {
2186+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
21852187
if (!hasExplicitTemplateArgs()) return 0;
21862188
return &getExplicitTemplateArgs();
21872189
}

‎clang/include/clang/AST/ExprCXX.h

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1842,16 +1842,16 @@ class OverloadExpr : public Expr {
18421842
/// template argument list, e.g. f<int>.
18431843
bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
18441844

1845-
ExplicitTemplateArgumentList &getExplicitTemplateArgs(); // defined far below
1845+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs(); // defined far below
18461846

1847-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
1847+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
18481848
return const_cast<OverloadExpr*>(this)->getExplicitTemplateArgs();
18491849
}
18501850

18511851
/// \brief Retrieves the optional explicit template arguments.
18521852
/// This points to the same data as getExplicitTemplateArgs(), but
18531853
/// returns null if there are no explicit template arguments.
1854-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() {
1854+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() {
18551855
if (!hasExplicitTemplateArgs()) return 0;
18561856
return &getExplicitTemplateArgs();
18571857
}
@@ -1969,21 +1969,21 @@ class UnresolvedLookupExpr : public OverloadExpr {
19691969
// nodes, users are *forbidden* from calling these methods on objects
19701970
// without explicit template arguments.
19711971

1972-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
1972+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
19731973
assert(hasExplicitTemplateArgs());
1974-
return *reinterpret_cast<ExplicitTemplateArgumentList*>(this + 1);
1974+
return *reinterpret_cast<ASTTemplateArgumentListInfo*>(this + 1);
19751975
}
19761976

19771977
/// Gets a reference to the explicit template argument list.
1978-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
1978+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
19791979
assert(hasExplicitTemplateArgs());
1980-
return *reinterpret_cast<const ExplicitTemplateArgumentList*>(this + 1);
1980+
return *reinterpret_cast<const ASTTemplateArgumentListInfo*>(this + 1);
19811981
}
19821982

19831983
/// \brief Retrieves the optional explicit template arguments.
19841984
/// This points to the same data as getExplicitTemplateArgs(), but
19851985
/// returns null if there are no explicit template arguments.
1986-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() {
1986+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() {
19871987
if (!hasExplicitTemplateArgs()) return 0;
19881988
return &getExplicitTemplateArgs();
19891989
}
@@ -2094,21 +2094,21 @@ class DependentScopeDeclRefExpr : public Expr {
20942094
// nodes, users are *forbidden* from calling these methods on objects
20952095
// without explicit template arguments.
20962096

2097-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
2097+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
20982098
assert(hasExplicitTemplateArgs());
2099-
return *reinterpret_cast<ExplicitTemplateArgumentList*>(this + 1);
2099+
return *reinterpret_cast<ASTTemplateArgumentListInfo*>(this + 1);
21002100
}
21012101

21022102
/// Gets a reference to the explicit template argument list.
2103-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
2103+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
21042104
assert(hasExplicitTemplateArgs());
2105-
return *reinterpret_cast<const ExplicitTemplateArgumentList*>(this + 1);
2105+
return *reinterpret_cast<const ASTTemplateArgumentListInfo*>(this + 1);
21062106
}
21072107

21082108
/// \brief Retrieves the optional explicit template arguments.
21092109
/// This points to the same data as getExplicitTemplateArgs(), but
21102110
/// returns null if there are no explicit template arguments.
2111-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() {
2111+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() {
21122112
if (!hasExplicitTemplateArgs()) return 0;
21132113
return &getExplicitTemplateArgs();
21142114
}
@@ -2470,22 +2470,22 @@ class CXXDependentScopeMemberExpr : public Expr {
24702470

24712471
/// \brief Retrieve the explicit template argument list that followed the
24722472
/// member template name, if any.
2473-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
2473+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
24742474
assert(HasExplicitTemplateArgs);
2475-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(this + 1);
2475+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
24762476
}
24772477

24782478
/// \brief Retrieve the explicit template argument list that followed the
24792479
/// member template name, if any.
2480-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
2480+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
24812481
return const_cast<CXXDependentScopeMemberExpr *>(this)
24822482
->getExplicitTemplateArgs();
24832483
}
24842484

24852485
/// \brief Retrieves the optional explicit template arguments.
24862486
/// This points to the same data as getExplicitTemplateArgs(), but
24872487
/// returns null if there are no explicit template arguments.
2488-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() {
2488+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() {
24892489
if (!hasExplicitTemplateArgs()) return 0;
24902490
return &getExplicitTemplateArgs();
24912491
}
@@ -2663,22 +2663,22 @@ class UnresolvedMemberExpr : public OverloadExpr {
26632663

26642664
/// \brief Retrieve the explicit template argument list that followed the
26652665
/// member template name.
2666-
ExplicitTemplateArgumentList &getExplicitTemplateArgs() {
2666+
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
26672667
assert(hasExplicitTemplateArgs());
2668-
return *reinterpret_cast<ExplicitTemplateArgumentList *>(this + 1);
2668+
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
26692669
}
26702670

26712671
/// \brief Retrieve the explicit template argument list that followed the
26722672
/// member template name, if any.
2673-
const ExplicitTemplateArgumentList &getExplicitTemplateArgs() const {
2673+
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
26742674
assert(hasExplicitTemplateArgs());
2675-
return *reinterpret_cast<const ExplicitTemplateArgumentList *>(this + 1);
2675+
return *reinterpret_cast<const ASTTemplateArgumentListInfo *>(this + 1);
26762676
}
26772677

26782678
/// \brief Retrieves the optional explicit template arguments.
26792679
/// This points to the same data as getExplicitTemplateArgs(), but
26802680
/// returns null if there are no explicit template arguments.
2681-
const ExplicitTemplateArgumentList *getOptionalExplicitTemplateArgs() {
2681+
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() {
26822682
if (!hasExplicitTemplateArgs()) return 0;
26832683
return &getExplicitTemplateArgs();
26842684
}
@@ -2856,7 +2856,7 @@ class PackExpansionExpr : public Expr {
28562856
}
28572857
};
28582858

2859-
inline ExplicitTemplateArgumentList &OverloadExpr::getExplicitTemplateArgs() {
2859+
inline ASTTemplateArgumentListInfo &OverloadExpr::getExplicitTemplateArgs() {
28602860
if (isa<UnresolvedLookupExpr>(this))
28612861
return cast<UnresolvedLookupExpr>(this)->getExplicitTemplateArgs();
28622862
else

‎clang/lib/AST/Expr.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,7 @@ SourceLocation Expr::getExprLoc() const {
130130
// Primary Expressions.
131131
//===----------------------------------------------------------------------===//
132132

133-
void ExplicitTemplateArgumentList::initializeFrom(
133+
void ASTTemplateArgumentListInfo::initializeFrom(
134134
const TemplateArgumentListInfo &Info) {
135135
LAngleLoc = Info.getLAngleLoc();
136136
RAngleLoc = Info.getRAngleLoc();
@@ -141,7 +141,7 @@ void ExplicitTemplateArgumentList::initializeFrom(
141141
new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
142142
}
143143

144-
void ExplicitTemplateArgumentList::initializeFrom(
144+
void ASTTemplateArgumentListInfo::initializeFrom(
145145
const TemplateArgumentListInfo &Info,
146146
bool &Dependent,
147147
bool &InstantiationDependent,
@@ -163,20 +163,20 @@ void ExplicitTemplateArgumentList::initializeFrom(
163163
}
164164
}
165165

166-
void ExplicitTemplateArgumentList::copyInto(
166+
void ASTTemplateArgumentListInfo::copyInto(
167167
TemplateArgumentListInfo &Info) const {
168168
Info.setLAngleLoc(LAngleLoc);
169169
Info.setRAngleLoc(RAngleLoc);
170170
for (unsigned I = 0; I != NumTemplateArgs; ++I)
171171
Info.addArgument(getTemplateArgs()[I]);
172172
}
173173

174-
std::size_t ExplicitTemplateArgumentList::sizeFor(unsigned NumTemplateArgs) {
175-
return sizeof(ExplicitTemplateArgumentList) +
174+
std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
175+
return sizeof(ASTTemplateArgumentListInfo) +
176176
sizeof(TemplateArgumentLoc) * NumTemplateArgs;
177177
}
178178

179-
std::size_t ExplicitTemplateArgumentList::sizeFor(
179+
std::size_t ASTTemplateArgumentListInfo::sizeFor(
180180
const TemplateArgumentListInfo &Info) {
181181
return sizeFor(Info.size());
182182
}
@@ -360,7 +360,7 @@ DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
360360
if (FoundD)
361361
Size += sizeof(NamedDecl *);
362362
if (TemplateArgs)
363-
Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
363+
Size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
364364

365365
void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
366366
return new (Mem) DeclRefExpr(QualifierLoc, D, NameInfo, FoundD, TemplateArgs,
@@ -378,7 +378,7 @@ DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context,
378378
if (HasFoundDecl)
379379
Size += sizeof(NamedDecl *);
380380
if (HasExplicitTemplateArgs)
381-
Size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
381+
Size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
382382

383383
void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
384384
return new (Mem) DeclRefExpr(EmptyShell());
@@ -952,7 +952,7 @@ MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
952952
Size += sizeof(MemberNameQualifier);
953953

954954
if (targs)
955-
Size += ExplicitTemplateArgumentList::sizeFor(*targs);
955+
Size += ASTTemplateArgumentListInfo::sizeFor(*targs);
956956

957957
void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
958958
MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo,

‎clang/lib/AST/ExprCXX.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,7 @@ UnresolvedLookupExpr::Create(ASTContext &C,
202202
UnresolvedSetIterator End)
203203
{
204204
void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
205-
ExplicitTemplateArgumentList::sizeFor(Args));
205+
ASTTemplateArgumentListInfo::sizeFor(Args));
206206
return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, NameInfo,
207207
ADL, /*Overload*/ true, &Args,
208208
Begin, End, /*StdIsAssociated=*/false);
@@ -213,7 +213,7 @@ UnresolvedLookupExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
213213
unsigned NumTemplateArgs) {
214214
std::size_t size = sizeof(UnresolvedLookupExpr);
215215
if (HasExplicitTemplateArgs)
216-
size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
216+
size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
217217

218218
void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
219219
UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
@@ -332,7 +332,7 @@ DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
332332
bool ContainsUnexpandedParameterPack
333333
= ExprBits.ContainsUnexpandedParameterPack;
334334

335-
reinterpret_cast<ExplicitTemplateArgumentList*>(this+1)
335+
reinterpret_cast<ASTTemplateArgumentListInfo*>(this+1)
336336
->initializeFrom(*Args, Dependent, InstantiationDependent,
337337
ContainsUnexpandedParameterPack);
338338

@@ -347,7 +347,7 @@ DependentScopeDeclRefExpr::Create(ASTContext &C,
347347
const TemplateArgumentListInfo *Args) {
348348
std::size_t size = sizeof(DependentScopeDeclRefExpr);
349349
if (Args)
350-
size += ExplicitTemplateArgumentList::sizeFor(*Args);
350+
size += ASTTemplateArgumentListInfo::sizeFor(*Args);
351351
void *Mem = C.Allocate(size);
352352
return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
353353
NameInfo, Args);
@@ -359,7 +359,7 @@ DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
359359
unsigned NumTemplateArgs) {
360360
std::size_t size = sizeof(DependentScopeDeclRefExpr);
361361
if (HasExplicitTemplateArgs)
362-
size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
362+
size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
363363
void *Mem = C.Allocate(size);
364364
DependentScopeDeclRefExpr *E
365365
= new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
@@ -838,7 +838,7 @@ CXXDependentScopeMemberExpr::Create(ASTContext &C,
838838

839839
std::size_t size = sizeof(CXXDependentScopeMemberExpr);
840840
if (TemplateArgs)
841-
size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
841+
size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
842842

843843
void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
844844
return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
@@ -859,7 +859,7 @@ CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
859859
DeclarationNameInfo());
860860

861861
std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
862-
ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
862+
ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
863863
void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
864864
CXXDependentScopeMemberExpr *E
865865
= new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
@@ -947,7 +947,7 @@ UnresolvedMemberExpr::Create(ASTContext &C,
947947
UnresolvedSetIterator End) {
948948
std::size_t size = sizeof(UnresolvedMemberExpr);
949949
if (TemplateArgs)
950-
size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
950+
size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
951951

952952
void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
953953
return new (Mem) UnresolvedMemberExpr(C,
@@ -961,7 +961,7 @@ UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
961961
unsigned NumTemplateArgs) {
962962
std::size_t size = sizeof(UnresolvedMemberExpr);
963963
if (HasExplicitTemplateArgs)
964-
size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
964+
size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
965965

966966
void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
967967
UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());

‎clang/lib/AST/ItaniumMangle.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -310,7 +310,7 @@ class CXXNameMangler {
310310
void mangleCXXCtorType(CXXCtorType T);
311311
void mangleCXXDtorType(CXXDtorType T);
312312

313-
void mangleTemplateArgs(const ExplicitTemplateArgumentList &TemplateArgs);
313+
void mangleTemplateArgs(const ASTTemplateArgumentListInfo &TemplateArgs);
314314
void mangleTemplateArgs(TemplateName Template,
315315
const TemplateArgument *TemplateArgs,
316316
unsigned NumTemplateArgs);
@@ -2817,7 +2817,7 @@ void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
28172817
}
28182818

28192819
void CXXNameMangler::mangleTemplateArgs(
2820-
const ExplicitTemplateArgumentList &TemplateArgs) {
2820+
const ASTTemplateArgumentListInfo &TemplateArgs) {
28212821
// <template-args> ::= I <template-arg>+ E
28222822
Out << 'I';
28232823
for (unsigned i = 0, e = TemplateArgs.NumTemplateArgs; i != e; ++i)

0 commit comments

Comments
 (0)