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

11 files changed, 50 insertions, 45 deletions

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index f1e4f956ce..b5e3a4c05d 100644
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -27,6 +27,7 @@ namespace clang {
   struct CXX0XAttributeList;
   class PragmaHandler;
   class Scope;
+  class DeclGroupRef;
   class DiagnosticBuilder;
   class Parser;
   class PragmaUnusedHandler;
@@ -147,13 +148,13 @@ public:
   // different actual classes based on the actions in place.
   typedef Expr ExprTy;
   typedef Stmt StmtTy;
-  typedef Action::DeclGroupPtrTy DeclGroupPtrTy;
+  typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
   typedef Action::TypeTy TypeTy;
   typedef CXXBaseSpecifier BaseTy;
   typedef CXXBaseOrMemberInitializer MemInitTy;
   typedef NestedNameSpecifier CXXScopeTy;
   typedef TemplateParameterList TemplateParamsTy;
-  typedef Action::TemplateTy TemplateTy;
+  typedef OpaquePtr<TemplateName> TemplateTy;
 
   typedef llvm::SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
 
diff --git a/include/clang/Sema/Ownership.h b/include/clang/Sema/Ownership.h
index 1877ddda40..5a70eef4f1 100644
--- a/include/clang/Sema/Ownership.h
+++ b/include/clang/Sema/Ownership.h
@@ -27,59 +27,64 @@ namespace clang {
   class CXXBaseOrMemberInitializer;
   class CXXBaseSpecifier;
   class Decl;
+  class DeclGroupRef;
   class Expr;
   class NestedNameSpecifier;
   class Stmt;
+  class TemplateName;
   class TemplateParameterList;
 
   /// OpaquePtr - This is a very simple POD type that wraps a pointer that the
   /// Parser doesn't know about but that Sema or another client does.  The UID
   /// template argument is used to make sure that "Decl" pointers are not
   /// compatible with "Type" pointers for example.
-  template<int UID>
+  template <class PtrTy>
   class OpaquePtr {
     void *Ptr;
+    explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {}
+
   public:
     OpaquePtr() : Ptr(0) {}
 
-    template <typename T>
-    T* getAs() const {
-      return llvm::PointerLikeTypeTraits<T*>::getFromVoidPointer(Ptr);
+    static OpaquePtr make(PtrTy P) {
+      OpaquePtr OP; OP.set(P); return OP;
     }
 
-    template <typename T>
-    T getAsVal() const {
-      return llvm::PointerLikeTypeTraits<T>::getFromVoidPointer(Ptr);
+    template <typename T> T* getAs() const {
+      return get();
     }
 
-    void *get() const { return Ptr; }
+    template <typename T> T getAsVal() const {
+      return get();
+    }
 
-    template<typename T>
-    static OpaquePtr make(T P) {
-      OpaquePtr R; R.set(P); return R;
+    PtrTy get() const {
+      return llvm::PointerLikeTypeTraits<PtrTy>::getFromVoidPointer(Ptr);
     }
 
-    template<typename T>
-    void set(T P) {
-      Ptr = llvm::PointerLikeTypeTraits<T>::getAsVoidPointer(P);
+    void set(PtrTy P) {
+      Ptr = llvm::PointerLikeTypeTraits<PtrTy>::getAsVoidPointer(P);
     }
 
     operator bool() const { return Ptr != 0; }
+
+    void *getAsOpaquePtr() const { return Ptr; }
+    static OpaquePtr getFromOpaquePtr(void *P) { return OpaquePtr(P); }
   };
 }
 
 namespace llvm {
-  template <int UID>
-  class PointerLikeTypeTraits<clang::OpaquePtr<UID> > {
+  template <class T>
+  class PointerLikeTypeTraits<clang::OpaquePtr<T> > {
   public:
-    static inline void *getAsVoidPointer(clang::OpaquePtr<UID> P) {
+    static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
       // FIXME: Doesn't work? return P.getAs< void >();
-      return P.get();
+      return P.getAsOpaquePtr();
     }
-    static inline clang::OpaquePtr<UID> getFromVoidPointer(void *P) {
-      return clang::OpaquePtr<UID>::make(P);
+    static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) {
+      return clang::OpaquePtr<T>::getFromOpaquePtr(P);
     }
-    enum { NumLowBitsAvailable = 3 };
+    enum { NumLowBitsAvailable = 0 };
   };
 }
 
@@ -207,8 +212,8 @@ namespace clang {
 
     // Types - Though these don't actually enforce strong typing, they document
     // what types are required to be identical for the actions.
-    typedef OpaquePtr<1> DeclGroupPtrTy;
-    typedef OpaquePtr<2> TemplateTy;
+    typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
+    typedef OpaquePtr<TemplateName> TemplateTy;
     typedef Attr AttrTy;
     typedef CXXBaseSpecifier BaseTy;
     typedef CXXBaseOrMemberInitializer MemInitTy;
@@ -535,6 +540,7 @@ namespace clang {
   typedef ActionBase::ActionResult<CXXBaseOrMemberInitializer*> MemInitResult;
 
   typedef ActionBase::ActionResult<Decl*> DeclResult;
+  typedef OpaquePtr<TemplateName> ParsedTemplateTy;
 }
 
 #endif
diff --git a/include/clang/Sema/ParsedTemplate.h b/include/clang/Sema/ParsedTemplate.h
index c420404c90..c7bf4aa4e4 100644
--- a/include/clang/Sema/ParsedTemplate.h
+++ b/include/clang/Sema/ParsedTemplate.h
@@ -54,7 +54,8 @@ namespace clang {
     ParsedTemplateArgument(const CXXScopeSpec &SS,
                            ActionBase::TemplateTy Template, 
                            SourceLocation TemplateLoc) 
-      : Kind(ParsedTemplateArgument::Template), Arg(Template.get()), 
+      : Kind(ParsedTemplateArgument::Template),
+        Arg(Template.getAsOpaquePtr()), 
         Loc(TemplateLoc), SS(SS) { }
     
     /// \brief Determine whether the given template argument is invalid.
@@ -78,7 +79,7 @@ namespace clang {
     /// \brief Retrieve the template template argument's template name.
     ActionBase::TemplateTy getAsTemplate() const {
       assert(Kind == Template && "Not a template template argument");
-      return ActionBase::TemplateTy::make(Arg);
+      return ActionBase::TemplateTy::getFromOpaquePtr(Arg);
     }
     
     /// \brief Retrieve the location of the template argument.
@@ -128,8 +129,8 @@ namespace clang {
     OverloadedOperatorKind Operator;
     
     /// The declaration of the template corresponding to the
-    /// template-name. This is an Action::TemplateTy.
-    void *Template;
+    /// template-name.
+    ParsedTemplateTy Template;
     
     /// The kind of template that Template refers to.
     TemplateNameKind Kind;
diff --git a/lib/Parse/ParseAST.cpp b/lib/Parse/ParseAST.cpp
index 0279bb9e06..e500aae369 100644
--- a/lib/Parse/ParseAST.cpp
+++ b/lib/Parse/ParseAST.cpp
@@ -84,11 +84,11 @@ void clang::ParseAST(Sema &S, bool PrintStats) {
     // is due to a top-level semicolon, an action override, or a parse error
     // skipping something.
     if (ADecl)
-      Consumer->HandleTopLevelDecl(ADecl.getAsVal<DeclGroupRef>());
+      Consumer->HandleTopLevelDecl(ADecl.get());
   };
   // Check for any pending objective-c implementation decl.
   while ((ADecl = P.FinishPendingObjCActions()))
-    Consumer->HandleTopLevelDecl(ADecl.getAsVal<DeclGroupRef>());
+    Consumer->HandleTopLevelDecl(ADecl.get());
   
   // Process any TopLevelDecls generated by #pragma weak.
   for (llvm::SmallVector<Decl*,2>::iterator
diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index 3687f54f03..ea42c727f6 100644
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -842,7 +842,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
                                              TagType,
                                              StartLoc,
                                              SS,
-                                     TemplateTy::make(TemplateId->Template),
+                                             TemplateId->Template,
                                              TemplateId->TemplateNameLoc,
                                              TemplateId->LAngleLoc,
                                              TemplateArgsPtr,
@@ -857,7 +857,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
                (TUK == Action::TUK_Friend &&
                 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
       TypeResult
-        = Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
+        = Actions.ActOnTemplateIdType(TemplateId->Template,
                                       TemplateId->TemplateNameLoc,
                                       TemplateId->LAngleLoc,
                                       TemplateArgsPtr,
@@ -904,7 +904,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
       TagOrTempResult
         = Actions.ActOnClassTemplateSpecialization(getCurScope(), TagType, TUK,
                        StartLoc, SS,
-                       TemplateTy::make(TemplateId->Template),
+                       TemplateId->Template,
                        TemplateId->TemplateNameLoc,
                        TemplateId->LAngleLoc,
                        TemplateArgsPtr,
diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp
index 606eb4c1b4..ea835470df 100644
--- a/lib/Parse/ParseExprCXX.cpp
+++ b/lib/Parse/ParseExprCXX.cpp
@@ -1128,7 +1128,7 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
       TemplateId->TemplateNameLoc = Id.StartLocation;
     }
 
-    TemplateId->Template = Template.getAs<void*>();
+    TemplateId->Template = Template;
     TemplateId->Kind = TNK;
     TemplateId->LAngleLoc = LAngleLoc;
     TemplateId->RAngleLoc = RAngleLoc;
diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp
index 5d5fc9ce3b..795fea789c 100644
--- a/lib/Parse/ParseTemplate.cpp
+++ b/lib/Parse/ParseTemplate.cpp
@@ -806,7 +806,7 @@ bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
       TemplateId->Name = 0;
       TemplateId->Operator = TemplateName.OperatorFunctionId.Operator;
     }
-    TemplateId->Template = Template.getAs<void*>();
+    TemplateId->Template = Template;
     TemplateId->Kind = TNK;
     TemplateId->LAngleLoc = LAngleLoc;
     TemplateId->RAngleLoc = RAngleLoc;
@@ -851,7 +851,7 @@ void Parser::AnnotateTemplateIdTokenAsType(const CXXScopeSpec *SS) {
                                      TemplateId->NumArgs);
 
   Action::TypeResult Type
-    = Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
+    = Actions.ActOnTemplateIdType(TemplateId->Template,
                                   TemplateId->TemplateNameLoc,
                                   TemplateId->LAngleLoc,
                                   TemplateArgsPtr,
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 55f5aac361..0f9d12e6fe 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -2072,8 +2072,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
   }
 
   case UnqualifiedId::IK_TemplateId: {
-    TemplateName TName
-      = TemplateName::getFromVoidPointer(Name.TemplateId->Template);
+    TemplateName TName = Name.TemplateId->Template.get();
     SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
     return Context.getNameForTemplate(TName, TNameLoc);
   }
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 01fbdbe5fa..36a1e4e277 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -671,8 +671,7 @@ static void DecomposeUnqualifiedId(Sema &SemaRef,
     SemaRef.translateTemplateArguments(TemplateArgsPtr, Buffer);
     TemplateArgsPtr.release();
 
-    TemplateName TName =
-      Sema::TemplateTy::make(Id.TemplateId->Template).getAsVal<TemplateName>();
+    TemplateName TName = Id.TemplateId->Template.get();
     SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
     NameInfo = SemaRef.Context.getNameForTemplate(TName, TNameLoc);
     TemplateArgs = &Buffer;
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 2d400b5826..948a7079a2 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -2977,7 +2977,7 @@ Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
     ASTTemplateArgsPtr TemplateArgsPtr(*this,
                                        TemplateId->getTemplateArgs(),
                                        TemplateId->NumArgs);
-    TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
+    TypeResult T = ActOnTemplateIdType(TemplateId->Template,
                                        TemplateId->TemplateNameLoc,
                                        TemplateId->LAngleLoc,
                                        TemplateArgsPtr,
@@ -3025,7 +3025,7 @@ Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
       ASTTemplateArgsPtr TemplateArgsPtr(*this,
                                          TemplateId->getTemplateArgs(),
                                          TemplateId->NumArgs);
-      TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
+      TypeResult T = ActOnTemplateIdType(TemplateId->Template,
                                          TemplateId->TemplateNameLoc,
                                          TemplateId->LAngleLoc,
                                          TemplateArgsPtr,
diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 958c2485a3..33ef32a8e7 100644
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -436,8 +436,7 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
   }
     
   case ParsedTemplateArgument::Template: {
-    TemplateName Template
-      = TemplateName::getFromVoidPointer(Arg.getAsTemplate().get());
+    TemplateName Template = Arg.getAsTemplate().get();
     return TemplateArgumentLoc(TemplateArgument(Template),
                                Arg.getScopeSpec().getRange(),
                                Arg.getLocation());