Phase 2 of making the Decl class more lightweight...

Move Identifier/Loc instance variables (and associated getters/setters) down from Decl to ScopedDecl/FieldDecl.

Objc AST's can now inherit from Decl without getting instance variables and types that are C specific. For now, I am keeping NextDeclarator, since I believe it may be useful to ObjC. If not, it can be moved later.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@41934 91177308-0d34-0410-b5e6-96231b3b80d8

11 files changed, 74 insertions, 48 deletions

diff --git a/AST/Decl.cpp b/AST/Decl.cpp
index e84532923b..4b668c2686 100644
--- a/AST/Decl.cpp
+++ b/AST/Decl.cpp
@@ -112,7 +112,13 @@ void Decl::addDeclKind(const Kind k) {
 Decl::~Decl() {
 }
 
-const char *Decl::getName() const {
+const char *FieldDecl::getName() const {
+  if (const IdentifierInfo *II = getIdentifier())
+    return II->getName();
+  return "";
+}
+
+const char *ScopedDecl::getName() const {
   if (const IdentifierInfo *II = getIdentifier())
     return II->getName();
   return "";
diff --git a/CodeGen/CGExpr.cpp b/CodeGen/CGExpr.cpp
index 86604f94bf..64fa549a05 100644
--- a/CodeGen/CGExpr.cpp
+++ b/CodeGen/CGExpr.cpp
@@ -261,7 +261,7 @@ void CodeGenFunction::EmitStoreThroughOCUComponentLValue(RValue Src, LValue Dst,
 
 
 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
-  const Decl *D = E->getDecl();
+  const ValueDecl *D = E->getDecl();
   if (isa<BlockVarDecl>(D) || isa<ParmVarDecl>(D)) {
     llvm::Value *V = LocalDeclMap[D];
     assert(V && "BlockVarDecl not entered in LocalDeclMap?");
diff --git a/CodeGen/CodeGenModule.cpp b/CodeGen/CodeGenModule.cpp
index a26e129336..e14b738a31 100644
--- a/CodeGen/CodeGenModule.cpp
+++ b/CodeGen/CodeGenModule.cpp
@@ -27,7 +27,7 @@ using namespace CodeGen;
 CodeGenModule::CodeGenModule(ASTContext &C, llvm::Module &M)
   : Context(C), TheModule(M), Types(C, M), CFConstantStringClassRef(0) {}
 
-llvm::Constant *CodeGenModule::GetAddrOfGlobalDecl(const Decl *D) {
+llvm::Constant *CodeGenModule::GetAddrOfGlobalDecl(const ValueDecl *D) {
   // See if it is already in the map.
   llvm::Constant *&Entry = GlobalDeclMap[D];
   if (Entry) return Entry;
diff --git a/CodeGen/CodeGenModule.h b/CodeGen/CodeGenModule.h
index af2db80840..d94f54a846 100644
--- a/CodeGen/CodeGenModule.h
+++ b/CodeGen/CodeGenModule.h
@@ -28,6 +28,7 @@ namespace clang {
   class ASTContext;
   class FunctionDecl;
   class Decl;
+  class ValueDecl;
   class FileVarDecl;
     
 namespace CodeGen {
@@ -53,7 +54,7 @@ public:
   llvm::Module &getModule() const { return TheModule; }
   CodeGenTypes &getTypes() { return Types; }
   
-  llvm::Constant *GetAddrOfGlobalDecl(const Decl *D);
+  llvm::Constant *GetAddrOfGlobalDecl(const ValueDecl *D);
   
   /// getBuiltinLibFunction - Given a builtin id for a function like
   /// "__builtin_fabsf", return a Function* for "fabsf".
diff --git a/Driver/ASTStreamers.cpp b/Driver/ASTStreamers.cpp
index 342ee6b327..b60a99440d 100644
--- a/Driver/ASTStreamers.cpp
+++ b/Driver/ASTStreamers.cpp
@@ -124,8 +124,8 @@ void clang::PrintASTs(Preprocessor &PP, unsigned MainFileID, bool Stats) {
       PrintTypeDefDecl(TD);
     } else if (ObjcInterfaceDecl *OID = dyn_cast<ObjcInterfaceDecl>(D)) {
       PrintObjcInterfaceDecl(OID);
-    } else {
-      fprintf(stderr, "Read top-level variable decl: '%s'\n", D->getName());
+    } else if (ScopedDecl *SD = dyn_cast<ScopedDecl>(D)) {
+      fprintf(stderr, "Read top-level variable decl: '%s'\n", SD->getName());
     }
   }
   
@@ -154,8 +154,8 @@ void clang::DumpASTs(Preprocessor &PP, unsigned MainFileID, bool Stats) {
       }
     } else if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
       PrintTypeDefDecl(TD);
-    } else {
-      fprintf(stderr, "Read top-level variable decl: '%s'\n", D->getName());
+    } else if (ScopedDecl *SD = dyn_cast<ScopedDecl>(D)) {
+      fprintf(stderr, "Read top-level variable decl: '%s'\n", SD->getName());
     }
   }
   
diff --git a/Sema/Sema.h b/Sema/Sema.h
index 2cc1148712..3095308354 100644
--- a/Sema/Sema.h
+++ b/Sema/Sema.h
@@ -166,9 +166,9 @@ private:
 private:
   /// Subroutines of ParseDeclarator()...
   TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, Decl *LastDeclarator);
-  TypedefDecl *MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
-  FunctionDecl *MergeFunctionDecl(FunctionDecl *New, Decl *Old);
-  VarDecl *MergeVarDecl(VarDecl *New, Decl *Old);
+  TypedefDecl *MergeTypeDefDecl(TypedefDecl *New, ScopedDecl *Old);
+  FunctionDecl *MergeFunctionDecl(FunctionDecl *New, ScopedDecl *Old);
+  VarDecl *MergeVarDecl(VarDecl *New, ScopedDecl *Old);
   /// AddTopLevelDecl - called after the decl has been fully processed.
   /// Allows for bookkeeping and post-processing of each declaration.
   void AddTopLevelDecl(Decl *current, Decl *last);
diff --git a/Sema/SemaDecl.cpp b/Sema/SemaDecl.cpp
index 02d93504d3..97e8e07aaf 100644
--- a/Sema/SemaDecl.cpp
+++ b/Sema/SemaDecl.cpp
@@ -147,7 +147,7 @@ ScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, Scope *S
 /// and scope as a previous declaration 'Old'.  Figure out how to resolve this
 /// situation, merging decls or emitting diagnostics as appropriate.
 ///
-TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
+TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, ScopedDecl *OldD) {
   // Verify the old decl was also a typedef.
   TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD);
   if (!Old) {
@@ -169,7 +169,7 @@ TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
 /// and scope as a previous declaration 'Old'.  Figure out how to resolve this
 /// situation, merging decls or emitting diagnostics as appropriate.
 ///
-FunctionDecl *Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
+FunctionDecl *Sema::MergeFunctionDecl(FunctionDecl *New, ScopedDecl *OldD) {
   // Verify the old decl was also a function.
   FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD);
   if (!Old) {
@@ -202,7 +202,7 @@ FunctionDecl *Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
 /// FIXME: Need to carefully consider tentative definition rules (C99 6.9.2p2).
 /// For example, we incorrectly complain about i1, i4 from C99 6.9.2p4.
 /// 
-VarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
+VarDecl *Sema::MergeVarDecl(VarDecl *New, ScopedDecl *OldD) {
   // Verify the old decl was also a variable.
   VarDecl *Old = dyn_cast<VarDecl>(OldD);
   if (!Old) {
@@ -571,7 +571,8 @@ void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) {
   
   VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
   if (!VDecl) {
-    Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
+    Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(), 
+         diag::err_illegal_initializer);
     RealDecl->setInvalidDecl();
     return;
   }  
@@ -1280,7 +1281,8 @@ Sema::DeclTy *Sema::ParseEnumConstant(Scope *S, DeclTy *theEnumDecl,
   
   // Verify that there isn't already something declared with this name in this
   // scope.
-  if (Decl *PrevDecl = LookupScopedDecl(Id, Decl::IDNS_Ordinary, IdLoc, S)) {
+  if (ScopedDecl *PrevDecl = LookupScopedDecl(Id, Decl::IDNS_Ordinary, 
+                                              IdLoc, S)) {
     if (S->isDeclScope(PrevDecl)) {
       if (isa<EnumConstantDecl>(PrevDecl))
         Diag(IdLoc, diag::err_redefinition_of_enumerator, Id->getName());
diff --git a/Sema/SemaStmt.cpp b/Sema/SemaStmt.cpp
index 9cca2c24f0..2e7e753985 100644
--- a/Sema/SemaStmt.cpp
+++ b/Sema/SemaStmt.cpp
@@ -33,9 +33,11 @@ Sema::StmtResult Sema::ParseNullStmt(SourceLocation SemiLoc) {
 }
 
 Sema::StmtResult Sema::ParseDeclStmt(DeclTy *decl) {
-  if (decl)
-    return new DeclStmt(static_cast<Decl *>(decl));
-  else 
+  if (decl) {
+    ScopedDecl *SD = dyn_cast<ScopedDecl>(static_cast<Decl *>(decl));
+    assert(SD && "Sema::ParseDeclStmt(): expected ScopedDecl");
+    return new DeclStmt(SD);
+  } else 
     return true; // error
 }
 
@@ -57,7 +59,7 @@ Sema::ParseCompoundStmt(SourceLocation L, SourceLocation R,
       /*empty*/;
     
     if (i != NumElts) {
-      Decl *D = cast<DeclStmt>(Elts[i])->getDecl();
+      ScopedDecl *D = cast<DeclStmt>(Elts[i])->getDecl();
       Diag(D->getLocation(), diag::ext_mixed_decls_code);
     }
   }
@@ -484,7 +486,8 @@ Sema::ParseForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
       if (BVD && !BVD->hasLocalStorage())
         BVD = 0;
       if (BVD == 0)
-        Diag(D->getLocation(), diag::err_non_variable_decl_in_for);
+        Diag(dyn_cast<ScopedDecl>(D)->getLocation(), 
+             diag::err_non_variable_decl_in_for);
       // FIXME: mark decl erroneous!
     }
   }
diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index d0f4aba154..89fc5d5f82 100644
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -56,30 +56,18 @@ private:
   /// InvalidDecl - This indicates a semantic error occurred.
   int InvalidDecl :  1;
 
-  /// Loc - The location that this decl.
-  SourceLocation Loc;
-  
-  /// Identifier - The identifier for this declaration (e.g. the name for the
-  /// variable, the tag for a struct).
-  IdentifierInfo *Identifier;
-  
   /// NextDeclarator - If this decl was part of a multi-declarator declaration,
   /// such as "int X, Y, *Z;" this indicates Decl for the next declarator.
   Decl *NextDeclarator;
   
 protected:
-  Decl(Kind DK, SourceLocation L, IdentifierInfo *Id, Decl *NextDecl)
-    : DeclKind(DK), InvalidDecl(0), Loc(L), Identifier(Id),
-      NextDeclarator(NextDecl) {
+  Decl(Kind DK, Decl *NextDecl)
+    : DeclKind(DK), InvalidDecl(0), NextDeclarator(NextDecl) {
     if (Decl::CollectingStats()) addDeclKind(DK);
   }
   virtual ~Decl();
   
 public:
-  IdentifierInfo *getIdentifier() const { return Identifier; }
-  SourceLocation getLocation() const { return Loc; }
-  void setLocation(SourceLocation L) { Loc = L; }
-  const char *getName() const;
   
   Kind getKind() const { return DeclKind; }
 
@@ -124,6 +112,13 @@ public:
 /// ScopedDecl - Represent lexically scoped names, used for all ValueDecl's
 /// and TypeDecl's.
 class ScopedDecl : public Decl {
+  /// Identifier - The identifier for this declaration (e.g. the name for the
+  /// variable, the tag for a struct).
+  IdentifierInfo *Identifier;
+  
+  /// Loc - The location that this decl.
+  SourceLocation Loc;
+  
   /// When this decl is in scope while parsing, the Next field contains a
   /// pointer to the shadowed decl of the same name.  When the scope is popped,
   /// Decls are relinked onto a containing decl object.
@@ -131,8 +126,13 @@ class ScopedDecl : public Decl {
   ScopedDecl *Next;
 protected:
   ScopedDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, Decl *PrevDecl) 
-    : Decl(DK, L, Id, PrevDecl), Next(0) {}
+    : Decl(DK, PrevDecl), Identifier(Id), Loc(L), Next(0) {}
 public:
+  IdentifierInfo *getIdentifier() const { return Identifier; }
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+  const char *getName() const;
+
   ScopedDecl *getNext() const { return Next; }
   void setNext(ScopedDecl *N) { Next = N; }
   
@@ -317,12 +317,25 @@ private:
 /// FieldDecl - An instance of this class is created by Sema::ParseField to 
 /// represent a member of a struct/union/class.
 class FieldDecl : public Decl {
-  QualType DeclType;
+  /// Identifier - The identifier for this declaration (e.g. the name for the
+  /// variable, the tag for a struct).
+  IdentifierInfo *Identifier;
+  
+  /// Loc - The location that this decl.
+  SourceLocation Loc;
+  
+  QualType DeclType;  
 public:
   FieldDecl(SourceLocation L, IdentifierInfo *Id, QualType T, Decl *PrevDecl)
-    : Decl(Field, L, Id, PrevDecl), DeclType(T) {}
+    : Decl(Field, PrevDecl), Identifier(Id), Loc(L), DeclType(T) {}
   FieldDecl(Kind DK, SourceLocation L, IdentifierInfo *Id, QualType T, 
-            Decl *PrevDecl) : Decl(DK, L, Id, PrevDecl), DeclType(T) {}
+            Decl *PrevDecl) : Decl(DK, PrevDecl), Identifier(Id), Loc(L), 
+            DeclType(T) {}
+
+  IdentifierInfo *getIdentifier() const { return Identifier; }
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+  const char *getName() const;
 
   QualType getType() const { return DeclType; }
   QualType getCanonicalType() const { return DeclType.getCanonicalType(); }
@@ -601,7 +614,7 @@ public:
 		 ParmVarDecl **paramInfo = 0, int numParams=-1,
 		 AttributeList *M = 0, bool isInstance = true, 
 		 Decl *PrevDecl = 0)
-    : Decl(ObjcMethod, L, Id, PrevDecl), MethodDeclType(T), 
+    : Decl(ObjcMethod, PrevDecl), MethodDeclType(T), 
       ParamInfo(paramInfo), NumMethodParams(numParams),
       MethodAttrs(M), IsInstance(isInstance) {}
 
diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index c5e0a6d272..ecf6eb025c 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -116,14 +116,14 @@ public:
 /// DeclRefExpr - [C99 6.5.1p2] - A reference to a declared variable, function,
 /// enum, etc.
 class DeclRefExpr : public Expr {
-  Decl *D; // a ValueDecl or EnumConstantDecl
+  ValueDecl *D; 
   SourceLocation Loc;
 public:
-  DeclRefExpr(Decl *d, QualType t, SourceLocation l) : 
+  DeclRefExpr(ValueDecl *d, QualType t, SourceLocation l) : 
     Expr(DeclRefExprClass, t), D(d), Loc(l) {}
   
-  Decl *getDecl() { return D; }
-  const Decl *getDecl() const { return D; }
+  ValueDecl *getDecl() { return D; }
+  const ValueDecl *getDecl() const { return D; }
   virtual SourceRange getSourceRange() const { return SourceRange(Loc); }
   
   
diff --git a/include/clang/AST/Stmt.h b/include/clang/AST/Stmt.h
index b2703f4647..e7de0b264f 100644
--- a/include/clang/AST/Stmt.h
+++ b/include/clang/AST/Stmt.h
@@ -22,6 +22,7 @@
 namespace clang {
   class Expr;
   class Decl;
+  class ScopedDecl;
   class IdentifierInfo;
   class SourceManager;
   class SwitchStmt;
@@ -125,12 +126,12 @@ public:
 /// the first statement can be an expression or a declaration.
 ///
 class DeclStmt : public Stmt {
-  Decl *TheDecl;
+  ScopedDecl *TheDecl;
 public:
-  DeclStmt(Decl *D) : Stmt(DeclStmtClass), TheDecl(D) {}
+  DeclStmt(ScopedDecl *D) : Stmt(DeclStmtClass), TheDecl(D) {}
   
-  const Decl *getDecl() const { return TheDecl; }
-  Decl *getDecl() { return TheDecl; }
+  const ScopedDecl *getDecl() const { return TheDecl; }
+  ScopedDecl *getDecl() { return TheDecl; }
 
   virtual SourceRange getSourceRange() const { return SourceRange(); }