De-memberify the VarDecl and FunctionDecl StorageClass enums.

This lets us remove Sema.h's dependency on Expr.h and Decl.h.



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

24 files changed, 285 insertions, 249 deletions

diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index bfe0b2934a..cb794ff60a 100644
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -490,36 +490,11 @@ struct EvaluatedStmt {
   APValue Evaluated;
 };
 
-// \brief Describes the kind of template specialization that a
-// particular template specialization declaration represents.
-enum TemplateSpecializationKind {
-  /// This template specialization was formed from a template-id but
-  /// has not yet been declared, defined, or instantiated.
-  TSK_Undeclared = 0,
-  /// This template specialization was implicitly instantiated from a
-  /// template. (C++ [temp.inst]).
-  TSK_ImplicitInstantiation,
-  /// This template specialization was declared or defined by an
-  /// explicit specialization (C++ [temp.expl.spec]) or partial
-  /// specialization (C++ [temp.class.spec]).
-  TSK_ExplicitSpecialization,
-  /// This template specialization was instantiated from a template
-  /// due to an explicit instantiation declaration request
-  /// (C++0x [temp.explicit]).
-  TSK_ExplicitInstantiationDeclaration,
-  /// This template specialization was instantiated from a template
-  /// due to an explicit instantiation definition request
-  /// (C++ [temp.explicit]).
-  TSK_ExplicitInstantiationDefinition
-};
-  
 /// VarDecl - An instance of this class is created to represent a variable
 /// declaration or definition.
 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
 public:
-  enum StorageClass {
-    None, Auto, Register, Extern, Static, PrivateExtern
-  };
+  typedef clang::StorageClass StorageClass;
 
   /// getStorageClassSpecifierString - Return the string used to
   /// specify the storage class \arg SC.
@@ -595,8 +570,14 @@ public:
   StorageClass getStorageClassAsWritten() const {
     return (StorageClass) SClassAsWritten;
   }
-  void setStorageClass(StorageClass SC) { SClass = SC; }
-  void setStorageClassAsWritten(StorageClass SC) { SClassAsWritten = SC; }
+  void setStorageClass(StorageClass SC) {
+    assert(isLegalForVariable(SC));
+    SClass = SC;
+  }
+  void setStorageClassAsWritten(StorageClass SC) {
+    assert(isLegalForVariable(SC));
+    SClassAsWritten = SC;
+  }
 
   void setThreadSpecified(bool T) { ThreadSpecified = T; }
   bool isThreadSpecified() const {
@@ -606,25 +587,26 @@ public:
   /// hasLocalStorage - Returns true if a variable with function scope
   ///  is a non-static local variable.
   bool hasLocalStorage() const {
-    if (getStorageClass() == None)
+    if (getStorageClass() == SC_None)
       return !isFileVarDecl();
 
     // Return true for:  Auto, Register.
     // Return false for: Extern, Static, PrivateExtern.
 
-    return getStorageClass() <= Register;
+    return getStorageClass() >= SC_Auto;
   }
 
   /// isStaticLocal - Returns true if a variable with function scope is a 
   /// static local variable.
   bool isStaticLocal() const {
-    return getStorageClass() == Static && !isFileVarDecl();
+    return getStorageClass() == SC_Static && !isFileVarDecl();
   }
   
   /// hasExternStorage - Returns true if a variable has extern or
   /// __private_extern__ storage.
   bool hasExternalStorage() const {
-    return getStorageClass() == Extern || getStorageClass() == PrivateExtern;
+    return getStorageClass() == SC_Extern ||
+           getStorageClass() == SC_PrivateExtern;
   }
 
   /// hasGlobalStorage - Returns true for all variables that do not
@@ -937,7 +919,7 @@ class ImplicitParamDecl : public VarDecl {
 protected:
   ImplicitParamDecl(Kind DK, DeclContext *DC, SourceLocation L,
                     IdentifierInfo *Id, QualType Tw)
-    : VarDecl(DK, DC, L, Id, Tw, /*TInfo=*/0, VarDecl::None, VarDecl::None) {}
+    : VarDecl(DK, DC, L, Id, Tw, /*TInfo=*/0, SC_None, SC_None) {}
 public:
   static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation L, IdentifierInfo *Id,
@@ -1081,9 +1063,7 @@ public:
 class FunctionDecl : public DeclaratorDecl, public DeclContext,
                      public Redeclarable<FunctionDecl> {
 public:
-  enum StorageClass {
-    None, Extern, Static, PrivateExtern
-  };
+  typedef clang::StorageClass StorageClass;
 
   /// \brief The kind of templated function a FunctionDecl can be.
   enum TemplatedKind {
@@ -1178,8 +1158,8 @@ public:
   static FunctionDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L,
                               DeclarationName N, QualType T,
                               TypeSourceInfo *TInfo,
-                              StorageClass S = None,
-                              StorageClass SCAsWritten = None,
+                              StorageClass S = SC_None,
+                              StorageClass SCAsWritten = SC_None,
                               bool isInline = false,
                               bool hasWrittenPrototype = true) {
     DeclarationNameInfo NameInfo(N, L);
@@ -1190,8 +1170,8 @@ public:
   static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
                               const DeclarationNameInfo &NameInfo,
                               QualType T, TypeSourceInfo *TInfo,
-                              StorageClass S = None,
-                              StorageClass SCAsWritten = None,
+                              StorageClass S = SC_None,
+                              StorageClass SCAsWritten = SC_None,
                               bool isInline = false,
                               bool hasWrittenPrototype = true);
 
@@ -1372,12 +1352,18 @@ public:
   }
                        
   StorageClass getStorageClass() const { return StorageClass(SClass); }
-  void setStorageClass(StorageClass SC) { SClass = SC; }
+  void setStorageClass(StorageClass SC) {
+    assert(isLegalForFunction(SC));
+    SClass = SC;
+  }
 
   StorageClass getStorageClassAsWritten() const {
     return StorageClass(SClassAsWritten);
   }
-  void setStorageClassAsWritten(StorageClass SC) { SClassAsWritten = SC; }
+  void setStorageClassAsWritten(StorageClass SC) {
+    assert(isLegalForFunction(SC));
+    SClassAsWritten = SC;
+  }
 
   /// \brief Determine whether the "inline" keyword was specified for this
   /// function.
diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h
index 3e665d45e4..b529cf0346 100644
--- a/include/clang/AST/DeclCXX.h
+++ b/include/clang/AST/DeclCXX.h
@@ -1069,7 +1069,7 @@ protected:
                 const DeclarationNameInfo &NameInfo,
                 QualType T, TypeSourceInfo *TInfo,
                 bool isStatic, StorageClass SCAsWritten, bool isInline)
-    : FunctionDecl(DK, RD, NameInfo, T, TInfo, (isStatic ? Static : None),
+    : FunctionDecl(DK, RD, NameInfo, T, TInfo, (isStatic ? SC_Static : SC_None),
                    SCAsWritten, isInline) {}
 
 public:
@@ -1077,10 +1077,10 @@ public:
                                const DeclarationNameInfo &NameInfo,
                                QualType T, TypeSourceInfo *TInfo,
                                bool isStatic = false,
-                               StorageClass SCAsWritten = FunctionDecl::None,
+                               StorageClass SCAsWritten = SC_None,
                                bool isInline = false);
 
-  bool isStatic() const { return getStorageClass() == Static; }
+  bool isStatic() const { return getStorageClass() == SC_Static; }
   bool isInstance() const { return !isStatic(); }
 
   bool isVirtual() const {
@@ -1398,7 +1398,7 @@ class CXXConstructorDecl : public CXXMethodDecl {
                      bool isExplicitSpecified, bool isInline, 
                      bool isImplicitlyDeclared)
     : CXXMethodDecl(CXXConstructor, RD, NameInfo, T, TInfo, false,
-                    FunctionDecl::None, isInline),
+                    SC_None, isInline),
       IsExplicitSpecified(isExplicitSpecified), ImplicitlyDefined(false),
       BaseOrMemberInitializers(0), NumBaseOrMemberInitializers(0) {
     setImplicit(isImplicitlyDeclared);
@@ -1544,7 +1544,7 @@ class CXXDestructorDecl : public CXXMethodDecl {
   CXXDestructorDecl(CXXRecordDecl *RD, const DeclarationNameInfo &NameInfo,
                     QualType T, bool isInline, bool isImplicitlyDeclared)
     : CXXMethodDecl(CXXDestructor, RD, NameInfo, T, /*TInfo=*/0, false,
-                    FunctionDecl::None, isInline),
+                    SC_None, isInline),
       ImplicitlyDefined(false), OperatorDelete(0) {
     setImplicit(isImplicitlyDeclared);
   }
@@ -1605,7 +1605,7 @@ class CXXConversionDecl : public CXXMethodDecl {
                     QualType T, TypeSourceInfo *TInfo,
                     bool isInline, bool isExplicitSpecified)
     : CXXMethodDecl(CXXConversion, RD, NameInfo, T, TInfo, false,
-                    FunctionDecl::None, isInline),
+                    SC_None, isInline),
       IsExplicitSpecified(isExplicitSpecified) { }
 
 public:
diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index c99ac25798..3861cd9a91 100644
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -1016,8 +1016,7 @@ class NonTypeTemplateParmDecl
   NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation L, unsigned D,
                           unsigned P, IdentifierInfo *Id, QualType T,
                           TypeSourceInfo *TInfo)
-    : VarDecl(NonTypeTemplateParm, DC, L, Id, T, TInfo, VarDecl::None,
-              VarDecl::None),
+    : VarDecl(NonTypeTemplateParm, DC, L, Id, T, TInfo, SC_None, SC_None),
       TemplateParmPosition(D, P), DefaultArgumentAndInherited(0, false)
   { }
 
diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h
index c808a0d75c..e757a2f4a1 100644
--- a/include/clang/Basic/Specifiers.h
+++ b/include/clang/Basic/Specifiers.h
@@ -95,6 +95,51 @@ namespace clang {
     VK_XValue
   };
 
+  // \brief Describes the kind of template specialization that a
+  // particular template specialization declaration represents.
+  enum TemplateSpecializationKind {
+    /// This template specialization was formed from a template-id but
+    /// has not yet been declared, defined, or instantiated.
+    TSK_Undeclared = 0,
+    /// This template specialization was implicitly instantiated from a
+    /// template. (C++ [temp.inst]).
+    TSK_ImplicitInstantiation,
+    /// This template specialization was declared or defined by an
+    /// explicit specialization (C++ [temp.expl.spec]) or partial
+    /// specialization (C++ [temp.class.spec]).
+    TSK_ExplicitSpecialization,
+    /// This template specialization was instantiated from a template
+    /// due to an explicit instantiation declaration request
+    /// (C++0x [temp.explicit]).
+    TSK_ExplicitInstantiationDeclaration,
+    /// This template specialization was instantiated from a template
+    /// due to an explicit instantiation definition request
+    /// (C++ [temp.explicit]).
+    TSK_ExplicitInstantiationDefinition
+  };
+
+  /// \brief Storage classes.
+  enum StorageClass {
+    // These are legal on both functions and variables.
+    SC_None,
+    SC_Extern,
+    SC_Static,
+    SC_PrivateExtern,
+
+    // These are only legal on variables.
+    SC_Auto,
+    SC_Register
+  };
+
+  /// Checks whether the given storage class is legal for functions.
+  inline bool isLegalForFunction(StorageClass SC) {
+    return SC <= SC_PrivateExtern;
+  }
+
+  /// Checks whether the given storage class is legal for variables.
+  inline bool isLegalForVariable(StorageClass SC) {
+    return true;
+  }
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_SPECIFIERS_H
diff --git a/include/clang/Frontend/DeclXML.def b/include/clang/Frontend/DeclXML.def
index 16551ee03e..18451189bc 100644
--- a/include/clang/Frontend/DeclXML.def
+++ b/include/clang/Frontend/DeclXML.def
@@ -95,10 +95,10 @@ NODE_XML(FunctionDecl, "Function")
   TYPE_ATTRIBUTE_XML(getType()->getAs<FunctionType>()->getResultType())
   ATTRIBUTE_XML(getType()->getAs<FunctionType>(), "function_type")
   ATTRIBUTE_ENUM_OPT_XML(getStorageClass(), "storage_class")
-	  ENUM_XML(FunctionDecl::None, "")
-	  ENUM_XML(FunctionDecl::Extern, "extern")
-	  ENUM_XML(FunctionDecl::Static, "static")
-	  ENUM_XML(FunctionDecl::PrivateExtern, "__private_extern__")
+	  ENUM_XML(SC_None, "")
+	  ENUM_XML(SC_Extern, "extern")
+	  ENUM_XML(SC_Static, "static")
+	  ENUM_XML(SC_PrivateExtern, "__private_extern__")
   END_ENUM_XML
   ATTRIBUTE_OPT_XML(isInlineSpecified(), "inline")
   //ATTRIBUTE_OPT_XML(isVariadic(), "variadic")       // in the type reference
@@ -289,12 +289,12 @@ NODE_XML(VarDecl, "Var")
   ATTRIBUTE_XML(getNameAsString(), "name")
   TYPE_ATTRIBUTE_XML(getType())
   ATTRIBUTE_ENUM_OPT_XML(getStorageClass(), "storage_class")
-	  ENUM_XML(VarDecl::None, "")
-	  ENUM_XML(VarDecl::Auto, "auto")
-	  ENUM_XML(VarDecl::Register, "register")
-	  ENUM_XML(VarDecl::Extern, "extern")
-	  ENUM_XML(VarDecl::Static, "static")
-	  ENUM_XML(VarDecl::PrivateExtern, "__private_extern__")
+	  ENUM_XML(SC_None, "")
+	  ENUM_XML(SC_Auto, "auto")
+	  ENUM_XML(SC_Register, "register")
+	  ENUM_XML(SC_Extern, "extern")
+	  ENUM_XML(SC_Static, "static")
+	  ENUM_XML(SC_PrivateExtern, "__private_extern__")
   END_ENUM_XML
   SUB_NODE_OPT_XML(Expr)                                      // init expr
 END_NODE_XML
diff --git a/include/clang/Sema/DelayedDiagnostic.h b/include/clang/Sema/DelayedDiagnostic.h
index 655f8332be..6a9a1bf5b6 100644
--- a/include/clang/Sema/DelayedDiagnostic.h
+++ b/include/clang/Sema/DelayedDiagnostic.h
@@ -56,7 +56,7 @@ public:
                  CXXRecordDecl *DerivedClass,
                  AccessSpecifier Access)
     : Access(Access), IsMember(false),
-      Target(reinterpret_cast<NamedDecl*>(BaseClass)),
+      Target(BaseClass),
       NamingClass(DerivedClass),
       Diag(0, Context.getDiagAllocator()) {
   }
@@ -71,7 +71,7 @@ public:
 
   // ...and these apply to hierarchy conversions.
   CXXRecordDecl *getBaseClass() const {
-    assert(!IsMember); return reinterpret_cast<CXXRecordDecl*>(Target);
+    assert(!IsMember); return cast<CXXRecordDecl>(Target);
   }
   CXXRecordDecl *getDerivedClass() const { return NamingClass; }
 
diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index e6e97dfed5..8a880739e4 100644
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -20,9 +20,9 @@
 #include "clang/Sema/IdentifierResolver.h"
 #include "clang/Sema/ObjCMethodList.h"
 #include "clang/AST/OperationKinds.h"
-#include "clang/AST/Decl.h"
-#include "clang/AST/Expr.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclarationName.h"
+#include "clang/AST/ExternalASTSource.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -40,6 +40,7 @@ namespace clang {
   class ASTConsumer;
   class ASTContext;
   class ArrayType;
+  class BlockDecl;
   class CXXBasePath;
   class CXXBasePaths;
   typedef llvm::SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
@@ -62,8 +63,10 @@ namespace clang {
   class DeclContext;
   class DeclRefExpr;
   class DeclSpec;
+  class DeclaratorDecl;
   class DeducedTemplateArgument;
   class DesignatedInitExpr;
+  class EnumConstantDecl;
   class Expr;
   class ExtVectorType;
   class ExternalSemaSource;
@@ -71,6 +74,7 @@ namespace clang {
   class FullExpr;
   class FunctionDecl;
   class FunctionProtoType;
+  class FunctionTemplateDecl;
   class ImplicitConversionSequence;
   class InitListExpr;
   class InitializationKind;
@@ -116,12 +120,13 @@ namespace clang {
   class TemplateTemplateParmDecl;
   class Token;
   class TypedefDecl;
-  class TypedefDecl;
   class UnresolvedLookupExpr;
   class UnresolvedMemberExpr;
+  class UnresolvedSetImpl;
   class UnresolvedSetIterator;
   class UsingDecl;
   class UsingShadowDecl;
+  class ValueDecl;
   class VarDecl;
   class VisibleDeclConsumer;
 
@@ -652,8 +657,8 @@ public:
                               TypeSourceInfo *TSInfo, QualType T,
                               IdentifierInfo *Name,
                               SourceLocation NameLoc,
-                              VarDecl::StorageClass StorageClass,
-                              VarDecl::StorageClass StorageClassAsWritten);
+                              StorageClass SC,
+                              StorageClass SCAsWritten);
   virtual void ActOnParamDefaultArgument(Decl *param,
                                          SourceLocation EqualLoc,
                                          ExprArg defarg);
@@ -2487,13 +2492,13 @@ public:
                                     MultiTemplateParamsArg TemplateParams);
 
   QualType CheckConstructorDeclarator(Declarator &D, QualType R,
-                                      FunctionDecl::StorageClass& SC);
+                                      StorageClass& SC);
   void CheckConstructor(CXXConstructorDecl *Constructor);
   QualType CheckDestructorDeclarator(Declarator &D, QualType R,
-                                     FunctionDecl::StorageClass& SC);
+                                     StorageClass& SC);
   bool CheckDestructor(CXXDestructorDecl *Destructor);
   void CheckConversionDeclarator(Declarator &D, QualType &R,
-                                 FunctionDecl::StorageClass& SC);
+                                 StorageClass& SC);
   Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
 
   //===--------------------------------------------------------------------===//
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index 00b052d476..bef6194e26 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -116,7 +116,7 @@ static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
   // (This bullet corresponds to C99 6.2.2p3.)
   if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
     // Explicitly declared static.
-    if (Var->getStorageClass() == VarDecl::Static)
+    if (Var->getStorageClass() == SC_Static)
       return InternalLinkage;
 
     // - an object or reference that is explicitly declared const
@@ -125,8 +125,8 @@ static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
     // (there is no equivalent in C99)
     if (Context.getLangOptions().CPlusPlus &&
         Var->getType().isConstant(Context) && 
-        Var->getStorageClass() != VarDecl::Extern &&
-        Var->getStorageClass() != VarDecl::PrivateExtern) {
+        Var->getStorageClass() != SC_Extern &&
+        Var->getStorageClass() != SC_PrivateExtern) {
       bool FoundExtern = false;
       for (const VarDecl *PrevVar = Var->getPreviousDeclaration();
            PrevVar && !FoundExtern; 
@@ -149,7 +149,7 @@ static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
       Function = cast<FunctionDecl>(D);
 
     // Explicitly declared static.
-    if (Function->getStorageClass() == FunctionDecl::Static)
+    if (Function->getStorageClass() == SC_Static)
       return InternalLinkage;
   } else if (const FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
     //   - a data member of an anonymous union.
@@ -165,8 +165,8 @@ static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
   //     - an object or reference, unless it has internal linkage; or
   if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
     if (!Context.getLangOptions().CPlusPlus &&
-        (Var->getStorageClass() == VarDecl::Extern ||
-         Var->getStorageClass() == VarDecl::PrivateExtern)) {
+        (Var->getStorageClass() == SC_Extern ||
+         Var->getStorageClass() == SC_PrivateExtern)) {
       // C99 6.2.2p4:
       //   For an identifier declared with the storage-class specifier
       //   extern in a scope in which a prior declaration of that
@@ -200,9 +200,9 @@ static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
     //   as if it were declared with the storage-class specifier
     //   extern.
     if (!Context.getLangOptions().CPlusPlus &&
-        (Function->getStorageClass() == FunctionDecl::Extern ||
-         Function->getStorageClass() == FunctionDecl::PrivateExtern ||
-         Function->getStorageClass() == FunctionDecl::None)) {
+        (Function->getStorageClass() == SC_Extern ||
+         Function->getStorageClass() == SC_PrivateExtern ||
+         Function->getStorageClass() == SC_None)) {
       // C99 6.2.2p4:
       //   For an identifier declared with the storage-class specifier
       //   extern in a scope in which a prior declaration of that
@@ -383,8 +383,8 @@ Linkage NamedDecl::getLinkage() const {
     }
 
     if (const VarDecl *Var = dyn_cast<VarDecl>(this))
-      if (Var->getStorageClass() == VarDecl::Extern ||
-          Var->getStorageClass() == VarDecl::PrivateExtern) {
+      if (Var->getStorageClass() == SC_Extern ||
+          Var->getStorageClass() == SC_PrivateExtern) {
         if (Var->getPreviousDeclaration())
           if (Linkage L = Var->getPreviousDeclaration()->getLinkage())
             return L;
@@ -637,12 +637,12 @@ QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context,
 
 const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
   switch (SC) {
-  case VarDecl::None:          break;
-  case VarDecl::Auto:          return "auto"; break;
-  case VarDecl::Extern:        return "extern"; break;
-  case VarDecl::PrivateExtern: return "__private_extern__"; break;
-  case VarDecl::Register:      return "register"; break;
-  case VarDecl::Static:        return "static"; break;
+  case SC_None:          break;
+  case SC_Auto:          return "auto"; break;
+  case SC_Extern:        return "extern"; break;
+  case SC_PrivateExtern: return "__private_extern__"; break;
+  case SC_Register:      return "register"; break;
+  case SC_Static:        return "static"; break;
   }
 
   assert(0 && "Invalid storage class");
@@ -672,14 +672,14 @@ bool VarDecl::isExternC() const {
   ASTContext &Context = getASTContext();
   if (!Context.getLangOptions().CPlusPlus)
     return (getDeclContext()->isTranslationUnit() &&
-            getStorageClass() != Static) ||
+            getStorageClass() != SC_Static) ||
       (getDeclContext()->isFunctionOrMethod() && hasExternalStorage());
 
   for (const DeclContext *DC = getDeclContext(); !DC->isTranslationUnit();
        DC = DC->getParent()) {
     if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC))  {
       if (Linkage->getLanguage() == LinkageSpecDecl::lang_c)
-        return getStorageClass() != Static;
+        return getStorageClass() != SC_Static;
 
       break;
     }
@@ -724,8 +724,8 @@ VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition() const {
   if (hasExternalStorage())
     return DeclarationOnly;
   
-  if (getStorageClassAsWritten() == Extern ||
-       getStorageClassAsWritten() == PrivateExtern) {
+  if (getStorageClassAsWritten() == SC_Extern ||
+       getStorageClassAsWritten() == SC_PrivateExtern) {
     for (const VarDecl *PrevVar = getPreviousDeclaration();
          PrevVar; PrevVar = PrevVar->getPreviousDeclaration()) {
       if (PrevVar->getLinkage() == InternalLinkage && PrevVar->hasInit())
@@ -978,13 +978,13 @@ bool FunctionDecl::isExternC() const {
   // In C, any non-static, non-overloadable function has external
   // linkage.
   if (!Context.getLangOptions().CPlusPlus)
-    return getStorageClass() != Static && !getAttr<OverloadableAttr>();
+    return getStorageClass() != SC_Static && !getAttr<OverloadableAttr>();
 
   for (const DeclContext *DC = getDeclContext(); !DC->isTranslationUnit();
        DC = DC->getParent()) {
     if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC))  {
       if (Linkage->getLanguage() == LinkageSpecDecl::lang_c)
-        return getStorageClass() != Static &&
+        return getStorageClass() != SC_Static &&
                !getAttr<OverloadableAttr>();
 
       break;
@@ -1001,7 +1001,7 @@ bool FunctionDecl::isGlobal() const {
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this))
     return Method->isStatic();
 
-  if (getStorageClass() == Static)
+  if (getStorageClass() == SC_Static)
     return false;
 
   for (const DeclContext *DC = getDeclContext();
@@ -1060,7 +1060,7 @@ unsigned FunctionDecl::getBuiltinID() const {
   // function or whether it just has the same name.
 
   // If this is a static function, it's not a builtin.
-  if (getStorageClass() == Static)
+  if (getStorageClass() == SC_Static)
     return 0;
 
   // If this function is at translation-unit scope and we're not in
@@ -1194,7 +1194,7 @@ bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
     for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end();
          Redecl != RedeclEnd;
          ++Redecl) {
-      if (Redecl->isInlineSpecified() && Redecl->getStorageClass() != Extern)
+      if (Redecl->isInlineSpecified() && Redecl->getStorageClass() != SC_Extern)
         return true;
     }
     
@@ -1213,7 +1213,7 @@ bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
     if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
       continue;
     
-    if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == Extern) 
+    if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 
       return true; // Not an inline definition
   }
   
diff --git a/lib/AST/DeclPrinter.cpp b/lib/AST/DeclPrinter.cpp
index a42be556f2..f18d2f0215 100644
--- a/lib/AST/DeclPrinter.cpp
+++ b/lib/AST/DeclPrinter.cpp
@@ -335,10 +335,11 @@ void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
-    case FunctionDecl::None: break;
-    case FunctionDecl::Extern: Out << "extern "; break;
-    case FunctionDecl::Static: Out << "static "; break;
-    case FunctionDecl::PrivateExtern: Out << "__private_extern__ "; break;
+    case SC_None: break;
+    case SC_Extern: Out << "extern "; break;
+    case SC_Static: Out << "static "; break;
+    case SC_PrivateExtern: Out << "__private_extern__ "; break;
+    case SC_Auto: case SC_Register: llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())           Out << "inline ";
@@ -505,7 +506,7 @@ void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
 }
 
 void DeclPrinter::VisitVarDecl(VarDecl *D) {
-  if (!Policy.SuppressSpecifiers && D->getStorageClass() != VarDecl::None)
+  if (!Policy.SuppressSpecifiers && D->getStorageClass() != SC_None)
     Out << VarDecl::getStorageClassSpecifierString(D->getStorageClass()) << " ";
 
   if (!Policy.SuppressSpecifiers && D->isThreadSpecified())
diff --git a/lib/AST/StmtDumper.cpp b/lib/AST/StmtDumper.cpp
index 44601e0bdf..850bba40b7 100644
--- a/lib/AST/StmtDumper.cpp
+++ b/lib/AST/StmtDumper.cpp
@@ -225,7 +225,7 @@ void StmtDumper::DumpDeclarator(Decl *D) {
     OS << "\"";
     // Emit storage class for vardecls.
     if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
-      if (V->getStorageClass() != VarDecl::None)
+      if (V->getStorageClass() != SC_None)
         OS << VarDecl::getStorageClassSpecifierString(V->getStorageClass())
            << " ";
     }
diff --git a/lib/Checker/BasicStore.cpp b/lib/Checker/BasicStore.cpp
index 002d4ee835..f82e1b20be 100644
--- a/lib/Checker/BasicStore.cpp
+++ b/lib/Checker/BasicStore.cpp
@@ -437,11 +437,11 @@ Store BasicStoreManager::BindDeclInternal(Store store, const VarRegion* VR,
     // will not be called more than once.
 
     // Static global variables should not be visited here.
-    assert(!(VD->getStorageClass() == VarDecl::Static &&
+    assert(!(VD->getStorageClass() == SC_Static &&
              VD->isFileVarDecl()));
 
     // Process static variables.
-    if (VD->getStorageClass() == VarDecl::Static) {
+    if (VD->getStorageClass() == SC_Static) {
       // C99: 6.7.8 Initialization
       //  If an object that has static storage duration is not initialized
       //  explicitly, then:
diff --git a/lib/CodeGen/CGBlocks.cpp b/lib/CodeGen/CGBlocks.cpp
index 5feca9d2e0..04f1ef24b2 100644
--- a/lib/CodeGen/CGBlocks.cpp
+++ b/lib/CodeGen/CGBlocks.cpp
@@ -722,7 +722,7 @@ CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const BlockExpr *BExpr,
        ++i) {
     const VarDecl *VD = dyn_cast<VarDecl>(i->first);
 
-    if (VD->getStorageClass() == VarDecl::Static || VD->hasExternalStorage())
+    if (VD->getStorageClass() == SC_Static || VD->hasExternalStorage())
       LocalDeclMap[VD] = i->second;
   }
 
@@ -803,8 +803,8 @@ CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const BlockExpr *BExpr,
                                      getContext().getTranslationUnitDecl(),
                                      SourceLocation(), ID, FnType, 
                                      0,
-                                     FunctionDecl::Static,
-                                     FunctionDecl::None,
+                                     SC_Static,
+                                     SC_None,
                                      false, HasPrototype);
   if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FnType)) {
     const FunctionDecl *CFD = dyn_cast<FunctionDecl>(CurCodeDecl);
@@ -814,7 +814,7 @@ CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const BlockExpr *BExpr,
       Params.push_back(ParmVarDecl::Create(getContext(), FD, 
                                            SourceLocation(), 0,
                                            FT->getArgType(i), /*TInfo=*/0,
-                                           VarDecl::None, VarDecl::None, 0));
+                                           SC_None, SC_None, 0));
     FD->setParams(Params.data(), Params.size());
   }
   
@@ -916,7 +916,7 @@ CharUnits BlockFunction::getBlockOffset(CharUnits Size, CharUnits Align) {
                                          getContext().getTranslationUnitDecl(),
                                          SourceLocation(),
                                          0, QualType(PadTy), 0,
-                                         VarDecl::None, VarDecl::None);
+                                         SC_None, SC_None);
     Expr *E = new (getContext()) DeclRefExpr(PadDecl, PadDecl->getType(),
                                              SourceLocation());
     BlockLayout.push_back(E);
@@ -962,8 +962,8 @@ GenerateCopyHelperFunction(bool BlockHasCopyDispose, const llvm::StructType *T,
   FunctionDecl *FD = FunctionDecl::Create(getContext(),
                                           getContext().getTranslationUnitDecl(),
                                           SourceLocation(), II, R, 0,
-                                          FunctionDecl::Static,
-                                          FunctionDecl::None,
+                                          SC_Static,
+                                          SC_None,
                                           false,
                                           true);
   CGF.StartFunction(FD, R, Fn, Args, SourceLocation());
@@ -1044,8 +1044,8 @@ GenerateDestroyHelperFunction(bool BlockHasCopyDispose,
   FunctionDecl *FD = FunctionDecl::Create(getContext(),
                                           getContext().getTranslationUnitDecl(),