Skip to content
This repository was archived by the owner on Nov 1, 2021. It is now read-only.

Commit 2b5289b

Browse files
rjmccallrjmccall
committed
Push DeclGroupRefs and TemplateNames in an opaque but type-safe way
through the parser. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111800 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent 42d0f2a commit 2b5289b

11 files changed

+50
-45
lines changed

‎include/clang/Parse/Parser.h

+3-2
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@ namespace clang {
2727
struct CXX0XAttributeList;
2828
class PragmaHandler;
2929
class Scope;
30+
class DeclGroupRef;
3031
class DiagnosticBuilder;
3132
class Parser;
3233
class PragmaUnusedHandler;
@@ -147,13 +148,13 @@ class Parser {
147148
// different actual classes based on the actions in place.
148149
typedef Expr ExprTy;
149150
typedef Stmt StmtTy;
150-
typedef Action::DeclGroupPtrTy DeclGroupPtrTy;
151+
typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
151152
typedef Action::TypeTy TypeTy;
152153
typedef CXXBaseSpecifier BaseTy;
153154
typedef CXXBaseOrMemberInitializer MemInitTy;
154155
typedef NestedNameSpecifier CXXScopeTy;
155156
typedef TemplateParameterList TemplateParamsTy;
156-
typedef Action::TemplateTy TemplateTy;
157+
typedef OpaquePtr<TemplateName> TemplateTy;
157158

158159
typedef llvm::SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
159160

‎include/clang/Sema/Ownership.h

+29-23
Original file line numberDiff line numberDiff line change
@@ -27,59 +27,64 @@ namespace clang {
2727
class CXXBaseOrMemberInitializer;
2828
class CXXBaseSpecifier;
2929
class Decl;
30+
class DeclGroupRef;
3031
class Expr;
3132
class NestedNameSpecifier;
3233
class Stmt;
34+
class TemplateName;
3335
class TemplateParameterList;
3436

3537
/// OpaquePtr - This is a very simple POD type that wraps a pointer that the
3638
/// Parser doesn't know about but that Sema or another client does. The UID
3739
/// template argument is used to make sure that "Decl" pointers are not
3840
/// compatible with "Type" pointers for example.
39-
template<int UID>
41+
template <class PtrTy>
4042
class OpaquePtr {
4143
void *Ptr;
44+
explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {}
45+
4246
public:
4347
OpaquePtr() : Ptr(0) {}
4448

45-
template <typename T>
46-
T* getAs() const {
47-
return llvm::PointerLikeTypeTraits<T*>::getFromVoidPointer(Ptr);
49+
static OpaquePtr make(PtrTy P) {
50+
OpaquePtr OP; OP.set(P); return OP;
4851
}
4952

50-
template <typename T>
51-
T getAsVal() const {
52-
return llvm::PointerLikeTypeTraits<T>::getFromVoidPointer(Ptr);
53+
template <typename T> T* getAs() const {
54+
return get();
5355
}
5456

55-
void *get() const { return Ptr; }
57+
template <typename T> T getAsVal() const {
58+
return get();
59+
}
5660

57-
template<typename T>
58-
static OpaquePtr make(T P) {
59-
OpaquePtr R; R.set(P); return R;
61+
PtrTy get() const {
62+
return llvm::PointerLikeTypeTraits<PtrTy>::getFromVoidPointer(Ptr);
6063
}
6164

62-
template<typename T>
63-
void set(T P) {
64-
Ptr = llvm::PointerLikeTypeTraits<T>::getAsVoidPointer(P);
65+
void set(PtrTy P) {
66+
Ptr = llvm::PointerLikeTypeTraits<PtrTy>::getAsVoidPointer(P);
6567
}
6668

6769
operator bool() const { return Ptr != 0; }
70+
71+
void *getAsOpaquePtr() const { return Ptr; }
72+
static OpaquePtr getFromOpaquePtr(void *P) { return OpaquePtr(P); }
6873
};
6974
}
7075

7176
namespace llvm {
72-
template <int UID>
73-
class PointerLikeTypeTraits<clang::OpaquePtr<UID> > {
77+
template <class T>
78+
class PointerLikeTypeTraits<clang::OpaquePtr<T> > {
7479
public:
75-
static inline void *getAsVoidPointer(clang::OpaquePtr<UID> P) {
80+
static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
7681
// FIXME: Doesn't work? return P.getAs< void >();
77-
return P.get();
82+
return P.getAsOpaquePtr();
7883
}
79-
static inline clang::OpaquePtr<UID> getFromVoidPointer(void *P) {
80-
return clang::OpaquePtr<UID>::make(P);
84+
static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) {
85+
return clang::OpaquePtr<T>::getFromOpaquePtr(P);
8186
}
82-
enum { NumLowBitsAvailable = 3 };
87+
enum { NumLowBitsAvailable = 0 };
8388
};
8489
}
8590

@@ -207,8 +212,8 @@ namespace clang {
207212

208213
// Types - Though these don't actually enforce strong typing, they document
209214
// what types are required to be identical for the actions.
210-
typedef OpaquePtr<1> DeclGroupPtrTy;
211-
typedef OpaquePtr<2> TemplateTy;
215+
typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
216+
typedef OpaquePtr<TemplateName> TemplateTy;
212217
typedef Attr AttrTy;
213218
typedef CXXBaseSpecifier BaseTy;
214219
typedef CXXBaseOrMemberInitializer MemInitTy;
@@ -535,6 +540,7 @@ namespace clang {
535540
typedef ActionBase::ActionResult<CXXBaseOrMemberInitializer*> MemInitResult;
536541

537542
typedef ActionBase::ActionResult<Decl*> DeclResult;
543+
typedef OpaquePtr<TemplateName> ParsedTemplateTy;
538544
}
539545

540546
#endif

‎include/clang/Sema/ParsedTemplate.h

+5-4
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,8 @@ namespace clang {
5454
ParsedTemplateArgument(const CXXScopeSpec &SS,
5555
ActionBase::TemplateTy Template,
5656
SourceLocation TemplateLoc)
57-
: Kind(ParsedTemplateArgument::Template), Arg(Template.get()),
57+
: Kind(ParsedTemplateArgument::Template),
58+
Arg(Template.getAsOpaquePtr()),
5859
Loc(TemplateLoc), SS(SS) { }
5960

6061
/// \brief Determine whether the given template argument is invalid.
@@ -78,7 +79,7 @@ namespace clang {
7879
/// \brief Retrieve the template template argument's template name.
7980
ActionBase::TemplateTy getAsTemplate() const {
8081
assert(Kind == Template && "Not a template template argument");
81-
return ActionBase::TemplateTy::make(Arg);
82+
return ActionBase::TemplateTy::getFromOpaquePtr(Arg);
8283
}
8384

8485
/// \brief Retrieve the location of the template argument.
@@ -128,8 +129,8 @@ namespace clang {
128129
OverloadedOperatorKind Operator;
129130

130131
/// The declaration of the template corresponding to the
131-
/// template-name. This is an Action::TemplateTy.
132-
void *Template;
132+
/// template-name.
133+
ParsedTemplateTy Template;
133134

134135
/// The kind of template that Template refers to.
135136
TemplateNameKind Kind;

‎lib/Parse/ParseAST.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -84,11 +84,11 @@ void clang::ParseAST(Sema &S, bool PrintStats) {
8484
// is due to a top-level semicolon, an action override, or a parse error
8585
// skipping something.
8686
if (ADecl)
87-
Consumer->HandleTopLevelDecl(ADecl.getAsVal<DeclGroupRef>());
87+
Consumer->HandleTopLevelDecl(ADecl.get());
8888
};
8989
// Check for any pending objective-c implementation decl.
9090
while ((ADecl = P.FinishPendingObjCActions()))
91-
Consumer->HandleTopLevelDecl(ADecl.getAsVal<DeclGroupRef>());
91+
Consumer->HandleTopLevelDecl(ADecl.get());
9292

9393
// Process any TopLevelDecls generated by #pragma weak.
9494
for (llvm::SmallVector<Decl*,2>::iterator

‎lib/Parse/ParseDeclCXX.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -842,7 +842,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
842842
TagType,
843843
StartLoc,
844844
SS,
845-
TemplateTy::make(TemplateId->Template),
845+
TemplateId->Template,
846846
TemplateId->TemplateNameLoc,
847847
TemplateId->LAngleLoc,
848848
TemplateArgsPtr,
@@ -857,7 +857,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
857857
(TUK == Action::TUK_Friend &&
858858
TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
859859
TypeResult
860-
= Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
860+
= Actions.ActOnTemplateIdType(TemplateId->Template,
861861
TemplateId->TemplateNameLoc,
862862
TemplateId->LAngleLoc,
863863
TemplateArgsPtr,
@@ -904,7 +904,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
904904
TagOrTempResult
905905
= Actions.ActOnClassTemplateSpecialization(getCurScope(), TagType, TUK,
906906
StartLoc, SS,
907-
TemplateTy::make(TemplateId->Template),
907+
TemplateId->Template,
908908
TemplateId->TemplateNameLoc,
909909
TemplateId->LAngleLoc,
910910
TemplateArgsPtr,

‎lib/Parse/ParseExprCXX.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -1128,7 +1128,7 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
11281128
TemplateId->TemplateNameLoc = Id.StartLocation;
11291129
}
11301130

1131-
TemplateId->Template = Template.getAs<void*>();
1131+
TemplateId->Template = Template;
11321132
TemplateId->Kind = TNK;
11331133
TemplateId->LAngleLoc = LAngleLoc;
11341134
TemplateId->RAngleLoc = RAngleLoc;

‎lib/Parse/ParseTemplate.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -806,7 +806,7 @@ bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
806806
TemplateId->Name = 0;
807807
TemplateId->Operator = TemplateName.OperatorFunctionId.Operator;
808808
}
809-
TemplateId->Template = Template.getAs<void*>();
809+
TemplateId->Template = Template;
810810
TemplateId->Kind = TNK;
811811
TemplateId->LAngleLoc = LAngleLoc;
812812
TemplateId->RAngleLoc = RAngleLoc;
@@ -851,7 +851,7 @@ void Parser::AnnotateTemplateIdTokenAsType(const CXXScopeSpec *SS) {
851851
TemplateId->NumArgs);
852852

853853
Action::TypeResult Type
854-
= Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
854+
= Actions.ActOnTemplateIdType(TemplateId->Template,
855855
TemplateId->TemplateNameLoc,
856856
TemplateId->LAngleLoc,
857857
TemplateArgsPtr,

‎lib/Sema/SemaDecl.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -2072,8 +2072,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
20722072
}
20732073

20742074
case UnqualifiedId::IK_TemplateId: {
2075-
TemplateName TName
2076-
= TemplateName::getFromVoidPointer(Name.TemplateId->Template);
2075+
TemplateName TName = Name.TemplateId->Template.get();
20772076
SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
20782077
return Context.getNameForTemplate(TName, TNameLoc);
20792078
}

‎lib/Sema/SemaExpr.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -671,8 +671,7 @@ static void DecomposeUnqualifiedId(Sema &SemaRef,
671671
SemaRef.translateTemplateArguments(TemplateArgsPtr, Buffer);
672672
TemplateArgsPtr.release();
673673

674-
TemplateName TName =
675-
Sema::TemplateTy::make(Id.TemplateId->Template).getAsVal<TemplateName>();
674+
TemplateName TName = Id.TemplateId->Template.get();
676675
SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
677676
NameInfo = SemaRef.Context.getNameForTemplate(TName, TNameLoc);
678677
TemplateArgs = &Buffer;

‎lib/Sema/SemaExprCXX.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -2977,7 +2977,7 @@ Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
29772977
ASTTemplateArgsPtr TemplateArgsPtr(*this,
29782978
TemplateId->getTemplateArgs(),
29792979
TemplateId->NumArgs);
2980-
TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
2980+
TypeResult T = ActOnTemplateIdType(TemplateId->Template,
29812981
TemplateId->TemplateNameLoc,
29822982
TemplateId->LAngleLoc,
29832983
TemplateArgsPtr,
@@ -3025,7 +3025,7 @@ Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
30253025
ASTTemplateArgsPtr TemplateArgsPtr(*this,
30263026
TemplateId->getTemplateArgs(),
30273027
TemplateId->NumArgs);
3028-
TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
3028+
TypeResult T = ActOnTemplateIdType(TemplateId->Template,
30293029
TemplateId->TemplateNameLoc,
30303030
TemplateId->LAngleLoc,
30313031
TemplateArgsPtr,

‎lib/Sema/SemaTemplate.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -436,8 +436,7 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
436436
}
437437

438438
case ParsedTemplateArgument::Template: {
439-
TemplateName Template
440-
= TemplateName::getFromVoidPointer(Arg.getAsTemplate().get());
439+
TemplateName Template = Arg.getAsTemplate().get();
441440
return TemplateArgumentLoc(TemplateArgument(Template),
442441
Arg.getScopeSpec().getRange(),
443442
Arg.getLocation());

0 commit comments

Comments
 (0)