[NFC, Refactor] Modernize StorageClass from Specifiers.h to a scoped enum

[tschuett]

Summary

ninja clang clangd

clang-tools-extra/clang-tidy/google/FunctionNamingCheck.cpp

 
 /// For now we will only fix functions of static storage class with names like
 /// 'functionName' or 'function_name' and convert them to 'FunctionName'. For
 /// other cases the user must determine an appropriate name on their own.
 FixItHint generateFixItHint(const FunctionDecl *Decl) {
   // A fixit can be generated for functions of static storage class but
   // otherwise the check cannot determine the appropriate function name prefix
   // to use.
-  if (Decl->getStorageClass() != SC_Static)
+  if (Decl->getStorageClass() != StorageClass::Static)
     return FixItHint();
 
   StringRef Name = Decl->getName();
   std::string NewName = Decl->getName().str();
 
   size_t Index = 0;
   bool AtWordBoundary = true;
   while (Index < NewName.size()) {
Finder->addMatcher(
                              matchesName(validFunctionNameRegex(false))))))
           .bind("function"),
       this);
 }
 
 void FunctionNamingCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("function");
 
-  bool IsGlobal = MatchedDecl->getStorageClass() != SC_Static;
+  bool IsGlobal = MatchedDecl->getStorageClass() != StorageClass::Static;
   diag(MatchedDecl->getLocation(),
        "%select{static function|function in global namespace}1 named %0 must "
        "%select{be in|have an appropriate prefix followed by}1 Pascal case as "
        "required by Google Objective-C style guide")
       << MatchedDecl << IsGlobal << generateFixItHint(MatchedDecl);
 }
 
 } // namespace objc
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/google/GlobalVariableDeclarationCheck.cpp

 namespace google {
 namespace objc {
 
 namespace {
 
 AST_MATCHER(VarDecl, isLocalVariable) { return Node.isLocalVarDecl(); }
 
 FixItHint generateFixItHint(const VarDecl *Decl, bool IsConst) {
-  if (IsConst && (Decl->getStorageClass() != SC_Static)) {
+  if (IsConst && (Decl->getStorageClass() != StorageClass::Static)) {
     // No fix available if it is not a static constant, since it is difficult
     // to determine the proper fix in this case.
     return FixItHint();
   }
 
   char FC = Decl->getName()[0];
   if (!llvm::isAlpha(FC) || Decl->getName().size() == 1) {
     // No fix available if first character is not alphabetical character, or it

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

 void UseTrailingReturnTypeCheck::keepSpecifiers(
     std::string &ReturnType, std::string &Auto, SourceRange ReturnTypeCVRange,
     const FunctionDecl &F, const FriendDecl *Fr, const ASTContext &Ctx,
     const SourceManager &SM, const LangOptions &LangOpts) {
   // Check if there are specifiers inside the return type. E.g. unsigned
   // inline int.
   const auto *M = dyn_cast<CXXMethodDecl>(&F);
   if (!F.isConstexpr() && !F.isInlineSpecified() &&
-      F.getStorageClass() != SC_Extern && F.getStorageClass() != SC_Static &&
-      !Fr && !(M && M->isVirtualAsWritten()))
+      F.getStorageClass() != StorageClass::Extern &&
+      F.getStorageClass() != StorageClass::Static && !Fr &&
+      !(M && M->isVirtualAsWritten()))
     return;
 
   // Tokenize return type. If it contains macros which contain a mix of
   // qualifiers, specifiers and types, give up.
   llvm::Optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
       classifyTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
   if (!MaybeTokens)
     return;

clang/include/clang/AST/Decl.h

public:
   ThreadStorageClassSpecifier getTSCSpec() const {
     return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
   }
   TLSKind getTLSKind() const;
 
   /// Returns true if a variable with function scope is a non-static local
   /// variable.
   bool hasLocalStorage() const {
-    if (getStorageClass() == SC_None) {
+    if (getStorageClass() == StorageClass::None) {
       // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
       // used to describe variables allocated in global memory and which are
       // accessed inside a kernel(s) as read-only variables. As such, variables
       // in constant address space cannot have local storage.
       if (getType().getAddressSpace() == LangAS::opencl_constant)
         return false;
       // Second check is for C++11 [dcl.stc]p4.
       return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
     }
 
     // Global Named Register (GNU extension)
-    if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
+    if (getStorageClass() == StorageClass::Register && !isLocalVarDeclOrParm())
       return false;
 
     // Return true for:  Auto, Register.
     // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
 
-    return getStorageClass() >= SC_Auto;
+    return getStorageClass() >= StorageClass::Auto;
   }
 
   /// Returns true if a variable with function scope is a static local
   /// variable.
   bool isStaticLocal() const {
-    return (getStorageClass() == SC_Static ||
+    return (getStorageClass() == StorageClass::Static ||
             // C++11 [dcl.stc]p4
-            (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
-      && !isFileVarDecl();
+            (getStorageClass() == StorageClass::None &&
+             getTSCSpec() == TSCS_thread_local)) &&
+           !isFileVarDecl();
   }
 
   /// Returns true if a variable has extern or __private_extern__
   /// storage.
   bool hasExternalStorage() const {
-    return getStorageClass() == SC_Extern ||
-           getStorageClass() == SC_PrivateExtern;
+    return getStorageClass() == StorageClass::Extern ||
+           getStorageClass() == StorageClass::PrivateExtern;
   }
 
   /// Returns true for all variables that do not have local storage.
   ///
   /// This includes all global variables as well as static variables declared
   /// within a function.
   bool hasGlobalStorage() const { return !hasLocalStorage(); }
 
static ImplicitParamDecl *Create(ASTContext &C, QualType T,
                                    ImplicitParamKind ParamKind);
 
   static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
                     IdentifierInfo *Id, QualType Type,
                     ImplicitParamKind ParamKind)
       : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
-                /*TInfo=*/nullptr, SC_None) {
+                /*TInfo=*/nullptr, StorageClass::None) {
     NonParmVarDeclBits.ImplicitParamKind = ParamKind;
     setImplicit();
   }
 
   ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
       : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
                 SourceLocation(), /*Id=*/nullptr, Type,
-                /*TInfo=*/nullptr, SC_None) {
+                /*TInfo=*/nullptr, StorageClass::None) {
     NonParmVarDeclBits.ImplicitParamKind = ParamKind;
     setImplicit();
   }
 
   /// Returns the implicit parameter kind.
   ImplicitParamKind getParameterKind() const {
     return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
   }
public:
   /// Returns the storage class as written in the source. For the
   /// computed linkage of symbol, see getLinkage.
   StorageClass getStorageClass() const {
     return static_cast<StorageClass>(FunctionDeclBits.SClass);
   }
 
   /// Sets the storage class as written in the source.
   void setStorageClass(StorageClass SClass) {
-    FunctionDeclBits.SClass = SClass;
+    FunctionDeclBits.SClass = static_cast<uint64_t>(SClass);
   }
 
   /// Determine whether the "inline" keyword was specified for this
   /// function.
   bool isInlineSpecified() const { return FunctionDeclBits.IsInlineSpecified; }
 
   /// Set whether the "inline" keyword was specified for this function.
   void setInlineSpecified(bool I) {
public:
   bool isInlined() const { return FunctionDeclBits.IsInline; }
 
   bool isInlineDefinitionExternallyVisible() const;
 
   bool isMSExternInline() const;
 
   bool doesDeclarationForceExternallyVisibleDefinition() const;
 
-  bool isStatic() const { return getStorageClass() == SC_Static; }
+  bool isStatic() const { return getStorageClass() == StorageClass::Static; }
 
   /// Whether this function declaration represents an C++ overloaded
   /// operator, e.g., "operator+".
   bool isOverloadedOperator() const {
     return getOverloadedOperator() != OO_None;
   }
 
   OverloadedOperatorKind getOverloadedOperator() const;

clang/include/clang/AST/DeclCXX.h

class CXXDeductionGuideDecl : public FunctionDecl {
   void anchor() override;
 
 private:
   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                         ExplicitSpecifier ES,
                         const DeclarationNameInfo &NameInfo, QualType T,
                         TypeSourceInfo *TInfo, SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
-                     SC_None, false, ConstexprSpecKind::Unspecified),
+                     StorageClass::None, false, ConstexprSpecKind::Unspecified),
         ExplicitSpec(ES) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
     setIsCopyDeductionCandidate(false);
   }
 
   ExplicitSpecifier ExplicitSpec;
   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
class CXXDestructorDecl : public CXXMethodDecl {
   Expr *OperatorDeleteThisArg = nullptr;
 
   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline,
                     bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
                     Expr *TrailingRequiresClause = nullptr)
       : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, ConstexprKind, SourceLocation(),
-                      TrailingRequiresClause) {
+                      StorageClass::None, isInline, ConstexprKind,
+                      SourceLocation(), TrailingRequiresClause) {
     setImplicit(isImplicitlyDeclared);
   }
 
   void anchor() override;
 
 public:
   static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                    SourceLocation StartLoc,

 /// \endcode
 class CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES,
                     ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
                     Expr *TrailingRequiresClause = nullptr)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, ConstexprKind, EndLocation,
+                      StorageClass::None, isInline, ConstexprKind, EndLocation,
                       TrailingRequiresClause),
         ExplicitSpec(ES) {}
   void anchor() override;
 
   ExplicitSpecifier ExplicitSpec;
 
 public:
   friend class ASTDeclReader;

clang/include/clang/AST/DeclOpenMP.h

 class OMPCapturedExprDecl final : public VarDecl {
   friend class ASTDeclReader;
   void anchor() override;
 
   OMPCapturedExprDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
                       QualType Type, TypeSourceInfo *TInfo,
                       SourceLocation StartLoc)
       : VarDecl(OMPCapturedExpr, C, DC, StartLoc, StartLoc, Id, Type, TInfo,
-                SC_None) {
+                StorageClass::None) {
     setImplicit();
   }
 
 public:
   static OMPCapturedExprDecl *Create(ASTContext &C, DeclContext *DC,
                                      IdentifierInfo *Id, QualType T,
                                      SourceLocation StartLoc);
 

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// \endcode
 /// functionDecl(isStaticStorageClass())
 ///   matches the function declaration f.
 /// varDecl(isStaticStorageClass())
 ///   matches the variable declaration i.
 AST_POLYMORPHIC_MATCHER(isStaticStorageClass,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl,
                                                         VarDecl)) {
-  return Node.getStorageClass() == SC_Static;
+  return Node.getStorageClass() == StorageClass::Static;
 }
 
 /// Matches deleted function declarations.
 ///
 /// Given:
 /// \code
 ///   void Func();
 ///   void DeletedFunc() = delete;

clang/include/clang/Basic/Specifiers.h

enum ThreadStorageClassSpecifier {
     /// class scope.
     TSCS_thread_local,
     /// C11 _Thread_local. Must be combined with either 'static' or 'extern'
     /// if used at block scope.
     TSCS__Thread_local
   };
 
   /// Storage classes.
-  enum StorageClass {
+  enum class StorageClass {
     // These are legal on both functions and variables.
-    SC_None,
-    SC_Extern,
-    SC_Static,
-    SC_PrivateExtern,
+    None,
+    Extern,
+    Static,
+    PrivateExtern,
 
     // These are only legal on variables.
-    SC_Auto,
-    SC_Register
+    Auto,
+    Register
   };
 
   /// Checks whether the given storage class is legal for functions.
   inline bool isLegalForFunction(StorageClass SC) {
-    return SC <= SC_PrivateExtern;
+    switch (SC) {
+    case StorageClass::None:
+    case StorageClass::Extern:
+    case StorageClass::Static:
+    case StorageClass::PrivateExtern:
+      return true;
+    case StorageClass::Auto:
+    case StorageClass::Register:
+      return false;
+    }
+    llvm_unreachable("unknown storage class");
   }
 
   /// Checks whether the given storage class is legal for variables.
   inline bool isLegalForVariable(StorageClass SC) {
     return true;
   }
 
   /// In-class initialization styles for non-static data members.

clang/lib/AST/ASTContext.cpp

return adjustGVALinkageForExternalDefinitionKind(*this, VD,
              basicGVALinkageForVariable(*this, VD)));
 }
 
 bool ASTContext::DeclMustBeEmitted(const Decl *D) {
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->isFileVarDecl())
       return false;
     // Global named register variables (GNU extension) are never emitted.
-    if (VD->getStorageClass() == SC_Register)
+    if (VD->getStorageClass() == StorageClass::Register)
       return false;
     if (VD->getDescribedVarTemplate() ||
         isa<VarTemplatePartialSpecializationDecl>(VD))
       return false;
   } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     // We never need to emit an uninstantiated function template.
     if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
       return false;

 
 bool ASTContext::mayExternalizeStaticVar(const Decl *D) const {
   return !getLangOpts().GPURelocatableDeviceCode &&
          ((D->hasAttr<CUDADeviceAttr>() &&
            !D->getAttr<CUDADeviceAttr>()->isImplicit()) ||
           (D->hasAttr<CUDAConstantAttr>() &&
            !D->getAttr<CUDAConstantAttr>()->isImplicit())) &&
          isa<VarDecl>(D) && cast<VarDecl>(D)->isFileVarDecl() &&
-         cast<VarDecl>(D)->getStorageClass() == SC_Static;
+         cast<VarDecl>(D)->getStorageClass() == StorageClass::Static;
 }
 
 bool ASTContext::shouldExternalizeStaticVar(const Decl *D) const {
   return mayExternalizeStaticVar(D) &&
          CUDAStaticDeviceVarReferencedByHost.count(cast<VarDecl>(D));
 }

clang/lib/AST/Decl.cpp

static StorageClass getStorageClass(const Decl *D) {
   if (auto *TD = dyn_cast<TemplateDecl>(D))
     D = TD->getTemplatedDecl();
   if (D) {
     if (auto *VD = dyn_cast<VarDecl>(D))
       return VD->getStorageClass();
     if (auto *FD = dyn_cast<FunctionDecl>(D))
       return FD->getStorageClass();
   }
-  return SC_None;
+  return StorageClass::None;
 }
 
 LinkageInfo
 LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
                                             LVComputationKind computation,
                                             bool IgnoreVarTypeLinkage) {
   assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
          "Not a name having namespace scope");
   ASTContext &Context = D->getASTContext();
 
   // C++ [basic.link]p3:
   //   A name having namespace scope (3.3.6) has internal linkage if it
   //   is the name of
 
-  if (getStorageClass(D->getCanonicalDecl()) == SC_Static) {
+  if (getStorageClass(D->getCanonicalDecl()) == StorageClass::Static) {
     // - a variable, variable template, function, or function template
     //   that is explicitly declared static; or
     // (This bullet corresponds to C99 6.2.2p3.)
     return getInternalLinkageFor(D);
   }
 
   if (const auto *Var = dyn_cast<VarDecl>(D)) {
     // - a non-template variable of non-volatile const-qualified type, unless
     //   - it is explicitly declared extern, or
     //   - it is inline or exported, or
     //   - it was previously declared and the prior declaration did not have
     //     internal linkage
     // (There is no equivalent in C99.)
     if (Context.getLangOpts().CPlusPlus &&
         Var->getType().isConstQualified() &&
         !Var->getType().isVolatileQualified() &&
         !Var->isInline() &&
         !isExportedFromModuleInterfaceUnit(Var) &&
         !isa<VarTemplateSpecializationDecl>(Var) &&
         !Var->getDescribedVarTemplate()) {
       const VarDecl *PrevVar = Var->getPreviousDecl();
       if (PrevVar)
         return getLVForDecl(PrevVar, computation);
 
-      if (Var->getStorageClass() != SC_Extern &&
-          Var->getStorageClass() != SC_PrivateExtern &&
+      if (Var->getStorageClass() != StorageClass::Extern &&
+          Var->getStorageClass() != StorageClass::PrivateExtern &&
           !isSingleLineLanguageLinkage(*Var))
         return getInternalLinkageFor(Var);
     }
 
     for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
          PrevVar = PrevVar->getPreviousDecl()) {
-      if (PrevVar->getStorageClass() == SC_PrivateExtern &&
-          Var->getStorageClass() == SC_None)
+      if (PrevVar->getStorageClass() == StorageClass::PrivateExtern &&
+          Var->getStorageClass() == StorageClass::None)
         return getDeclLinkageAndVisibility(PrevVar);
       // Explicitly declared static.
-      if (PrevVar->getStorageClass() == SC_Static)
+      if (PrevVar->getStorageClass() == StorageClass::Static)
         return getInternalLinkageFor(Var);
     }
   } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
     //   - a data member of an anonymous union.
     const VarDecl *VD = IFD->getVarDecl();
     assert(VD && "Expected a VarDecl in this IndirectFieldDecl!");
     return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
   }
if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var) &&
         !IgnoreVarTypeLinkage) {
       LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
       if (!isExternallyVisible(TypeLV.getLinkage()))
         return LinkageInfo::uniqueExternal();
       if (!LV.isVisibilityExplicit())
         LV.mergeVisibility(TypeLV);
     }
 
-    if (Var->getStorageClass() == SC_PrivateExtern)
+    if (Var->getStorageClass() == StorageClass::PrivateExtern)
       LV.mergeVisibility(HiddenVisibility, true);
 
     // Note that Sema::MergeVarDecl already takes care of implementing
     // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
     // to do it here.
 
     // As per function and class template specializations (below),
     // consider LV for the template and template arguments.  We're at file
     // scope, so we do not need to worry about nested specializations.
     if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
       mergeTemplateLV(LV, spec, computation);
     }
 
   //     - a function; or
   } else if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
     // In theory, we can modify the function's LV by the LV of its
     // type unless it has C linkage (see comment above about variables
     // for justification).  In practice, GCC doesn't do this, so it's
     // just too painful to make work.
 
-    if (Function->getStorageClass() == SC_PrivateExtern)
+    if (Function->getStorageClass() == StorageClass::PrivateExtern)
       LV.mergeVisibility(HiddenVisibility, true);
 
     // Note that Sema::MergeCompatibleFunctionDecls already takes care of
     // merging storage classes and visibility attributes, so we don't have to
     // look at previous decls in here.
 
     // In C++, then if the type of the function uses a type with
     // unique-external linkage, it's not legally usable from outside

 LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
                                                LVComputationKind computation) {
   if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
     if (Function->isInAnonymousNamespace() &&
         !isFirstInExternCContext(Function))
       return getInternalLinkageFor(Function);
 
     // This is a "void f();" which got merged with a file static.
-    if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
+    if (Function->getCanonicalDecl()->getStorageClass() == StorageClass::Static)
       return getInternalLinkageFor(Function);
 
     LinkageInfo LV;
     if (!hasExplicitVisibilityAlready(computation)) {
       if (Optional<Visibility> Vis =
               getExplicitVisibility(Function, computation))
         LV.mergeVisibility(*Vis, true);
     }
 
     // Note that Sema::MergeCompatibleFunctionDecls already takes care of
     // merging storage classes and visibility attributes, so we don't have to
     // look at previous decls in here.
 
     return LV;
   }
 
   if (const auto *Var = dyn_cast<VarDecl>(D)) {
     if (Var->hasExternalStorage()) {
       if (Var->isInAnonymousNamespace() && !isFirstInExternCContext(Var))
         return getInternalLinkageFor(Var);
 
       LinkageInfo LV;
-      if (Var->getStorageClass() == SC_PrivateExtern)
+      if (Var->getStorageClass() == StorageClass::PrivateExtern)
         LV.mergeVisibility(HiddenVisibility, true);
       else if (!hasExplicitVisibilityAlready(computation)) {
         if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
           LV.mergeVisibility(*Vis, true);
       }
 
       if (const VarDecl *Prev = Var->getPreviousDecl()) {
         LinkageInfo PrevLV = getLVForDecl(Prev, computation);

 }
 
 //===----------------------------------------------------------------------===//
 // VarDecl Implementation
 //===----------------------------------------------------------------------===//
 
 const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
   switch (SC) {
-  case SC_None:                 break;
-  case SC_Auto:                 return "auto";
-  case SC_Extern:               return "extern";
-  case SC_PrivateExtern:        return "__private_extern__";
-  case SC_Register:             return "register";
-  case SC_Static:               return "static";
+  case StorageClass::None:
+    break;
+  case StorageClass::Auto:
+    return "auto";
+  case StorageClass::Extern:
+    return "extern";
+  case StorageClass::PrivateExtern:
+    return "__private_extern__";
+  case StorageClass::Register:
+    return "register";
+  case StorageClass::Static:
+    return "static";
   }
 
   llvm_unreachable("Invalid storage class");
 }
 
 VarDecl::VarDecl(Kind DK, ASTContext &C, DeclContext *DC,
                  SourceLocation StartLoc, SourceLocation IdLoc,
                  IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
                  StorageClass SC)
     : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
       redeclarable_base(C) {
   static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
                 "VarDeclBitfields too large!");
   static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
                 "ParmVarDeclBitfields too large!");
   static_assert(sizeof(NonParmVarDeclBitfields) <= sizeof(unsigned),
                 "NonParmVarDeclBitfields too large!");
   AllBits = 0;
-  VarDeclBits.SClass = SC;
+  VarDeclBits.SClass = static_cast<int>(SC);
   // Everything else is implicitly initialized to false.
 }
 
 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
                          SourceLocation StartL, SourceLocation IdL,
                          IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
                          StorageClass S) {
   return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
 }
 
 VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID)
       VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
-              QualType(), nullptr, SC_None);
+              QualType(), nullptr, StorageClass::None);
 }
 
 void VarDecl::setStorageClass(StorageClass SC) {
   assert(isLegalForVariable(SC));
-  VarDeclBits.SClass = SC;
+  VarDeclBits.SClass = static_cast<unsigned int>(SC);
 }
 
 VarDecl::TLSKind VarDecl::getTLSKind() const {
   switch (VarDeclBits.TSCSpec) {
   case TSCS_unspecified:
     if (!hasAttr<ThreadAttr>() &&
         !(getASTContext().getLangOpts().OpenMPUseTLS &&
           getASTContext().getTargetInfo().isTLSSupported() &&
QualType ParmVarDecl::getOriginalType() const {
   if (const auto *DT = dyn_cast<DecayedType>(T))
     return DT->getOriginalType();
   return T;
 }
 
 ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID)
       ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
-                  nullptr, QualType(), nullptr, SC_None, nullptr);
+                  nullptr, QualType(), nullptr, StorageClass::None, nullptr);
 }
 
 SourceRange ParmVarDecl::getSourceRange() const {
   if (!hasInheritedDefaultArg()) {
     SourceRange ArgRange = getDefaultArgRange();
     if (ArgRange.isValid())
       return SourceRange(getOuterLocStart(), ArgRange.getEnd());
   }
FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
                            bool isInlineSpecified,
                            ConstexprSpecKind ConstexprKind,
                            Expr *TrailingRequiresClause)
     : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                      StartLoc),
       DeclContext(DK), redeclarable_base(C), Body(), ODRHash(0),
       EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
   assert(T.isNull() || T->isFunctionType());
-  FunctionDeclBits.SClass = S;
+  FunctionDeclBits.SClass = static_cast<uint64_t>(S);
   FunctionDeclBits.IsInline = isInlineSpecified;
   FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
   FunctionDeclBits.IsVirtualAsWritten = false;
   FunctionDeclBits.IsPure = false;
   FunctionDeclBits.HasInheritedPrototype = false;
   FunctionDeclBits.HasWrittenPrototype = true;
   FunctionDeclBits.IsDeleted = false;
   FunctionDeclBits.IsTrivial = false;

 bool FunctionDecl::isInExternCXXContext() const {
   return getLexicalDeclContext()->isExternCXXContext();
 }
 
 bool FunctionDecl::isGlobal() const {
   if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
     return Method->isStatic();
 
-  if (getCanonicalDecl()->getStorageClass() == SC_Static)
+  if (getCanonicalDecl()->getStorageClass() == StorageClass::Static)
     return false;
 
   for (const DeclContext *DC = getDeclContext();
        DC->isNamespace();
        DC = DC->getParent()) {
     if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
       if (!Namespace->getDeclName())
         return false;
unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
   if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
     return BuiltinID;
 
   // This function has the name of a known C library
   // function. Determine whether it actually refers to the C library
   // function or whether it just has the same name.
 
   // If this is a static function, it's not a builtin.
-  if (!ConsiderWrapperFunctions && getStorageClass() == SC_Static)
+  if (!ConsiderWrapperFunctions && getStorageClass() == StorageClass::Static)
     return 0;
 
   // OpenCL v1.2 s6.9.f - The library functions defined in
   // the C99 standard headers are not available.
   if (Context.getLangOpts().OpenCL &&
       Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
     return 0;
 
bool FunctionDecl::isMSExternInline() const {
 
   const ASTContext &Context = getASTContext();
   if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
       !hasAttr<DLLExportAttr>())
     return false;
 
   for (const FunctionDecl *FD = getMostRecentDecl(); FD;
        FD = FD->getPreviousDecl())
-    if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
+    if (!FD->isImplicit() && FD->getStorageClass() == StorageClass::Extern)
       return true;
 
   return false;
 }
 
 static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
-  if (Redecl->getStorageClass() != SC_Extern)
+  if (Redecl->getStorageClass() != StorageClass::Extern)
     return false;
 
   for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
        FD = FD->getPreviousDecl())
-    if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
+    if (!FD->isImplicit() && FD->getStorageClass() == StorageClass::Extern)
       return false;
 
   return true;
 }
 
 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
   // Only consider file-scope declarations in this test.
   if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
     return false;
 
   // Only consider explicit declarations; the presence of a builtin for a
   // libcall shouldn't affect whether a definition is externally visible.
   if (Redecl->isImplicit())
     return false;
 
-  if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
+  if (!Redecl->isInlineSpecified() ||
+      Redecl->getStorageClass() == StorageClass::Extern)
     return true; // Not an inline definition
 
   return false;
 }
 
 /// For a function declaration in C or C++, determine whether this
 /// declaration causes the definition to be externally visible.
 ///
if (Context.getLangOpts().CPlusPlus)
     return false;
 
   if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
     // With GNU inlining, a declaration with 'inline' but not 'extern', forces
     // an externally visible definition.
     //
     // FIXME: What happens if gnu_inline gets added on after the first
     // declaration?
-    if (!isInlineSpecified() || getStorageClass() == SC_Extern)
+    if (!isInlineSpecified() || getStorageClass() == StorageClass::Extern)
       return false;
 
     const FunctionDecl *Prev = this;
     bool FoundBody = false;
     while ((Prev = Prev->getPreviousDecl())) {
       FoundBody |= Prev->doesThisDeclarationHaveABody();
 
       if (Prev->doesThisDeclarationHaveABody()) {
         // If it's not the case that both 'inline' and 'extern' are
         // specified on the definition, then it is always externally visible.
         if (!Prev->isInlineSpecified() ||
-            Prev->getStorageClass() != SC_Extern)
+            Prev->getStorageClass() != StorageClass::Extern)
           return false;
       } else if (Prev->isInlineSpecified() &&
-                 Prev->getStorageClass() != SC_Extern) {
+                 Prev->getStorageClass() != StorageClass::Extern) {
         return false;
       }
     }
     return FoundBody;
   }
 
   // C99 6.7.4p6:
   //   [...] If all of the file scope declarations for a function in a
   //   translation unit include the inline function specifier without extern,
   //   then the definition in that translation unit is an inline definition.
-  if (isInlineSpecified() && getStorageClass() != SC_Extern)
+  if (isInlineSpecified() && getStorageClass() != StorageClass::Extern)
     return false;
   const FunctionDecl *Prev = this;
   bool FoundBody = false;
   while ((Prev = Prev->getPreviousDecl())) {
     FoundBody |= Prev->doesThisDeclarationHaveABody();
     if (RedeclForcesDefC99(Prev))
       return false;
   }
if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
     // Note: If you change the logic here, please change
     // doesDeclarationForceExternallyVisibleDefinition as well.
     //
     // If it's not the case that both 'inline' and 'extern' are
     // specified on the definition, then this inline definition is
     // externally visible.
     if (Context.getLangOpts().CPlusPlus)
       return false;
-    if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
+    if (!(isInlineSpecified() && getStorageClass() == StorageClass::Extern))
       return true;
 
     // If any declaration is 'inline' but not 'extern', then this definition
     // is externally visible.
     for (auto Redecl : redecls()) {
       if (Redecl->isInlineSpecified() &&
-          Redecl->getStorageClass() != SC_Extern)
+          Redecl->getStorageClass() != StorageClass::Extern)
         return true;
     }
 
     return false;
   }
 
   // The rest of this function is C-only.
   assert(!Context.getLangOpts().CPlusPlus &&
FunctionDecl *New =
       new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
                                SC, isInlineSpecified, ConstexprKind,
                                TrailingRequiresClause);
   New->setHasWrittenPrototype(hasWrittenPrototype);
   return New;
 }
 
 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) FunctionDecl(
-      Function, C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(),
-      nullptr, SC_None, false, ConstexprSpecKind::Unspecified, nullptr);
+  return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
+                                  DeclarationNameInfo(), QualType(), nullptr,
+                                  StorageClass::None, false,
+                                  ConstexprSpecKind::Unspecified, nullptr);
 }
 
 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
   return new (C, DC) BlockDecl(DC, L);
 }
 
 BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) BlockDecl(nullptr, SourceLocation());

clang/lib/AST/DeclCXX.cpp

RequiresExprBodyDecl *RequiresExprBodyDecl::CreateDeserialized(ASTContext &C,
   return new (C, ID) RequiresExprBodyDecl(C, nullptr, SourceLocation());
 }
 
 void CXXMethodDecl::anchor() {}
 
 bool CXXMethodDecl::isStatic() const {
   const CXXMethodDecl *MD = getCanonicalDecl();
 
-  if (MD->getStorageClass() == SC_Static)
+  if (MD->getStorageClass() == StorageClass::Static)
     return true;
 
   OverloadedOperatorKind OOK = getDeclName().getCXXOverloadedOperator();
   return isStaticOverloadedOperator(OOK);
 }
 
 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
                                  const CXXMethodDecl *BaseMD) {
CXXMethodDecl *CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
                                      Expr *TrailingRequiresClause) {
   return new (C, RD)
       CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo, T, TInfo, SC,
                     isInline, ConstexprKind, EndLocation,
                     TrailingRequiresClause);
 }
 
 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID)
-      CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
-                    DeclarationNameInfo(), QualType(), nullptr, SC_None, false,
-                    ConstexprSpecKind::Unspecified, SourceLocation(), nullptr);
+  return new (C, ID) CXXMethodDecl(
+      CXXMethod, C, nullptr, SourceLocation(), DeclarationNameInfo(),
+      QualType(), nullptr, StorageClass::None, false,
 }
 
 CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
                                                      bool IsAppleKext) {
   assert(isVirtual() && "this method is expected to be virtual");
 
   // When building with -fapple-kext, all calls must go through the vtable since
   // the kernel linker can do runtime patching of vtables.

 
 CXXConstructorDecl::CXXConstructorDecl(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
     const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
     ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
     ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited,
     Expr *TrailingRequiresClause)
     : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, ConstexprKind, SourceLocation(),
-                    TrailingRequiresClause) {
+                    StorageClass::None, isInline, ConstexprKind,
+                    SourceLocation(), TrailingRequiresClause) {
   setNumCtorInitializers(0);
   setInheritingConstructor(static_cast<bool>(Inherited));
   setImplicit(isImplicitlyDeclared);
   CXXConstructorDeclBits.HasTrailingExplicitSpecifier = ES.getExpr() ? 1 : 0;
   if (Inherited)
     *getTrailingObjects<InheritedConstructor>() = Inherited;
   setExplicitSpecifier(ES);
 }

clang/lib/AST/DeclPrinter.cpp

for (unsigned I = 0, NumTemplateParams = D->getNumTemplateParameterLists();
       printTemplateParameters(D->getTemplateParameterList(I));
   }
 
   CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
   CXXConversionDecl *ConversionDecl = dyn_cast<CXXConversionDecl>(D);
   CXXDeductionGuideDecl *GuideDecl = dyn_cast<CXXDeductionGuideDecl>(D);
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
-    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:
+    case StorageClass::None:
+      break;
+    case StorageClass::Extern:
+      Out << "extern ";
+      break;
+    case StorageClass::Static:
+      Out << "static ";
+      break;
+    case StorageClass::PrivateExtern:
+      Out << "__private_extern__ ";
+      break;
+    case StorageClass::Auto:
+    case StorageClass::Register:
       llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())  Out << "inline ";
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
     if (D->isConstexprSpecified() && !D->isExplicitlyDefaulted())
       Out << "constexpr ";
void DeclPrinter::VisitVarDecl(VarDecl *D) {
   prettyPrintPragmas(D);
 
   QualType T = D->getTypeSourceInfo()
     ? D->getTypeSourceInfo()->getType()
     : D->getASTContext().getUnqualifiedObjCPointerType(D->getType());
 
   if (!Policy.SuppressSpecifiers) {
     StorageClass SC = D->getStorageClass();
-    if (SC != SC_None)
+    if (SC != StorageClass::None)
       Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
 
     switch (D->getTSCSpec()) {
     case TSCS_unspecified:
       break;
     case TSCS___thread:
       Out << "__thread ";
       break;

clang/lib/AST/DeclTemplate.cpp

: VarDecl(DK, Context, DC, StartLoc, IdLoc,
               SpecializedTemplate->getIdentifier(), T, TInfo, S),
       SpecializedTemplate(SpecializedTemplate),
       TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
 
 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
                                                              ASTContext &C)
     : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
-              QualType(), nullptr, SC_None),
+              QualType(), nullptr, StorageClass::None),
       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
 
 VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
   return new (Context, DC) VarTemplateSpecializationDecl(
       VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,

clang/lib/AST/Expr.cpp

bool Expr::refersToVectorElement() const {
   return false;
 }
 
 bool Expr::refersToGlobalRegisterVar() const {
   const Expr *E = this->IgnoreParenImpCasts();
 
   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
     if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
-      if (VD->getStorageClass() == SC_Register &&
+      if (VD->getStorageClass() == StorageClass::Register &&
           VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
         return true;
 
   return false;
 }
 
 bool Expr::isSameComparisonOperand(const Expr* E1, const Expr* E2) {
   E1 = E1->IgnoreParens();

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *USD) {
   JOS.attribute("target", createBareDeclRef(USD->getTargetDecl()));
 }
 
 void JSONNodeDumper::VisitVarDecl(const VarDecl *VD) {
   VisitNamedDecl(VD);
   JOS.attribute("type", createQualType(VD->getType()));
 
   StorageClass SC = VD->getStorageClass();
-  if (SC != SC_None)
+  if (SC != StorageClass::None)
     JOS.attribute("storageClass", VarDecl::getStorageClassSpecifierString(SC));
   switch (VD->getTLSKind()) {
   case VarDecl::TLS_Dynamic: JOS.attribute("tls", "dynamic"); break;
   case VarDecl::TLS_Static: JOS.attribute("tls", "static"); break;
   case VarDecl::TLS_None: break;
   }
   attributeOnlyIfTrue("nrvo", VD->isNRVOVariable());
   attributeOnlyIfTrue("inline", VD->isInline());
void JSONNodeDumper::VisitFieldDecl(const FieldDecl *FD) {
   attributeOnlyIfTrue("isBitfield", FD->isBitField());
   attributeOnlyIfTrue("hasInClassInitializer", FD->hasInClassInitializer());
 }
 
 void JSONNodeDumper::VisitFunctionDecl(const FunctionDecl *FD) {
   VisitNamedDecl(FD);
   JOS.attribute("type", createQualType(FD->getType()));
   StorageClass SC = FD->getStorageClass();
-  if (SC != SC_None)
+  if (SC != StorageClass::None)
     JOS.attribute("storageClass", VarDecl::getStorageClassSpecifierString(SC));
   attributeOnlyIfTrue("inline", FD->isInlineSpecified());
   attributeOnlyIfTrue("virtual", FD->isVirtualAsWritten());
   attributeOnlyIfTrue("pure", FD->isPure());
   attributeOnlyIfTrue("explicitlyDeleted", FD->isDeletedAsWritten());
   attributeOnlyIfTrue("constexpr", FD->isConstexpr());
   attributeOnlyIfTrue("variadic", FD->isVariadic());
 

clang/lib/AST/ODRHash.cpp

if (SpecializationArgs) {
     }
   }
 
   if (const auto *Method = dyn_cast<CXXMethodDecl>(Function)) {
     AddBoolean(Method->isConst());
     AddBoolean(Method->isVolatile());
   }
 
-  ID.AddInteger(Function->getStorageClass());
+  ID.AddInteger(static_cast<int>(Function->getStorageClass()));
   AddBoolean(Function->isInlineSpecified());
   AddBoolean(Function->isVirtualAsWritten());
   AddBoolean(Function->isPure());
   AddBoolean(Function->isDeletedAsWritten());
   AddBoolean(Function->isExplicitlyDefaulted());
 
   AddDecl(Function);
 

clang/lib/AST/TextNodeDumper.cpp

for (const auto *Child : D->chain())
     dumpDeclRef(Child);
 }
 
 void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
   dumpName(D);
   dumpType(D->getType());
 
   StorageClass SC = D->getStorageClass();
-  if (SC != SC_None)
+  if (SC != StorageClass::None)
     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
   if (D->isInlineSpecified())
     OS << " inline";
   if (D->isVirtualAsWritten())
     OS << " virtual";
   if (D->isModulePrivate())
     OS << " __module_private__";
 
void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
   if (D->isModulePrivate())
     OS << " __module_private__";
 }
 
 void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
   dumpName(D);
   dumpType(D->getType());
   StorageClass SC = D->getStorageClass();
-  if (SC != SC_None)
+  if (SC != StorageClass::None)
     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
   switch (D->getTLSKind()) {
   case VarDecl::TLS_None:
     break;
   case VarDecl::TLS_Static:
     OS << " tls";
     break;
   case VarDecl::TLS_Dynamic:

clang/lib/Analysis/CFG.cpp

LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
   assert(!(BuildOpts.AddImplicitDtors && BuildOpts.AddLifetime) &&
          "AddImplicitDtors and AddLifetime cannot be used at the same time");
   if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
       !BuildOpts.AddScopes)
     return Scope;
 
   // Check if variable is local.
   switch (VD->getStorageClass()) {
-  case SC_None:
-  case SC_Auto:
-  case SC_Register:
+  case StorageClass::None:
+  case StorageClass::Auto:
+  case StorageClass::Register:
     break;
   default: return Scope;
   }
 
   if (BuildOpts.AddImplicitDtors) {
     if (!hasTrivialDestructor(VD) || BuildOpts.AddScopes) {
       // Add the variable to scope
       Scope = createOrReuseLocalScope(Scope);

clang/lib/CodeGen/CGBlocks.cpp

CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
 
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(C.VoidPtrTy);
   ArgTys.push_back(C.VoidPtrTy);
   QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {});
 
   FunctionDecl *FD = FunctionDecl::Create(
       C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
-      FunctionTy, nullptr, SC_Static, false, false);
+      FunctionTy, nullptr, StorageClass::Static, false, false);
   setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                      CGM);
   // This is necessary to avoid inheriting the previous line number.
   FD->setImplicit();
   StartFunction(FD, ReturnTy, Fn, FI, args);
   auto AL = ApplyDebugLocation::CreateArtificial(*this);
 
   llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
   IdentifierInfo *II = &C.Idents.get(FuncName);
 
   SmallVector<QualType, 1> ArgTys;
   ArgTys.push_back(C.VoidPtrTy);
   QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {});
 
   FunctionDecl *FD = FunctionDecl::Create(
       C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
-      FunctionTy, nullptr, SC_Static, false, false);
+      FunctionTy, nullptr, StorageClass::Static, false, false);
 
   setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                      CGM);
   // This is necessary to avoid inheriting the previous line number.
   FD->setImplicit();
   StartFunction(FD, ReturnTy, Fn, FI, args);
   markAsIgnoreThreadCheckingAtRuntime(Fn);
 
generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo,
   IdentifierInfo *II
     = &Context.Idents.get("__Block_byref_object_copy_");
 
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(Context.VoidPtrTy);
   ArgTys.push_back(Context.VoidPtrTy);
   QualType FunctionTy = Context.getFunctionType(ReturnTy, ArgTys, {});
 
-  FunctionDecl *FD = FunctionDecl::Create(
-      Context, Context.getTranslationUnitDecl(), SourceLocation(),
-      SourceLocation(), II, FunctionTy, nullptr, SC_Static, false, false);
+  FunctionDecl *FD =
+      FunctionDecl::Create(Context, Context.getTranslationUnitDecl(),
+                           SourceLocation(), SourceLocation(), II, FunctionTy,
+                           nullptr, StorageClass::Static, false, false);
 
   CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   CGF.StartFunction(FD, ReturnTy, Fn, FI, args);
 
   if (generator.needsCopy()) {
     llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0);
 
generateByrefDisposeHelper(CodeGenFunction &CGF,
 
   IdentifierInfo *II
     = &Context.Idents.get("__Block_byref_object_dispose_");
 
   SmallVector<QualType, 1> ArgTys;
   ArgTys.push_back(Context.VoidPtrTy);
   QualType FunctionTy = Context.getFunctionType(R, ArgTys, {});
 
-  FunctionDecl *FD = FunctionDecl::Create(
-      Context, Context.getTranslationUnitDecl(), SourceLocation(),
-      SourceLocation(), II, FunctionTy, nullptr, SC_Static, false, false);
+  FunctionDecl *FD =
+      FunctionDecl::Create(Context, Context.getTranslationUnitDecl(),
+                           SourceLocation(), SourceLocation(), II, FunctionTy,
+                           nullptr, StorageClass::Static, false, false);
 
   CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   CGF.StartFunction(FD, R, Fn, FI, args);
 
   if (generator.needsDispose()) {
     Address addr = CGF.GetAddrOfLocalVar(&Src);
     addr = Address(CGF.Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);

clang/lib/CodeGen/CGBuiltin.cpp

llvm::Function *CodeGenFunction::generateBuiltinOSLogHelperFunction(
   // Attach 'noinline' at -Oz.
   if (CGM.getCodeGenOpts().OptimizeSize == 2)
     Fn->addFnAttr(llvm::Attribute::NoInline);
 
   auto NL = ApplyDebugLocation::CreateEmpty(*this);
   IdentifierInfo *II = &Ctx.Idents.get(Name);
   FunctionDecl *FD = FunctionDecl::Create(
       Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
-      FuncionTy, nullptr, SC_PrivateExtern, false, false);
+      FuncionTy, nullptr, StorageClass::PrivateExtern, false, false);
   // Avoid generating debug location info for the function.
   FD->setImplicit();
 
   StartFunction(FD, ReturnTy, Fn, FI, Args);
 
   // Create a scope with an artificial location for the body of this function.
   auto AL = ApplyDebugLocation::CreateArtificial(*this);
 

clang/lib/CodeGen/CGDecl.cpp

else {
       // Create an artificial VarDecl to generate debug info for.
       IdentifierInfo *NameIdent = VLAExprNames[NameIdx++];
       auto VlaExprTy = VlaSize.NumElts->getType()->getPointerElementType();
       auto QT = getContext().getIntTypeForBitwidth(
           VlaExprTy->getScalarSizeInBits(), false);
       auto *ArtificialDecl = VarDecl::Create(
           getContext(), const_cast<DeclContext *>(D.getDeclContext()),
           D.getLocation(), D.getLocation(), NameIdent, QT,
-          getContext().CreateTypeSourceInfo(QT), SC_Auto);
+          getContext().CreateTypeSourceInfo(QT), StorageClass::Auto);
       ArtificialDecl->setImplicit();
 
       MD = DI->EmitDeclareOfAutoVariable(ArtificialDecl, VlaSize.NumElts,
                                          Builder);
     }
     assert(MD && "No Size expression debug node created");
     DI->registerVLASizeExpression(VlaSize.Type, MD);
   }

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
   const NamedDecl *ND = E->getDecl();
   QualType T = E->getType();
 
   assert(E->isNonOdrUse() != NOUR_Unevaluated &&
          "should not emit an unevaluated operand");
 
   if (const auto *VD = dyn_cast<VarDecl>(ND)) {
     // Global Named registers access via intrinsics only
-    if (VD->getStorageClass() == SC_Register &&
+    if (VD->getStorageClass() == StorageClass::Register &&
         VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
       return EmitGlobalNamedRegister(VD, CGM);
 
     // If this DeclRefExpr does not constitute an odr-use of the variable,
     // we're not permitted to emit a reference to it in general, and it might
     // not be captured if capture would be necessary for a use. Emit the
     // constant value directly instead.
     if (E->isNonOdrUse() == NOUR_Constant &&

clang/lib/CodeGen/CGNonTrivialStruct.cpp

llvm::Function *F =
                                FuncName, &CGM.getModule());
     F->setVisibility(llvm::GlobalValue::HiddenVisibility);
     CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, F);
     CGM.SetLLVMFunctionAttributesForDefinition(nullptr, F);
     IdentifierInfo *II = &Ctx.Idents.get(FuncName);
     FunctionDecl *FD = FunctionDecl::Create(
         Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
         II, Ctx.getFunctionType(Ctx.VoidTy, llvm::None, {}), nullptr,
-        SC_PrivateExtern, false, false);
+        StorageClass::PrivateExtern, false, false);
     CodeGenFunction NewCGF(CGM);
     setCGF(&NewCGF);
     CGF->StartFunction(FD, Ctx.VoidTy, F, FI, Args);
     std::array<Address, N> Addrs =
         getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);
     asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
     CGF->FinishFunction();
     return F;

clang/lib/CodeGen/CGObjC.cpp

CodeGenFunction::GenerateObjCAtomicSetterCopyHelperFunction(
 
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(DestTy);
   ArgTys.push_back(SrcTy);
   QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {});
 
   FunctionDecl *FD = FunctionDecl::Create(
       C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
-      FunctionTy, nullptr, SC_Static, false, false);
+      FunctionTy, nullptr, StorageClass::Static, false, false);
 
   FunctionArgList args;
   ImplicitParamDecl DstDecl(C, FD, SourceLocation(), /*Id=*/nullptr, DestTy,
                             ImplicitParamDecl::Other);
   args.push_back(&DstDecl);
   ImplicitParamDecl SrcDecl(C, FD, SourceLocation(), /*Id=*/nullptr, SrcTy,
                             ImplicitParamDecl::Other);
   args.push_back(&SrcDecl);
CodeGenFunction::GenerateObjCAtomicGetterCopyHelperFunction(
 
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(DestTy);
   ArgTys.push_back(SrcTy);
   QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {});
 
   FunctionDecl *FD = FunctionDecl::Create(
       C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
-      FunctionTy, nullptr, SC_Static, false, false);
+      FunctionTy, nullptr, StorageClass::Static, false, false);
 
   FunctionArgList args;
   ImplicitParamDecl DstDecl(C, FD, SourceLocation(), /*Id=*/nullptr, DestTy,
                             ImplicitParamDecl::Other);
   args.push_back(&DstDecl);
   ImplicitParamDecl SrcDecl(C, FD, SourceLocation(), /*Id=*/nullptr, SrcTy,
                             ImplicitParamDecl::Other);
   args.push_back(&SrcDecl);

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

if (isa<ImplicitParamDecl>(NativeParam))
     return ImplicitParamDecl::Create(
         CGM.getContext(), /*DC=*/nullptr, NativeParam->getLocation(),
         NativeParam->getIdentifier(), ArgType, ImplicitParamDecl::Other);
   return ParmVarDecl::Create(
       CGM.getContext(),
       const_cast<DeclContext *>(NativeParam->getDeclContext()),
       NativeParam->getBeginLoc(), NativeParam->getLocation(),
       NativeParam->getIdentifier(), ArgType,
-      /*TInfo=*/nullptr, SC_None, /*DefArg=*/nullptr);
+      /*TInfo=*/nullptr, StorageClass::None, /*DefArg=*/nullptr);
 }
 
 Address
 CGOpenMPRuntimeGPU::getParameterAddress(CodeGenFunction &CGF,
                                           const VarDecl *NativeParam,
                                           const VarDecl *TargetParam) const {
   assert(NativeParam != TargetParam &&
          NativeParam->getType()->isReferenceType() &&

clang/lib/CodeGen/CGStmt.cpp

AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr,
                        std::string *GCCReg = nullptr) {
   const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);
   if (!AsmDeclRef)
     return Constraint;
   const ValueDecl &Value = *AsmDeclRef->getDecl();
   const VarDecl *Variable = dyn_cast<VarDecl>(&Value);
   if (!Variable)
     return Constraint;
-  if (Variable->getStorageClass() != SC_Register)
+  if (Variable->getStorageClass() != StorageClass::Register)
     return Constraint;
   AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>();
   if (!Attr)
     return Constraint;
   StringRef Register = Attr->getLabel();
   assert(Target.isValidGCCRegisterName(Register));
   // We're using validateOutputConstraint here because we only care if
   // this is a register constraint.

clang/lib/CodeGen/CGStmtOpenMP.cpp

static llvm::Function *emitOutlinedFunctionPrologue(
   auto I = FO.S->captures().begin();
   FunctionDecl *DebugFunctionDecl = nullptr;
   if (!FO.UIntPtrCastRequired) {
     FunctionProtoType::ExtProtoInfo EPI;
     QualType FunctionTy = Ctx.getFunctionType(Ctx.VoidTy, llvm::None, EPI);
     DebugFunctionDecl = FunctionDecl::Create(
         Ctx, Ctx.getTranslationUnitDecl(), FO.S->getBeginLoc(),
         SourceLocation(), DeclarationName(), FunctionTy,
-        Ctx.getTrivialTypeSourceInfo(FunctionTy), SC_Static,
+        Ctx.getTrivialTypeSourceInfo(FunctionTy), StorageClass::Static,
         /*isInlineSpecified=*/false, /*hasWrittenPrototype=*/false);
   }
   for (const FieldDecl *FD : RD->fields()) {
     QualType ArgType = FD->getType();
     IdentifierInfo *II = nullptr;
     VarDecl *CapVar = nullptr;
 
     // If this is a capture by copy and the type is not a pointer, the outlined
for (const FieldDecl *FD : RD->fields()) {
     if (ArgType->isVariablyModifiedType())
       ArgType = getCanonicalParamType(Ctx, ArgType);
     VarDecl *Arg;
     if (DebugFunctionDecl && (CapVar || I->capturesThis())) {
       Arg = ParmVarDecl::Create(
           Ctx, DebugFunctionDecl,
           CapVar ? CapVar->getBeginLoc() : FD->getBeginLoc(),
           CapVar ? CapVar->getLocation() : FD->getLocation(), II, ArgType,
-          /*TInfo=*/nullptr, SC_None, /*DefArg=*/nullptr);
+          /*TInfo=*/nullptr, StorageClass::None, /*DefArg=*/nullptr);
     } else {
       Arg = ImplicitParamDecl::Create(Ctx, /*DC=*/nullptr, FD->getLocation(),
                                       II, ArgType, ImplicitParamDecl::Other);
     }
     Args.emplace_back(Arg);
     // Do not cast arguments if we emit function with non-original types.
     TargetArgs.emplace_back(
         FO.UIntPtrCastRequired

clang/lib/CodeGen/ItaniumCXXABI.cpp

static llvm::Function *createGlobalInitOrCleanupFn(CodeGen::CodeGenModule &CGM,
 
   return GlobalInitOrCleanupFn;
 }
 
 static FunctionDecl *
 createGlobalInitOrCleanupFnDecl(CodeGen::CodeGenModule &CGM, StringRef FnName) {
   ASTContext &Ctx = CGM.getContext();
   QualType FunctionTy = Ctx.getFunctionType(Ctx.VoidTy, llvm::None, {});
-  return FunctionDecl::Create(
-      Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
-      &Ctx.Idents.get(FnName), FunctionTy, nullptr, SC_Static, false, false);
+  return FunctionDecl::Create(Ctx, Ctx.getTranslationUnitDecl(),
+                              SourceLocation(), SourceLocation(),
+                              &Ctx.Idents.get(FnName), FunctionTy, nullptr,
+                              StorageClass::Static, false, false);
 }
 
 void CodeGenModule::unregisterGlobalDtorsWithUnAtExit() {
   for (const auto &I : DtorsUsingAtExit) {
     int Priority = I.first;
     std::string GlobalCleanupFnName =
         std::string("__GLOBAL_cleanup_") + llvm::to_string(Priority);
 

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

auto ignoreDecl = [this, isVisible](const NamedDecl *ND) -> bool {
       if (!isVisible(ND))
         return true;
 
       if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
         if (const auto *Parent = VD->getParentFunctionOrMethod())
           if (isa<BlockDecl>(Parent) || isa<CXXMethodDecl>(Parent))
             return true;
 
-        if ((VD->getStorageClass() == StorageClass::SC_Extern) ||
-            (VD->getStorageClass() == StorageClass::SC_Static &&
+        if ((VD->getStorageClass() == StorageClass::Extern) ||
+            (VD->getStorageClass() == StorageClass::Static &&
              VD->getParentFunctionOrMethod() == nullptr))
           return true;
       }
 
       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
         if (FD->isInlined() && !isa<CXXMethodDecl>(FD) &&
             !Instance.getLangOpts().GNUInline)
           return true;
         if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
           if (const auto *RC = dyn_cast<CXXRecordDecl>(MD->getParent()))
             if (isa<ClassTemplateDecl>(RC->getParent()) || !isVisible(RC))
               return true;
           if (MD->isDependentContext() || !MD->hasBody())
             return true;
         }
-        if (FD->getStorageClass() == StorageClass::SC_Static)
+        if (FD->getStorageClass() == StorageClass::Static)
           return true;
       }
       return false;
     };
 
     auto getParentFunctionDecl = [](const NamedDecl *ND) -> const NamedDecl * {
       if (const VarDecl *VD = dyn_cast<VarDecl>(ND))
         if (const auto *FD =

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

 
 // SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
 void RewriteModernObjC::SynthSelGetUidFunctionDecl() {
   IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getFuncType =
     getSimpleFunctionType(Context->getObjCSelType(), ArgTys);
-  SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                               SourceLocation(),
-                                               SourceLocation(),
-                                               SelGetUidIdent, getFuncType,
-                                               nullptr, SC_Extern);
+  SelGetUidFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), SelGetUidIdent,
+      getFuncType, nullptr, StorageClass::Extern);
 }
 
 void RewriteModernObjC::RewriteFunctionDecl(FunctionDecl *FD) {
   // declared in <objc/objc.h>
   if (FD->getIdentifier() &&
       FD->getName() == "sel_registerName") {
     SelGetUidFunctionDecl = FD;
     return;
void RewriteModernObjC::SynthSuperConstructorFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys);
-  SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                     SourceLocation(),
-                                                     SourceLocation(),
-                                                     msgSendIdent, msgSendType,
-                                                     nullptr, SC_Extern);
+  SuperConstructorFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
 void RewriteModernObjC::SynthMsgSendFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                             SourceLocation(),
-                                             SourceLocation(),
-                                             msgSendIdent, msgSendType, nullptr,
-                                             SC_Extern);
+  MsgSendFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(void);
 void RewriteModernObjC::SynthMsgSendSuperFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(Context->VoidTy);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendSuperFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
 void RewriteModernObjC::SynthMsgSendStretFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendStretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendSuperStretFunctionDecl -
 // id objc_msgSendSuper_stret(void);
 void RewriteModernObjC::SynthMsgSendSuperStretFunctionDecl() {
   IdentifierInfo *msgSendIdent =
     &Context->Idents.get("objc_msgSendSuper_stret");
   SmallVector<QualType, 2> ArgTys;
   ArgTys.push_back(Context->VoidTy);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                       SourceLocation(),
-                                                       SourceLocation(),
-                                                       msgSendIdent,
-                                                       msgSendType, nullptr,
-                                                       SC_Extern);
+  MsgSendSuperStretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
 void RewriteModernObjC::SynthMsgSendFpretFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
                                                ArgTys, /*variadic=*/true);
-  MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendFpretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetClassFunctionDecl - Class objc_getClass(const char *name);
 void RewriteModernObjC::SynthGetClassFunctionDecl() {
   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
                                                 ArgTys);
-  GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                              SourceLocation(),
-                                              SourceLocation(),
-                                              getClassIdent, getClassType,
-                                              nullptr, SC_Extern);
+  GetClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
 void RewriteModernObjC::SynthGetSuperClassFunctionDecl() {
   IdentifierInfo *getSuperClassIdent =
     &Context->Idents.get("class_getSuperclass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getObjCClassType());
   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
                                                 ArgTys);
-  GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                   SourceLocation(),
-                                                   SourceLocation(),
-                                                   getSuperClassIdent,
-                                                   getClassType, nullptr,
-                                                   SC_Extern);
+  GetSuperClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getSuperClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetMetaClassFunctionDecl - Class objc_getMetaClass(const char *name);
 void RewriteModernObjC::SynthGetMetaClassFunctionDecl() {
   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
                                                 ArgTys);
-  GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  getClassIdent, getClassType,
-                                                  nullptr, SC_Extern);
+  GetMetaClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   assert (Exp != nullptr && "Expected non-null ObjCStringLiteral");
   QualType strType = getConstantStringStructType();
 
   std::string S = "__NSConstantStringImpl_";
 
Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   llvm::raw_string_ostream prettyBuf(prettyBufS);
   Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
   Preamble += prettyBuf.str();
   Preamble += ",";
   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
 
   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                    SourceLocation(), &Context->Idents.get(S),
-                                   strType, nullptr, SC_Static);
+                                   strType, nullptr, StorageClass::Static);
   DeclRefExpr *DRE = new (Context)
       DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
   Expr *Unop = UnaryOperator::Create(
       const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
       Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
       SourceLocation(), false, FPOptionsOverride());
   // cast to NSConstantString *
   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
static SourceLocation getFunctionSourceLocation (RewriteModernObjC &R,
                                                  FunctionDecl *FD) {
   if (FD->isExternC()  && !FD->isMain()) {
     const DeclContext *DC = FD->getDeclContext();
     if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC))
       // if it is extern "C" {...}, return function decl's own location.
       if (!LSD->getRBraceLoc().isValid())
         return LSD->getExternLoc();
   }
-  if (FD->getStorageClass() != SC_None)
+  if (FD->getStorageClass() != StorageClass::None)
     R.RewriteBlockLiteralFunctionDecl(FD);
   return FD->getTypeSpecStartLoc();
 }
 
 void RewriteModernObjC::RewriteLineDirective(const Decl *D) {
 
   SourceLocation Location = D->getLocation();
 
else {
     FunLocStart = CurMethodDef->getBeginLoc();
   }
 
   InsertText(FunLocStart, str);
   ++stretCount;
 
   // AST for __Stretn(receiver, args).s;
   IdentifierInfo *ID = &Context->Idents.get(name);
-  FunctionDecl *FD =
-      FunctionDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
-                           ID, FuncType, nullptr, SC_Extern, false, false);
+  FunctionDecl *FD = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), ID, FuncType,
+      nullptr, StorageClass::Extern, false, false);
   DeclRefExpr *DRE = new (Context)
       DeclRefExpr(*Context, FD, false, castType, VK_RValue, SourceLocation());
   CallExpr *STCE =
       CallExpr::Create(*Context, DRE, MsgExprs, castType, VK_LValue,
                        SourceLocation(), FPOptionsOverride());
 
   FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                     SourceLocation(),

 /// RewriteObjCProtocolExpr - Rewrite a protocol expression into
 /// a synthesized/forward data reference (to the protocol's metadata).
 /// The forward references (and metadata) are generated in
 /// RewriteModernObjC::HandleTranslationUnit().
 Stmt *RewriteModernObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
   std::string Name = "_OBJC_PROTOCOL_REFERENCE_$_" +
                       Exp->getProtocol()->getNameAsString();
   IdentifierInfo *ID = &Context->Idents.get(Name);
-  VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
-                                SourceLocation(), ID, getProtocolType(),
-                                nullptr, SC_Extern);
+  VarDecl *VD =
+      VarDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(), ID,
+                      getProtocolType(), nullptr, StorageClass::Extern);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(
       *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
   CastExpr *castExpr = NoTypeInfoCStyleCastExpr(
       Context, Context->getPointerType(DRE->getType()), CK_BitCast, DRE);
   ReplaceStmt(Exp, castExpr);
   ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
   return castExpr;
if (hasCopy) {
     S += ", __" + FunName.str() + "_block_dispose_" + utostr(i);
   }
   S += "};\n";
   return S;
 }
 
 void RewriteModernObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
                                           StringRef FunName) {
-  bool RewriteSC = (GlobalVarDecl &&
-                    !Blocks.empty() &&
-                    GlobalVarDecl->getStorageClass() == SC_Static &&
+  bool RewriteSC = (GlobalVarDecl && !Blocks.empty() &&
+                    GlobalVarDecl->getStorageClass() == StorageClass::Static &&
                     GlobalVarDecl->getType().getCVRQualifiers());
   if (RewriteSC) {
     std::string SC(" void __");
     SC += GlobalVarDecl->getNameAsString();
     SC += "() {}";
     InsertText(FunLocStart, SC);
   }
 
for (unsigned i = 0, count=0; i < Blocks.size(); i++) {
     BlockByCopyDecls.clear();
     BlockByCopyDeclsPtrSet.clear();
     ImportedBlockDecls.clear();
   }
   if (RewriteSC) {
     // Must insert any 'const/volatile/static here. Since it has been
     // removed as result of rewriting of block literals.
     std::string SC;
-    if (GlobalVarDecl->getStorageClass() == SC_Static)
+    if (GlobalVarDecl->getStorageClass() == StorageClass::Static)
       SC = "static ";
     if (GlobalVarDecl->getType().isConstQualified())
       SC += "const ";
     if (GlobalVarDecl->getType().isVolatileQualified())
       SC += "volatile ";
     if (GlobalVarDecl->getType().isRestrictQualified())
       SC += "restrict ";
     InsertText(FunLocStart, SC);
for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
         ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
   }
 }
 
 FunctionDecl *RewriteModernObjC::SynthBlockInitFunctionDecl(StringRef name) {
   IdentifierInfo *ID = &Context->Idents.get(name);
   QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
   return FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
-                              SourceLocation(), ID, FType, nullptr, SC_Extern,
-                              false, false);
+                              SourceLocation(), ID, FType, nullptr,
+                              StorageClass::Extern, false, false);
 }
 
 Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp,
                      const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs) {
   const BlockDecl *block = Exp->getBlockDecl();
 
   Blocks.push_back(Exp);
 
DeclRefExpr *Arg = new (Context) DeclRefExpr(
       *Context, FD, false, FD->getType(), VK_LValue, SourceLocation());
   CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy,
                                                 CK_BitCast, Arg);
   InitExprs.push_back(castExpr);
 
   // Initialize the block descriptor.
   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 
-  VarDecl *NewVD = VarDecl::Create(
-      *Context, TUDecl, SourceLocation(), SourceLocation(),
-      &Context->Idents.get(DescData), Context->VoidPtrTy, nullptr, SC_Static);
+  VarDecl *NewVD =
+      VarDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
+                      &Context->Idents.get(DescData), Context->VoidPtrTy,
+                      nullptr, StorageClass::Static);
   UnaryOperator *DescRefExpr = UnaryOperator::Create(
       const_cast<ASTContext &>(*Context),
       new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy,
                                 VK_LValue, SourceLocation()),
       UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_RValue,
       OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
   InitExprs.push_back(DescRefExpr);
 
if (BaseExpr->getType()->isObjCObjectPointerType()) {
 
       ReferencedIvars[clsDeclared].insert(D);
 
       // cast offset to "char *".
       CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context,
                                                     Context->getPointerType(Context->CharTy),
                                                     CK_BitCast,
                                                     BaseExpr);
-      VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
-                                       SourceLocation(), &Context->Idents.get(IvarOffsetName),
-                                       Context->UnsignedLongTy, nullptr,
-                                       SC_Extern);
+      VarDecl *NewVD = VarDecl::Create(
+          *Context, TUDecl, SourceLocation(), SourceLocation(),
+          &Context->Idents.get(IvarOffsetName), Context->UnsignedLongTy,
+          nullptr, StorageClass::Extern);
       DeclRefExpr *DRE = new (Context)
           DeclRefExpr(*Context, NewVD, false, Context->UnsignedLongTy,
                       VK_LValue, SourceLocation());
       BinaryOperator *addExpr = BinaryOperator::Create(
           *Context, castExpr, DRE, BO_Add,
           Context->getPointerType(Context->CharTy), VK_RValue, OK_Ordinary,
           SourceLocation(), FPOptionsOverride());
       // Don't forget the parens to enforce the proper binding.

clang/lib/Frontend/Rewrite/RewriteObjC.cpp

 
 // SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
 void RewriteObjC::SynthSelGetUidFunctionDecl() {
   IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getFuncType =
     getSimpleFunctionType(Context->getObjCSelType(), ArgTys);
-  SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                               SourceLocation(),
-                                               SourceLocation(),
-                                               SelGetUidIdent, getFuncType,
-                                               nullptr, SC_Extern);
+  SelGetUidFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), SelGetUidIdent,
+      getFuncType, nullptr, StorageClass::Extern);
 }
 
 void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
   // declared in <objc/objc.h>
   if (FD->getIdentifier() &&
       FD->getName() == "sel_registerName") {
     SelGetUidFunctionDecl = FD;
     return;
void RewriteObjC::SynthSuperConstructorFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys);
-  SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                     SourceLocation(),
-                                                     SourceLocation(),
-                                                     msgSendIdent, msgSendType,
-                                                     nullptr, SC_Extern);
+  SuperConstructorFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
 void RewriteObjC::SynthMsgSendFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                             SourceLocation(),
-                                             SourceLocation(),
-                                             msgSendIdent, msgSendType,
-                                             nullptr, SC_Extern);
+  MsgSendFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
 void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
   SmallVector<QualType, 16> ArgTys;
   RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                       SourceLocation(), SourceLocation(),
                                       &Context->Idents.get("objc_super"));
   QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
   assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendSuperFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
 void RewriteObjC::SynthMsgSendStretFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendStretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendSuperStretFunctionDecl -
 // id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...);
 void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
   IdentifierInfo *msgSendIdent =
     &Context->Idents.get("objc_msgSendSuper_stret");
   SmallVector<QualType, 16> ArgTys;
   RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                       SourceLocation(), SourceLocation(),
                                       &Context->Idents.get("objc_super"));
   QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
   assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                                ArgTys, /*variadic=*/true);
-  MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                       SourceLocation(),
-                                                       SourceLocation(),
-                                                       msgSendIdent,
-                                                       msgSendType, nullptr,
-                                                       SC_Extern);
+  MsgSendSuperStretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
 void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
   SmallVector<QualType, 16> ArgTys;
   QualType argT = Context->getObjCIdType();
   assert(!argT.isNull() && "Can't find 'id' type");
   ArgTys.push_back(argT);
   argT = Context->getObjCSelType();
   assert(!argT.isNull() && "Can't find 'SEL' type");
   ArgTys.push_back(argT);
   QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
                                                ArgTys, /*variadic=*/true);
-  MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  msgSendIdent, msgSendType,
-                                                  nullptr, SC_Extern);
+  MsgSendFpretFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
+      msgSendType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetClassFunctionDecl - id objc_getClass(const char *name);
 void RewriteObjC::SynthGetClassFunctionDecl() {
   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
                                                 ArgTys);
-  GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                              SourceLocation(),
-                                              SourceLocation(),
-                                              getClassIdent, getClassType,
-                                              nullptr, SC_Extern);
+  GetClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
 void RewriteObjC::SynthGetSuperClassFunctionDecl() {
   IdentifierInfo *getSuperClassIdent =
     &Context->Idents.get("class_getSuperclass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getObjCClassType());
   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
                                                 ArgTys);
-  GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                   SourceLocation(),
-                                                   SourceLocation(),
-                                                   getSuperClassIdent,
-                                                   getClassType, nullptr,
-                                                   SC_Extern);
+  GetSuperClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getSuperClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 // SynthGetMetaClassFunctionDecl - id objc_getMetaClass(const char *name);
 void RewriteObjC::SynthGetMetaClassFunctionDecl() {
   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
   SmallVector<QualType, 16> ArgTys;
   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
   QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
                                                 ArgTys);
-  GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
-                                                  SourceLocation(),
-                                                  SourceLocation(),
-                                                  getClassIdent, getClassType,
-                                                  nullptr, SC_Extern);
+  GetMetaClassFunctionDecl = FunctionDecl::Create(
+      *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
+      getClassType, nullptr, StorageClass::Extern);
 }
 
 Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   assert(Exp != nullptr && "Expected non-null ObjCStringLiteral");
   QualType strType = getConstantStringStructType();
 
   std::string S = "__NSConstantStringImpl_";
 
Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   llvm::raw_string_ostream prettyBuf(prettyBufS);
   Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
   Preamble += prettyBuf.str();
   Preamble += ",";
   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
 
   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                    SourceLocation(), &Context->Idents.get(S),
-                                   strType, nullptr, SC_Static);
+                                   strType, nullptr, StorageClass::Static);
   DeclRefExpr *DRE = new (Context)
       DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
   Expr *Unop = UnaryOperator::Create(
       const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
       Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
       SourceLocation(), false, FPOptionsOverride());
   // cast to NSConstantString *
   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),

 
 /// RewriteObjCProtocolExpr - Rewrite a protocol expression into
 /// a synthesized/forward data reference (to the protocol's metadata).
 /// The forward references (and metadata) are generated in
 /// RewriteObjC::HandleTranslationUnit().
 Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
   std::string Name = "_OBJC_PROTOCOL_" + Exp->getProtocol()->getNameAsString();
   IdentifierInfo *ID = &Context->Idents.get(Name);
-  VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
-                                SourceLocation(), ID, getProtocolType(),
-                                nullptr, SC_Extern);
+  VarDecl *VD =
+      VarDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(), ID,
+                      getProtocolType(), nullptr, StorageClass::Extern);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(
       *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
   Expr *DerefExpr = UnaryOperator::Create(
       const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
       Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
       SourceLocation(), false, FPOptionsOverride());
   CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, DerefExpr->getType(),
                                                 CK_BitCast,
std::string RewriteObjC::SynthesizeBlockDescriptor(std::string DescTag,
   return S;
 }
 
 void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
                                           StringRef FunName) {
   // Insert declaration for the function in which block literal is used.
   if (CurFunctionDeclToDeclareForBlock && !Blocks.empty())
     RewriteBlockLiteralFunctionDecl(CurFunctionDeclToDeclareForBlock);
-  bool RewriteSC = (GlobalVarDecl &&
-                    !Blocks.empty() &&
-                    GlobalVarDecl->getStorageClass() == SC_Static &&
+  bool RewriteSC = (GlobalVarDecl && !Blocks.empty() &&
+                    GlobalVarDecl->getStorageClass() == StorageClass::Static &&
                     GlobalVarDecl->getType().getCVRQualifiers());
   if (RewriteSC) {
     std::string SC(" void __");
     SC += GlobalVarDecl->getNameAsString();
     SC += "() {}";
     InsertText(FunLocStart, SC);
   }
 
for (unsigned i = 0, count=0; i < Blocks.size(); i++) {
     BlockByCopyDecls.clear();
     BlockByCopyDeclsPtrSet.clear();
     ImportedBlockDecls.clear();
   }
   if (RewriteSC) {
     // Must insert any 'const/volatile/static here. Since it has been
     // removed as result of rewriting of block literals.
     std::string SC;
-    if (GlobalVarDecl->getStorageClass() == SC_Static)
+    if (GlobalVarDecl->getStorageClass() == StorageClass::Static)
       SC = "static ";
     if (GlobalVarDecl->getType().isConstQualified())
       SC += "const ";
     if (GlobalVarDecl->getType().isVolatileQualified())
       SC += "volatile ";
     if (GlobalVarDecl->getType().isRestrictQualified())
       SC += "restrict ";
     InsertText(FunLocStart, SC);
for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
         ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
   }
 }
 
 FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(StringRef name) {
   IdentifierInfo *ID = &Context->Idents.get(name);
   QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
   return FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
-                              SourceLocation(), ID, FType, nullptr, SC_Extern,
-                              false, false);
+                              SourceLocation(), ID, FType, nullptr,
+                              StorageClass::Extern, false, false);
 }
 
 Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp,
                      const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs) {
   const BlockDecl *block = Exp->getBlockDecl();
   Blocks.push_back(Exp);
 
   CollectBlockDeclRefInfo(Exp);
DeclRefExpr *Arg = new (Context) DeclRefExpr(
       *Context, FD, false, FD->getType(), VK_LValue, SourceLocation());
   CastExpr *castExpr =
       NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, CK_BitCast, Arg);
   InitExprs.push_back(castExpr);
 
   // Initialize the block descriptor.
   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 
-  VarDecl *NewVD = VarDecl::Create(
-      *Context, TUDecl, SourceLocation(), SourceLocation(),
-      &Context->Idents.get(DescData), Context->VoidPtrTy, nullptr, SC_Static);
+  VarDecl *NewVD =
+      VarDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
+                      &Context->Idents.get(DescData), Context->VoidPtrTy,
+                      nullptr, StorageClass::Static);
   UnaryOperator *DescRefExpr = UnaryOperator::Create(
       const_cast<ASTContext &>(*Context),
       new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy,
                                 VK_LValue, SourceLocation()),
       UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_RValue,
       OK_Ordinary, SourceLocation(), false, FPOptionsOverride());
   InitExprs.push_back(DescRefExpr);
 

clang/lib/Sema/Sema.cpp

for (UnusedFileScopedDeclsType::iterator
           DiagD = FD;
         if (DiagD->isDeleted())
           continue; // Deleted functions are supposed to be unused.
         if (DiagD->isReferenced()) {
           if (isa<CXXMethodDecl>(DiagD))
             Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
                 << DiagD;
           else {
-            if (FD->getStorageClass() == SC_Static &&
+            if (FD->getStorageClass() == StorageClass::Static &&
                 !FD->isInlineSpecified() &&
                 !SourceMgr.isInMainFile(
                     SourceMgr.getExpansionLoc(FD->getLocation())))
               Diag(DiagD->getLocation(),
                    diag::warn_unneeded_static_internal_decl)
                   << DiagD;
             else
               Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
                   << /*function*/ 0 << DiagD;
           }
         } else {

clang/lib/Sema/SemaChecking.cpp

bool Sema::SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {
   bool IsCRegister = false;
 
   if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
     if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
       SecondArgIsLastNamedArgument = PV == LastParam;
 
       Type = PV->getType();
       ParamLoc = PV->getLocation();
-      IsCRegister =
-          PV->getStorageClass() == SC_Register && !getLangOpts().CPlusPlus;
+      IsCRegister = PV->getStorageClass() == StorageClass::Register &&
+                    !getLangOpts().CPlusPlus;
     }
   }
 
   if (!SecondArgIsLastNamedArgument)
     Diag(TheCall->getArg(1)->getBeginLoc(),
          diag::warn_second_arg_of_va_start_not_last_named_param);
   else if (IsCRegister || Type->isReferenceType() ||
            Type->isSpecificBuiltinType(BuiltinType::Float) || [=] {
Diag(SL, diag::note_strncat_wrong_size)
     << FixItHint::CreateReplacement(SR, OS.str());
 }
 
 namespace {
 void CheckFreeArgumentsOnLvalue(Sema &S, const std::string &CalleeName,
                                 const UnaryOperator *UnaryExpr,
                                 const VarDecl *Var) {
   StorageClass Class = Var->getStorageClass();
-  if (Class == StorageClass::SC_Extern ||
-      Class == StorageClass::SC_PrivateExtern ||
+  if (Class == StorageClass::Extern || Class == StorageClass::PrivateExtern ||
       Var->getType()->isReferenceType())
     return;
 
   S.Diag(UnaryExpr->getBeginLoc(), diag::warn_free_nonheap_object)
       << CalleeName << Var;
 }
 
 void CheckFreeArgumentsOnLvalue(Sema &S, const std::string &CalleeName,

clang/lib/Sema/SemaCoroutine.cpp

VarDecl *Sema::buildCoroutinePromise(SourceLocation Loc) {
   QualType T = FD->getType()->isDependentType() || IsThisDependentType
                    ? Context.DependentTy
                    : lookupPromiseType(*this, FD, Loc);
   if (T.isNull())
     return nullptr;
 
   auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(),
                              &PP.getIdentifierTable().get("__promise"), T,
-                             Context.getTrivialTypeSourceInfo(T, Loc), SC_None);
+                             Context.getTrivialTypeSourceInfo(T, Loc),
+                             StorageClass::None);
   VD->setImplicit();
   CheckVariableDeclarationType(VD);
   if (VD->isInvalidDecl())
     return nullptr;
 
   auto *ScopeInfo = getCurFunction();
 
   // Build a list of arguments, based on the coroutine function's arguments,
if (GroType->isVoidType()) {
     S.PerformMoveOrCopyInitialization(Entity, nullptr, FnRetType, ReturnValue);
     noteMemberDeclaredHere(S, ReturnValue, Fn);
     return false;
   }
 
   auto *GroDecl = VarDecl::Create(
       S.Context, &FD, FD.getLocation(), FD.getLocation(),
       &S.PP.getIdentifierTable().get("__coro_gro"), GroType,
-      S.Context.getTrivialTypeSourceInfo(GroType, Loc), SC_None);
+      S.Context.getTrivialTypeSourceInfo(GroType, Loc), StorageClass::None);
   GroDecl->setImplicit();
 
   S.CheckVariableDeclarationType(GroDecl);
   if (GroDecl->isInvalidDecl())
     return false;
 
   InitializedEntity Entity = InitializedEntity::InitializeVariable(GroDecl);
   ExprResult Res = S.PerformMoveOrCopyInitialization(Entity, nullptr, GroType,
return S
       .get();
 }
 
 /// Build a variable declaration for move parameter.
 static VarDecl *buildVarDecl(Sema &S, SourceLocation Loc, QualType Type,
                              IdentifierInfo *II) {
   TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc);
   VarDecl *Decl = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, II, Type,
-                                  TInfo, SC_None);
+                                  TInfo, StorageClass::None);
   Decl->setImplicit();
   return Decl;
 }
 
 // Build statements that move coroutine function parameters to the coroutine
 // frame, and store them on the function scope info.
 bool Sema::buildCoroutineParameterMoves(SourceLocation Loc) {
   assert(isa<FunctionDecl>(CurContext) && "not in a function scope");

clang/lib/Sema/SemaDecl.cpp

FunctionDecl *Sema::CreateBuiltin(IdentifierInfo *II, QualType Type,
   if (getLangOpts().CPlusPlus) {
     LinkageSpecDecl *CLinkageDecl = LinkageSpecDecl::Create(
         Context, Parent, Loc, Loc, LinkageSpecDecl::lang_c, false);
     CLinkageDecl->setImplicit();
     Parent->addDecl(CLinkageDecl);
     Parent = CLinkageDecl;
   }
 
-  FunctionDecl *New = FunctionDecl::Create(Context, Parent, Loc, Loc, II, Type,
-                                           /*TInfo=*/nullptr, SC_Extern, false,
-                                           Type->isFunctionProtoType());
+  FunctionDecl *New =
+      FunctionDecl::Create(Context, Parent, Loc, Loc, II, Type,
+                           /*TInfo=*/nullptr, StorageClass::Extern, false,
   New->setImplicit();
   New->addAttr(BuiltinAttr::CreateImplicit(Context, ID));
 
   // Create Decl objects for each parameter, adding them to the
   // FunctionDecl.
   if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(Type)) {
     SmallVector<ParmVarDecl *, 16> Params;
     for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
       ParmVarDecl *parm = ParmVarDecl::Create(
           Context, New, SourceLocation(), SourceLocation(), nullptr,
-          FT->getParamType(i), /*TInfo=*/nullptr, SC_None, nullptr);
+          FT->getParamType(i), /*TInfo=*/nullptr, StorageClass::None, nullptr);
       parm->setScopeInfo(0, i);
       Params.push_back(parm);
     }
     New->setParams(Params);
   }
 
   AddKnownFunctionAttributes(New);
   return New;

 }
 
 /// canRedefineFunction - checks if a function can be redefined. Currently,
 /// only extern inline functions can be redefined, and even then only in
 /// GNU89 mode.
 static bool canRedefineFunction(const FunctionDecl *FD,
                                 const LangOptions& LangOpts) {
   return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
-          !LangOpts.CPlusPlus &&
-          FD->isInlineSpecified() &&
-          FD->getStorageClass() == SC_Extern);
+          !LangOpts.CPlusPlus && FD->isInlineSpecified() &&
+          FD->getStorageClass() == StorageClass::Extern);
 }
 
 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
   const AttributedType *AT = T->getAs<AttributedType>();
   while (AT && !AT->isCallingConv())
     AT = AT->getModifiedType()->getAs<AttributedType>();
   return AT;
 }
bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
   std::tie(PrevDiag, OldLocation) =
       getNoteDiagForInvalidRedeclaration(Old, New);
 
   // Don't complain about this if we're in GNU89 mode and the old function
   // is an extern inline function.
   // Don't complain about specializations. They are not supposed to have
   // storage classes.
   if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
-      New->getStorageClass() == SC_Static &&
+      New->getStorageClass() == StorageClass::Static &&
       Old->hasExternalFormalLinkage() &&
       !New->getTemplateSpecializationInfo() &&
       !canRedefineFunction(Old, getLangOpts())) {
     if (getLangOpts().MicrosoftExt) {
       Diag(New->getLocation(), diag::ext_static_non_static) << New;
       Diag(OldLocation, PrevDiag);
     } else {
       Diag(New->getLocation(), diag::err_static_non_static) << New;
if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
           Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
                                   OldProto->getExtProtoInfo());
       New->setType(NewQType);
       New->setHasInheritedPrototype();
 
       // Synthesize parameters with the same types.
       SmallVector<ParmVarDecl*, 16> Params;
       for (const auto &ParamType : OldProto->param_types()) {
-        ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
-                                                 SourceLocation(), nullptr,
-                                                 ParamType, /*TInfo=*/nullptr,
-                                                 SC_None, nullptr);
+        ParmVarDecl *Param = ParmVarDecl::Create(
+            Context, New, SourceLocation(), SourceLocation(), nullptr,
+            ParamType, /*TInfo=*/nullptr, StorageClass::None, nullptr);
         Param->setScopeInfo(0, Params.size());
         Param->setImplicit();
         Params.push_back(Param);
       }
 
       New->setParams(Params);
     }
 
if (Old->isStaticDataMember() && !New->isOutOfLine()) {
     Diag(Old->getLocation(), diag::note_previous_declaration);
     New->setInvalidDecl();
   }
 
   mergeDeclAttributes(New, Old);
   // Warn if an already-declared variable is made a weak_import in a subsequent
   // declaration
   if (New->hasAttr<WeakImportAttr>() &&
-      Old->getStorageClass() == SC_None &&
+      Old->getStorageClass() == StorageClass::None &&
       !Old->hasAttr<WeakImportAttr>()) {
     Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
     notePreviousDefinition(Old, New->getLocation());
     // Remove weak_import attribute on new declaration.
     New->dropAttr<WeakImportAttr>();
   }
 
   if (New->hasAttr<InternalLinkageAttr>() &&
if (New->isInvalidDecl())
     return;
 
   diag::kind PrevDiag;
   SourceLocation OldLocation;
   std::tie(PrevDiag, OldLocation) =
       getNoteDiagForInvalidRedeclaration(Old, New);
 
   // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
-  if (New->getStorageClass() == SC_Static &&
-      !New->isStaticDataMember() &&
-      Old->hasExternalFormalLinkage()) {
+  if (New->getStorageClass() == StorageClass::Static &&
+      !New->isStaticDataMember() && Old->hasExternalFormalLinkage()) {
     if (getLangOpts().MicrosoftExt) {
       Diag(New->getLocation(), diag::ext_static_non_static)
           << New->getDeclName();
       Diag(OldLocation, PrevDiag);
     } else {
       Diag(New->getLocation(), diag::err_static_non_static)
           << New->getDeclName();
       Diag(OldLocation, PrevDiag);
       return New->setInvalidDecl();
     }
   }
   // C99 6.2.2p4:
   //   For an identifier declared with the storage-class specifier
   //   extern in a scope in which a prior declaration of that
   //   identifier is visible,23) if the prior declaration specifies
   //   internal or external linkage, the linkage of the identifier at
   //   the later declaration is the same as the linkage specified at
   //   the prior declaration. If no prior declaration is visible, or
   //   if the prior declaration specifies no linkage, then the
   //   identifier has external linkage.
   if (New->hasExternalStorage() && Old->hasLinkage())
     /* Okay */;
-  else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
+  else if (New->getCanonicalDecl()->getStorageClass() != StorageClass::Static &&
            !New->isStaticDataMember() &&
-           Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
+           Old->getCanonicalDecl()->getStorageClass() == StorageClass::Static) {
     Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
     Diag(OldLocation, PrevDiag);
     return New->setInvalidDecl();
   }
 
   // Check if extern is followed by non-extern and vice-versa.
   if (New->hasExternalStorage() &&
       !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {

 /// a VarDecl::StorageClass. Any error reporting is up to the caller:
 /// illegal input values are mapped to SC_None.
 static StorageClass
 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
   DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
   assert(StorageClassSpec != DeclSpec::SCS_typedef &&
          "Parser allowed 'typedef' as storage class VarDecl.");
   switch (StorageClassSpec) {
-  case DeclSpec::SCS_unspecified:    return SC_None;
+  case DeclSpec::SCS_unspecified:
+    return StorageClass::None;
   case DeclSpec::SCS_extern:
     if (DS.isExternInLinkageSpec())
-      return SC_None;
-    return SC_Extern;
-  case DeclSpec::SCS_static:         return SC_Static;
-  case DeclSpec::SCS_auto:           return SC_Auto;
-  case DeclSpec::SCS_register:       return SC_Register;
-  case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
+      return StorageClass::None;
+    return StorageClass::Extern;
+  case DeclSpec::SCS_static:
+    return StorageClass::Static;
+  case DeclSpec::SCS_auto:
+    return StorageClass::Auto;
+  case DeclSpec::SCS_register:
+    return StorageClass::Register;
+  case DeclSpec::SCS_private_extern:
+    return StorageClass::PrivateExtern;
     // Illegal SCSs map to None: error reporting is up to the caller.
   case DeclSpec::SCS_mutable:        // Fall through.
-  case DeclSpec::SCS_typedef:        return SC_None;
+  case DeclSpec::SCS_typedef:
+    return StorageClass::None;
   }
   llvm_unreachable("unknown storage class specifier");
 }
 
 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
   assert(Record->hasInClassInitializer());
 
   for (const auto *I : Record->decls()) {
Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
   } else {
     DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
     StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
     if (SCSpec == DeclSpec::SCS_mutable) {
       // mutable can only appear on non-static class members, so it's always
       // an error here
       Diag(Record->getLocation(), diag::err_mutable_nonmember);
       Invalid = true;
-      SC = SC_None;
+      SC = StorageClass::None;
     }
 
     assert(DS.getAttributes().empty() && "No attribute expected");
     Anon = VarDecl::Create(Context, Owner, DS.getBeginLoc(),
                            Record->getLocation(), /*IdentifierInfo=*/nullptr,
                            Context.getTypeDeclType(Record), TInfo, SC);
 
     // Default-initialize the implicit variable. This initialization will be
NamedDecl *Sema::ActOnVariableDeclarator(
   }
 
 
   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
 
   // dllimport globals without explicit storage class are treated as extern. We
   // have to change the storage class this early to get the right DeclContext.
-  if (SC == SC_None && !DC->isRecord() &&
+  if (SC == StorageClass::None && !DC->isRecord() &&
       hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) &&
       !hasParsedAttr(S, D, ParsedAttr::AT_DLLExport))
-    SC = SC_Extern;
+    SC = StorageClass::Extern;
 
   DeclContext *OriginalDC = DC;
-  bool IsLocalExternDecl = SC == SC_Extern &&
-                           adjustContextForLocalExternDecl(DC);
+  bool IsLocalExternDecl =
+      SC == StorageClass::Extern && adjustContextForLocalExternDecl(DC);
 
   if (SCSpec == DeclSpec::SCS_mutable) {
     // mutable can only appear on non-static class members, so it's always
     // an error here
     Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
     D.setInvalidType();
-    SC = SC_None;
+    SC = StorageClass::None;
   }
 
   if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
       !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
                               D.getDeclSpec().getStorageClassSpecLoc())) {
     // In C++11, the 'register' storage class specifier is deprecated.
     // Suppress the warning in system macros, it's used in macros in some
     // popular C system headers, such as in glibc's htonl() macro.
     Diag(D.getDeclSpec().getStorageClassSpecLoc(),
          getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
                                    : diag::warn_deprecated_register)
       << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
   }
 
   DiagnoseFunctionSpecifiers(D.getDeclSpec());
 
   if (!DC->isRecord() && S->getFnParent() == nullptr) {
     // C99 6.9p2: The storage-class specifiers auto and register shall not
     // appear in the declaration specifiers in an external declaration.
     // Global Register+Asm is a GNU extension we support.
-    if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
+    if (SC == StorageClass::Auto ||
+        (SC == StorageClass::Register && !D.getAsmLabel())) {
       Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
       D.setInvalidType();
     }
   }
 
   // If this variable has a variable-modified type and an initializer, try to
   // fold to a constant-sized type. This is otherwise invalid.
   if (D.hasInitializer() && R->isVariablyModifiedType())
if (NewVD->getType().hasNonTrivialToPrimitiveDestructCUnion() &&
       checkNonTrivialCUnion(NewVD->getType(), NewVD->getLocation(),
                             NTCUC_AutoVar, NTCUK_Destruct);
   } else {
     bool Invalid = false;
 
     if (DC->isRecord() && !CurContext->isRecord()) {
       // This is an out-of-line definition of a static data member.
       switch (SC) {
-      case SC_None:
+      case StorageClass::None:
         break;
-      case SC_Static:
+      case StorageClass::Static:
         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
              diag::err_static_out_of_line)
           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
         break;
-      case SC_Auto:
-      case SC_Register:
-      case SC_Extern:
+      case StorageClass::Auto:
+      case StorageClass::Register:
+      case StorageClass::Extern:
         // [dcl.stc] p2: The auto or register specifiers shall be applied only
         // to names of variables declared in a block or to function parameters.
         // [dcl.stc] p6: The extern specifier cannot be used in the declaration
         // of class members
 
         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
              diag::err_storage_class_for_static_member)
           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
         break;
-      case SC_PrivateExtern:
+      case StorageClass::PrivateExtern:
         llvm_unreachable("C storage class in c++!");
       }
     }
 
-    if (SC == SC_Static && CurContext->isRecord()) {
+    if (SC == StorageClass::Static && CurContext->isRecord()) {
       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
         // Walk up the enclosing DeclContexts to check for any that are
         // incompatible with static data members.
         const DeclContext *FunctionOrMethod = nullptr;
         const CXXRecordDecl *AnonStruct = nullptr;
         for (DeclContext *Ctxt = DC; Ctxt; Ctxt = Ctxt->getParent()) {
           if (Ctxt->isFunctionOrMethod()) {
             FunctionOrMethod = Ctxt;
NamedDecl *Sema::ActOnVariableDeclarator(
   //   An inline definition of a function with external linkage shall
   //   not contain a definition of a modifiable object with static or
   //   thread storage duration...
   // We only apply this when the function is required to be defined
   // elsewhere, i.e. when the function is not 'extern inline'.  Note
   // that a local variable with thread storage duration still has to
   // be marked 'static'.  Also note that it's possible to get these
   // semantics in C++ using __attribute__((gnu_inline)).
-  if (SC == SC_Static && S->getFnParent() != nullptr &&
+  if (SC == StorageClass::Static && S->getFnParent() != nullptr &&
       !NewVD->getType().isConstQualified()) {
     FunctionDecl *CurFD = getCurFunctionDecl();
     if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
       Diag(D.getDeclSpec().getStorageClassSpecLoc(),
            diag::warn_static_local_in_extern_inline);
       MaybeSuggestAddingStaticToDecl(CurFD);
     }
   }
if (EmitTLSUnsupportedError &&
       Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
            diag::err_thread_unsupported);
 
     if (EmitTLSUnsupportedError &&
         (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)))
       targetDiag(D.getIdentifierLoc(), diag::err_thread_unsupported);
     // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
     // storage [duration]."
-    if (SC == SC_None && S->getFnParent() != nullptr &&
+    if (SC == StorageClass::None && S->getFnParent() != nullptr &&
         (NewVD->hasAttr<CUDASharedAttr>() ||
          NewVD->hasAttr<CUDAConstantAttr>())) {
-      NewVD->setStorageClass(SC_Static);
+      NewVD->setStorageClass(StorageClass::Static);
     }
   }
 
   // Ensure that dllimport globals without explicit storage class are treated as
   // extern. The storage class is set above using parsed attributes. Now we can
   // check the VarDecl itself.
   assert(!NewVD->hasAttr<DLLImportAttr>() ||
          NewVD->getAttr<DLLImportAttr>()->isInherited() ||
-         NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
+         NewVD->isStaticDataMember() ||
+         NewVD->getStorageClass() != StorageClass::None);
 
   // In auto-retain/release, infer strong retension for variables of
   // retainable type.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
     NewVD->setInvalidDecl();
 
   // Handle GNU asm-label extension (encoded as an attribute).
   if (Expr *E = (Expr*)D.getAsmLabel()) {
     // The parser guarantees this is a string.
     StringLiteral *SE = cast<StringLiteral>(E);
     StringRef Label = SE->getString();
     if (S->getFnParent() != nullptr) {
       switch (SC) {
-      case SC_None:
-      case SC_Auto:
+      case StorageClass::None:
+      case StorageClass::Auto:
         Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
         break;
-      case SC_Register:
+      case StorageClass::Register:
         // Local Named register
         if (!Context.getTargetInfo().isValidGCCRegisterName(Label) &&
             DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl()))
           Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
         break;
-      case SC_Static:
-      case SC_Extern:
-      case SC_PrivateExtern:
+      case StorageClass::Static:
+      case StorageClass::Extern:
+      case StorageClass::PrivateExtern:
         break;
       }
-    } else if (SC == SC_Register) {
+    } else if (SC == StorageClass::Register) {
       // Global Named register
       if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {
         const auto &TI = Context.getTargetInfo();
         bool HasSizeMismatch;
 
         if (!TI.isValidGCCRegisterName(Label))
           Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
         else if (!TI.validateGlobalRegisterVariable(Label,
case DeclSpec::SCS_mutable:
     SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
                  diag::err_typecheck_sclass_func);
     D.getMutableDeclSpec().ClearStorageClassSpecs();
     D.setInvalidType();
     break;
   case DeclSpec::SCS_unspecified: break;
   case DeclSpec::SCS_extern:
     if (D.getDeclSpec().isExternInLinkageSpec())
-      return SC_None;
-    return SC_Extern;
+      return StorageClass::None;
+    return StorageClass::Extern;
   case DeclSpec::SCS_static: {
     if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
       // C99 6.7.1p5:
       //   The declaration of an identifier for a function that has
       //   block scope shall have no explicit storage-class specifier
       //   other than extern
       // See also (C++ [dcl.stc]p4).
       SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
                    diag::err_static_block_func);
       break;
     } else
-      return SC_Static;
+      return StorageClass::Static;
   }
-  case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
+  case DeclSpec::SCS_private_extern:
+    return StorageClass::PrivateExtern;
   }
 
   // No explicit storage class has already been returned
-  return SC_None;
+  return StorageClass::None;
 }
 
 static FunctionDecl *CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
                                            DeclContext *DC, QualType &R,
                                            TypeSourceInfo *TInfo,
                                            StorageClass SC,
                                            bool &IsVirtualOkay) {
   DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
if (getLangOpts().CPlusPlus) {
     if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
         D.isFunctionDefinition()) {
       // C++ [class.mfct]p2:
       //   A member function may be defined (8.4) in its class definition, in
       //   which case it is an inline member function (7.1.2)
       NewFD->setImplicitlyInline();
     }
 
-    if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
+    if (SC == StorageClass::Static && isa<CXXMethodDecl>(NewFD) &&
         !CurContext->isRecord()) {
       // C++ [class.static]p1:
       //   A data or function member of a class may be declared static
       //   in a class definition, in which case it is a static member of
       //   the class.
 
       // Complain about the 'static' specifier if it's on an out-of-line
       // member function definition.
if (isFunctionTemplateSpecialization && isFriend &&
                      Previous))
         NewFD->setInvalidDecl();
 
       // C++ [dcl.stc]p1:
       //   A storage-class-specifier shall not be specified in an explicit
       //   specialization (14.7.3)
       FunctionTemplateSpecializationInfo *Info =
           NewFD->getTemplateSpecializationInfo();
-      if (Info && SC != SC_None) {
+      if (Info && SC != StorageClass::None) {
         if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
           Diag(NewFD->getLocation(),
                diag::err_explicit_specialization_inconsistent_storage_class)
-            << SC
+              << static_cast<int>(SC)
               << FixItHint::CreateRemoval(
-                                      D.getDeclSpec().getStorageClassSpecLoc());
 
         else
           Diag(NewFD->getLocation(),
                diag::ext_explicit_specialization_storage_class)
             << FixItHint::CreateRemoval(
                                       D.getDeclSpec().getStorageClassSpecLoc());
       }
     } else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   }
 
   MarkUnusedFileScopedDecl(NewFD);
 
 
 
   if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) {
     // OpenCL v1.2 s6.8 static is invalid for kernel functions.
-    if ((getLangOpts().OpenCLVersion >= 120)
-        && (SC == SC_Static)) {
+    if ((getLangOpts().OpenCLVersion >= 120) && (SC == StorageClass::Static)) {
       Diag(D.getIdentifierLoc(), diag::err_static_kernel);
       D.setInvalidType();
     }
 
     // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
     if (!NewFD->getReturnType()->isVoidType()) {
       SourceRange RTRange = NewFD->getReturnTypeSourceRange();
       Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)

 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
   // C++11 [basic.start.main]p3:
   //   A program that [...] declares main to be inline, static or
   //   constexpr is ill-formed.
   // C11 6.7.4p4:  In a hosted environment, no function specifier(s) shall
   //   appear in a declaration of main.
   // static main is not an error under C99, but we should warn about it.
   // We accept _Noreturn main as an extension.
-  if (FD->getStorageClass() == SC_Static)
+  if (FD->getStorageClass() == StorageClass::Static)
     Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
          ? diag::err_static_main : diag::warn_static_main)
       << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
   if (FD->isInlineSpecified())
     Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
       << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
   if (DS.isNoreturnSpecified()) {
     SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
// This is true even in C++ for OpenCL.
       CheckForConstantInitializer(Init, DclT);
 
     // Otherwise, C++ does not restrict the initializer.
     } else if (getLangOpts().CPlusPlus) {
       // do nothing
 
     // C99 6.7.8p4: All the expressions in an initializer for an object that has
     // static storage duration shall be constant expressions or string literals.
-    } else if (VDecl->getStorageClass() == SC_Static) {
+    } else if (VDecl->getStorageClass() == StorageClass::Static) {
       CheckForConstantInitializer(Init, DclT);
 
     // C89 is stricter than C99 for aggregate initializers.
     // C89 6.5.7p3: All the expressions [...] in an initializer list
     // for an object that has aggregate or union type shall be
     // constant expressions.
     } else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
                isa<InitListExpr>(Init)) {
void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
   } else if (VDecl->isFileVarDecl()) {
     // In C, extern is typically used to avoid tentative definitions when
     // declaring variables in headers, but adding an intializer makes it a
     // definition. This is somewhat confusing, so GCC and Clang both warn on it.
     // In C++, extern is often used to give implictly static const variables
     // external linkage, so don't warn in that case. If selectany is present,
     // this might be header code intended for C and C++ inclusion, so apply the
     // C++ rules.
-    if (VDecl->getStorageClass() == SC_Extern &&
+    if (VDecl->getStorageClass() == StorageClass::Extern &&
         ((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) ||
          !Context.getBaseElementType(VDecl->getType()).isConstQualified()) &&
         !(getLangOpts().CPlusPlus && VDecl->isExternC()) &&
         !isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
       Diag(VDecl->getLocation(), diag::warn_extern_init);
 
     // In Microsoft C++ mode, a const variable defined in namespace scope has
     // external linkage by default if the variable is declared with
     // __declspec(dllexport).
     if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
         getLangOpts().CPlusPlus && VDecl->getType().isConstQualified() &&
         VDecl->hasAttr<DLLExportAttr>() && VDecl->getDefinition())
-      VDecl->setStorageClass(SC_Extern);
+      VDecl->setStorageClass(StorageClass::Extern);
 
     // C99 6.7.8p4. All file scoped initializers need to be constant.
     if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
       CheckForConstantInitializer(Init, DclT);
   }
 
   QualType InitType = Init->getType();
   if (!InitType.isNull() &&
if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
         return;
       }
     }
 
     // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
     // be initialized.
     if (!Var->isInvalidDecl() &&
         Var->getType().getAddressSpace() == LangAS::opencl_constant &&
-        Var->getStorageClass() != SC_Extern && !Var->getInit()) {
+        Var->getStorageClass() != StorageClass::Extern && !Var->getInit()) {
       Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
       Var->setInvalidDecl();
       return;
     }
 
     if (!Var->isInvalidDecl() && RealDecl->hasAttr<LoaderUninitializedAttr>()) {
-      if (Var->getStorageClass() == SC_Extern) {
+      if (Var->getStorageClass() == StorageClass::Extern) {
         Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
             << Var;
         Var->setInvalidDecl();
         return;
       }
       if (RequireCompleteType(Var->getLocation(), Var->getType(),
                               diag::err_typecheck_decl_incomplete_type)) {
         Var->setInvalidDecl();
case VarDecl::DeclarationOnly:
 
       // Make sure that the type is not abstract.
       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
           RequireNonAbstractType(Var->getLocation(), Type,
                                  diag::err_abstract_type_in_decl,
                                  AbstractVariableType))
         Var->setInvalidDecl();
       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
-          Var->getStorageClass() == SC_PrivateExtern) {
+          Var->getStorageClass() == StorageClass::PrivateExtern) {
         Diag(Var->getLocation(), diag::warn_private_extern);
         Diag(Var->getLocation(), diag::note_private_extern);
       }
 
       if (Context.getTargetInfo().allowDebugInfoForExternalVar() &&
           !Var->isInvalidDecl() && !getLangOpts().CPlusPlus)
         ExternalDeclarations.push_back(Var);
 
       return;
 
     case VarDecl::TentativeDefinition:
       // File scope. C99 6.9.2p2: A declaration of an identifier for an
       // object that has file scope without an initializer, and without a
       // storage-class specifier or with the storage-class specifier "static",
       // constitutes a tentative definition. Note: A tentative definition with
       // external linkage is valid (C99 6.2.2p5).
       if (!Var->isInvalidDecl()) {
         if (const IncompleteArrayType *ArrayT
                                     = Context.getAsIncompleteArrayType(Type)) {
           if (RequireCompleteSizedType(
                   Var->getLocation(), ArrayT->getElementType(),
                   diag::err_array_incomplete_or_sizeless_type))
             Var->setInvalidDecl();
-        } else if (Var->getStorageClass() == SC_Static) {
+        } else if (Var->getStorageClass() == StorageClass::Static) {
           // C99 6.9.2p3: If the declaration of an identifier for an object is
           // a tentative definition and has internal linkage (C99 6.2.2p3), the
           // declared type shall not be an incomplete type.
           // NOTE: code such as the following
           //     static struct s;
           //     struct s { int a; };
           // is accepted by gcc. Hence here we issue a warning instead of
           // an error and we do not invalidate the static declaration.
if (!VD) {
     return;
   }
 
   VD->setCXXForRangeDecl(true);
 
   // for-range-declaration cannot be given a storage class specifier.
   int Error = -1;
   switch (VD->getStorageClass()) {
-  case SC_None:
+  case StorageClass::None:
     break;
-  case SC_Extern:
+  case StorageClass::Extern:
     Error = 0;
     break;
-  case SC_Static:
+  case StorageClass::Static:
     Error = 1;
     break;
-  case SC_PrivateExtern:
+  case StorageClass::PrivateExtern:
     Error = 2;
     break;
-  case SC_Auto:
+  case StorageClass::Auto:
     Error = 3;
     break;
-  case SC_Register:
+  case StorageClass::Register:
     Error = 4;
     break;
   }
 
   // for-range-declaration cannot be given a storage class specifier con't.
   switch (VD->getTSCSpec()) {
   case TSCS_thread_local:
     Error = 6;

 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
 /// to introduce parameters into function prototype scope.
 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
   const DeclSpec &DS = D.getDeclSpec();
 
   // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
 
   // C++03 [dcl.stc]p2 also permits 'auto'.
-  StorageClass SC = SC_None;
+  StorageClass SC = StorageClass::None;
   if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
-    SC = SC_Register;
+    SC = StorageClass::Register;
     // In C++11, the 'register' storage class specifier is deprecated.
     // In C++17, it is not allowed, but we tolerate it as an extension.
     if (getLangOpts().CPlusPlus11) {
       Diag(DS.getStorageClassSpecLoc(),
            getLangOpts().CPlusPlus17 ? diag::ext_register_storage_class
                                      : diag::warn_deprecated_register)
         << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
     }
   } else if (getLangOpts().CPlusPlus &&
              DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
-    SC = SC_Auto;
+    SC = StorageClass::Auto;
   } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
     Diag(DS.getStorageClassSpecLoc(),
          diag::err_invalid_storage_class_in_func_decl);
     D.getMutableDeclSpec().ClearStorageClassSpecs();
   }
 
   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
     Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)

 /// Synthesizes a variable for a parameter arising from a
 /// typedef.
 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
                                               SourceLocation Loc,
                                               QualType T) {
   /* FIXME: setting StartLoc == Loc.
      Would it be worth to modify callers so as to provide proper source
      location for the unnamed parameters, embedding the parameter's type? */
-  ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
-                                T, Context.getTrivialTypeSourceInfo(T, Loc),
-                                           SC_None, nullptr);
+  ParmVarDecl *Param = ParmVarDecl::Create(
+      Context, DC, Loc, Loc, nullptr, T,
+      Context.getTrivialTypeSourceInfo(T, Loc), StorageClass::None, nullptr);
   Param->setImplicit();
   return Param;
 }
 
 void Sema::DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters) {
   // Don't diagnose unused-parameter errors in template instantiations; we
   // will already have done so in the template itself.
   if (inTemplateInstantiation())
if (SkipBody && !hasVisibleDefinition(Definition) &&
     SkipBody->Previous = const_cast<FunctionDecl*>(Definition);
     if (auto *TD = Definition->getDescribedFunctionTemplate())
       makeMergedDefinitionVisible(TD);
     makeMergedDefinitionVisible(const_cast<FunctionDecl*>(Definition));
     return;
   }
 
   if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
-      Definition->getStorageClass() == SC_Extern)
+      Definition->getStorageClass() == StorageClass::Extern)
     Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
         << FD << getLangOpts().CPlusPlus;
   else
     Diag(FD->getLocation(), diag::err_redefinition) << FD;
 
   Diag(Definition->getLocation(), diag::note_previous_definition);
   FD->setInvalidDecl();
 }
if (ShouldWarnAboutMissingPrototype(FD, PossiblePrototype)) {
                              getLangOpts()))
 
               return FD->getBeginLoc();
           }
           return FD->getTypeSpecStartLoc();
         };
         Diag(FD->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage)
             << /* function */ 1
-            << (FD->getStorageClass() == SC_None
+            << (FD->getStorageClass() == StorageClass::None
                     ? FixItHint::CreateInsertion(findBeginLoc(), "static ")
                     : FixItHint{});
       }
 
       // GNU warning -Wstrict-prototypes
       //   Warn if K&R function is defined without a previous declaration.
       //   This warning is issued only if the definition itself does not provide
       //   a prototype. Only K&R definitions do not provide a prototype.

clang/lib/Sema/SemaDeclAttr.cpp

if (TmpAttr.isAlignas()) {
     // C11 6.7.5/2:
     //   An alignment attribute shall not be specified in a declaration of
     //   a typedef, or a bit-field, or a function, or a parameter, or an
     //   object declared with the register storage-class specifier.
     int DiagKind = -1;
     if (isa<ParmVarDecl>(D)) {
       DiagKind = 0;
     } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
-      if (VD->getStorageClass() == SC_Register)
+      if (VD->getStorageClass() == StorageClass::Register)
         DiagKind = 1;
       if (VD->isExceptionVariable())
         DiagKind = 2;
     } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
       if (FD->isBitField())
         DiagKind = 3;
     } else if (!isa<TagDecl>(D)) {
       Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr

 
 static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   const auto *Fn = cast<FunctionDecl>(D);
   if (!Fn->isInlineSpecified()) {
     S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
     return;
   }
 
-  if (S.LangOpts.CPlusPlus && Fn->getStorageClass() != SC_Extern)
+  if (S.LangOpts.CPlusPlus && Fn->getStorageClass() != StorageClass::Extern)
     S.Diag(AL.getLoc(), diag::warn_gnu_inline_cplusplus_without_extern);
 
   D->addAttr(::new (S.Context) GNUInlineAttr(S.Context, AL));
 }
 
 static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (hasDeclarator(D)) return;
 
NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
   if (auto *FD = dyn_cast<FunctionDecl>(ND)) {
     FunctionDecl *NewFD;
     // FIXME: Missing call to CheckFunctionDeclaration().
     // FIXME: Mangling?
     // FIXME: Is the qualifier info correct?
     // FIXME: Is the DeclContext correct?
     NewFD = FunctionDecl::Create(
         FD->getASTContext(), FD->getDeclContext(), Loc, Loc,
-        DeclarationName(II), FD->getType(), FD->getTypeSourceInfo(), SC_None,
-        false /*isInlineSpecified*/, FD->hasPrototype(),
+        DeclarationName(II), FD->getType(), FD->getTypeSourceInfo(),
+        StorageClass::None, false /*isInlineSpecified*/, FD->hasPrototype(),
         ConstexprSpecKind::Unspecified, FD->getTrailingRequiresClause());
     NewD = NewFD;
 
     if (FD->getQualifier())
       NewFD->setQualifierInfo(FD->getQualifierLoc());
 
     // Fake up parameter variables; they are declared as if this were
     // a typedef.

clang/lib/Sema/SemaDeclCXX.cpp

static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class) {
   if (S.Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())
     S.MarkVTableUsed(Class->getLocation(), Class, true);
 
   for (Decl *Member : Class->decls()) {
     // Defined static variables that are members of an exported base
     // class must be marked export too.
     auto *VD = dyn_cast<VarDecl>(Member);
     if (VD && Member->getAttr<DLLExportAttr>() &&
-        VD->getStorageClass() == SC_Static &&
+        VD->getStorageClass() == StorageClass::Static &&
         TSK == TSK_ImplicitInstantiation)
       S.MarkVariableReferenced(VD->getLocation(), VD);
 
     auto *MD = dyn_cast<CXXMethodDecl>(Member);
     if (!MD)
       continue;
 
     if (Member->getAttr<DLLExportAttr>()) {
void Sema::CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record) {
   // primary comparison functions (==, <=>).
   llvm::SmallVector<FunctionDecl*, 5> DefaultedSecondaryComparisons;
 
   // Perform checks that can't be done until we know all the properties of a
   // member function (whether it's defaulted, deleted, virtual, overriding,
   // ...).
   auto CheckCompletedMemberFunction = [&](CXXMethodDecl *MD) {
     // A static function cannot override anything.
-    if (MD->getStorageClass() == SC_Static) {
+    if (MD->getStorageClass() == StorageClass::Static) {
       if (ReportOverrides(*this, diag::err_static_overrides_virtual, MD,
                           [](const CXXMethodDecl *) { return true; }))
         return;
     }
 
     // A deleted function cannot override a non-deleted function and vice
     // versa.
     if (ReportOverrides(*this,
StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
     {
       SmallString<8> Str;
       llvm::raw_svector_ostream OS(Str);
       OS << "i" << ArrayDepth;
       IterationVarName = &S.Context.Idents.get(OS.str());
     }
     VarDecl *IterationVar = VarDecl::Create(
         S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
-        S.Context.getTrivialTypeSourceInfo(SizeType, Loc), SC_None);
+        S.Context.getTrivialTypeSourceInfo(SizeType, Loc), StorageClass::None);
     llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
     IterationVar->setInit(
         IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
     Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
 
     auto IterRef = [&] {
       ExprResult Ref = S.BuildDeclarationNameExpr(
           CXXScopeSpec(), DeclarationNameInfo(IterationVarName, Loc),
case DefaultedComparisonKind::ThreeWay: {
       //     return cmp;
       QualType R = FD->getReturnType();
       Op = buildStaticCastToR(Op.get());
       if (Op.isInvalid())
         return StmtError();
 
       // R cmp = ...;
       IdentifierInfo *Name = &S.Context.Idents.get("cmp");
-      VarDecl *VD =
-          VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
-                          S.Context.getTrivialTypeSourceInfo(R, Loc), SC_None);
+      VarDecl *VD = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
+                                    S.Context.getTrivialTypeSourceInfo(R, Loc),
+                                    StorageClass::None);
       S.AddInitializerToDecl(VD, Op.get(), /*DirectInit=*/false);
       Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
 
       // cmp != 0
       ExprResult VDRef = getDecl(VD);
       if (VDRef.isInvalid())
         return StmtError();
       llvm::APInt ZeroVal(S.Context.getIntWidth(S.Context.IntTy), 0);
QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
   //   volatile, or const volatile (9.3.2).
   if (isVirtual) {
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
         << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
         << SourceRange(D.getIdentifierLoc());
     D.setInvalidType();
   }
-  if (SC == SC_Static) {
+  if (SC == StorageClass::Static) {
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
         << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
         << SourceRange(D.getIdentifierLoc());
     D.setInvalidType();
-    SC = SC_None;
+    SC = StorageClass::None;
   }
 
   if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
     diagnoseIgnoredQualifiers(
         diag::err_constructor_return_type, TypeQuals, SourceLocation(),
         D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
         D.getDeclSpec().getRestrictSpecLoc(),
         D.getDeclSpec().getAtomicSpecLoc());
QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
   // C++ [class.dtor]p2:
   //   A destructor is used to destroy objects of its class type. A
   //   destructor takes no parameters, and no return type can be
   //   specified for it (not even void). The address of a destructor
   //   shall not be taken. A destructor shall not be static. A
   //   destructor can be invoked for a const, volatile or const
   //   volatile object. A destructor shall not be declared const,
   //   volatile or const volatile (9.3.2).
-  if (SC == SC_Static) {
+  if (SC == StorageClass::Static) {
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
         << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
         << SourceRange(D.getIdentifierLoc())
         << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
 
-    SC = SC_None;
+    SC = StorageClass::None;
   }
   if (!D.isInvalidType()) {
     // Destructors don't have return types, but the parser will
     // happily parse something like:
     //
     //   class X {
     //     float ~X();
     //   };

 /// false. Either way, the type @p R will be updated to reflect a
 /// well-formed type for the conversion operator.
 void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
                                      StorageClass& SC) {
   // C++ [class.conv.fct]p1:
   //   Neither parameter types nor return type can be specified. The
   //   type of a conversion function (8.3.5) is "function taking no
   //   parameter returning conversion-type-id."
-  if (SC == SC_Static) {
+  if (SC == StorageClass::Static) {
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
         << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
         << D.getName().getSourceRange();
     D.setInvalidType();
-    SC = SC_None;
+    SC = StorageClass::None;
   }
 
   TypeSourceInfo *ConvTSI = nullptr;
   QualType ConvType =
       GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
 
   const DeclSpec &DS = D.getDeclSpec();
   if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
       DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
       DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
     BadSpecifierDiagnoser Diagnoser(
         *this, D.getIdentifierLoc(),
         diag::err_deduction_guide_invalid_specifier);
 
     Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
     DS.ClearStorageClassSpecs();
-    SC = SC_None;
+    SC = StorageClass::None;
 
     // 'explicit' is permitted.
     Diagnoser.check(DS.getInlineSpecLoc(), "inline");
     Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
     Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
     DS.ClearConstexprSpec();
 
     Diagnoser.check(DS.getConstSpecLoc(), "const");
Sema::findInheritingConstructor(SourceLocation Loc,
 
   // Build the parameter declarations.
   SmallVector<ParmVarDecl *, 16> ParamDecls;
   for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
     TypeSourceInfo *TInfo =
         Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
     ParmVarDecl *PD = ParmVarDecl::Create(
         Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
-        FPT->getParamType(I), TInfo, SC_None, /*DefArg=*/nullptr);
+        FPT->getParamType(I), TInfo, StorageClass::None, /*DefArg=*/nullptr);
     PD->setScopeInfo(0, I);
     PD->setImplicit();
     // Ensure attributes are propagated onto parameters (this matters for
     // format, pass_object_size, ...).
     mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
     ParamDecls.push_back(PD);
     ProtoLoc.setParam(I, PD);
   }
buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
   // Create the iteration variable.
   IdentifierInfo *IterationVarName = nullptr;
   {
     SmallString<8> Str;
     llvm::raw_svector_ostream OS(Str);
     OS << "__i" << Depth;
     IterationVarName = &S.Context.Idents.get(OS.str());
   }
-  VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
-                                          IterationVarName, SizeType,
-                            S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
-                                          SC_None);
+  VarDecl *IterationVar = VarDecl::Create(
+      S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
+      S.Context.getTrivialTypeSourceInfo(SizeType, Loc), StorageClass::None);
 
   // Initialize the iteration variable to zero.
   llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
   IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
 
   // Creates a reference to the iteration variable.
   RefBuilder IterationVarRef(IterationVar, SizeType);
   LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
 
   //   An implicitly-declared copy assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
   CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-      /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
+      /*TInfo=*/nullptr, /*StorageClass=*/StorageClass::None,
       /*isInline=*/true,
       Constexpr ? ConstexprSpecKind::Constexpr : ConstexprSpecKind::Unspecified,
       SourceLocation());
   CopyAssignment->setAccess(AS_public);
   CopyAssignment->setDefaulted();
   CopyAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
                                             CopyAssignment,
                                             /* ConstRHS */ Const,
                                             /* Diagnose */ false);
   }
 
   setupImplicitSpecialMemberType(CopyAssignment, RetType, ArgType);
 
   // Add the parameter to the operator.
-  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
-                                               ClassLoc, ClassLoc,
-                                               /*Id=*/nullptr, ArgType,
-                                               /*TInfo=*/nullptr, SC_None,
-                                               nullptr);
+  ParmVarDecl *FromParam =
+      ParmVarDecl::Create(Context, CopyAssignment, ClassLoc, ClassLoc,
+                          /*TInfo=*/nullptr, StorageClass::None, nullptr);
   CopyAssignment->setParams(FromParam);
 
   CopyAssignment->setTrivial(
     ClassDecl->needsOverloadResolutionForCopyAssignment()
       ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
       : ClassDecl->hasTrivialCopyAssignment());
 
   // Note that we have added this copy-assignment operator.
CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
 
   //   An implicitly-declared move assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
   CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-      /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
+      /*TInfo=*/nullptr, /*StorageClass=*/StorageClass::None,
       /*isInline=*/true,
       Constexpr ? ConstexprSpecKind::Constexpr : ConstexprSpecKind::Unspecified,
       SourceLocation());
   MoveAssignment->setAccess(AS_public);
   MoveAssignment->setDefaulted();
   MoveAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
                                             MoveAssignment,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);
   }
 
   // Build an exception specification pointing back at this member.
   FunctionProtoType::ExtProtoInfo EPI =
       getImplicitMethodEPI(*this, MoveAssignment);
   MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
 
   // Add the parameter to the operator.
-  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
-                                               ClassLoc, ClassLoc,
-                                               /*Id=*/nullptr, ArgType,
-                                               /*TInfo=*/nullptr, SC_None,
-                                               nullptr);
+  ParmVarDecl *FromParam =
+      ParmVarDecl::Create(Context, MoveAssignment, ClassLoc, ClassLoc,
+                          /*TInfo=*/nullptr, StorageClass::None, nullptr);
   MoveAssignment->setParams(FromParam);
 
   MoveAssignment->setTrivial(
     ClassDecl->needsOverloadResolutionForMoveAssignment()
       ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
       : ClassDecl->hasTrivialMoveAssignment());
 
   // Note that we have added this copy-assignment operator.
inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
                                             CopyConstructor,
                                             /* ConstRHS */ Const,
                                             /* Diagnose */ false);
   }
 
   setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
 
   // Add the parameter to the constructor.
-  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
-                                               ClassLoc, ClassLoc,
-                                               /*IdentifierInfo=*/nullptr,
-                                               ArgType, /*TInfo=*/nullptr,
-                                               SC_None, nullptr);
+  ParmVarDecl *FromParam =
+      ParmVarDecl::Create(Context, CopyConstructor, ClassLoc, ClassLoc,
+                          /*IdentifierInfo=*/nullptr, ArgType,
+                          /*TInfo=*/nullptr, StorageClass::None, nullptr);
   CopyConstructor->setParams(FromParam);
 
   CopyConstructor->setTrivial(
       ClassDecl->needsOverloadResolutionForCopyConstructor()
           ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
           : ClassDecl->hasTrivialCopyConstructor());
 
   CopyConstructor->setTrivialForCall(
inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
                                             MoveConstructor,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);
   }
 
   setupImplicitSpecialMemberType(MoveConstructor, Context.VoidTy, ArgType);
 
   // Add the parameter to the constructor.
-  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
-                                               ClassLoc, ClassLoc,
-                                               /*IdentifierInfo=*/nullptr,
-                                               ArgType, /*TInfo=*/nullptr,
-                                               SC_None, nullptr);
+  ParmVarDecl *FromParam =
+      ParmVarDecl::Create(Context, MoveConstructor, ClassLoc, ClassLoc,
+                          /*IdentifierInfo=*/nullptr, ArgType,
+                          /*TInfo=*/nullptr, StorageClass::None, nullptr);
   MoveConstructor->setParams(FromParam);
 
   MoveConstructor->setTrivial(
       ClassDecl->needsOverloadResolutionForMoveConstructor()
           ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
           : ClassDecl->hasTrivialMoveConstructor());
 
   MoveConstructor->setTrivialForCall(
CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
   const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
   if (isa<NamespaceDecl>(DC)) {
     return SemaRef.Diag(FnDecl->getLocation(),
                         diag::err_operator_new_delete_declared_in_namespace)
       << FnDecl->getDeclName();
   }
 
   if (isa<TranslationUnitDecl>(DC) &&
-      FnDecl->getStorageClass() == SC_Static) {
+      FnDecl->getStorageClass() == StorageClass::Static) {
     return SemaRef.Diag(FnDecl->getLocation(),
                         diag::err_operator_new_delete_declared_static)
       << FnDecl->getDeclName();
   }
 
   return false;
 }
 
if (!Invalid && getLangOpts().ObjC) {
     } else if (T->isObjCObjectPointerType()) {
       // FIXME: should this be a test for macosx-fragile specifically?
       if (getLangOpts().ObjCRuntime.isFragile())
         Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
     }
   }
 
   VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
-                                    ExDeclType, TInfo, SC_None);
+                                    ExDeclType, TInfo, StorageClass::None);
   ExDecl->setExceptionVariable(true);
 
   // In ARC, infer 'retaining' for variables of retainable type.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
     Invalid = true;
 
   if (!Invalid && !ExDeclType->isDependentType()) {
     if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
   // If the calling conventions match, everything is fine
   if (NewCC == OldCC)
     return false;
 
   // If the calling conventions mismatch because the new function is static,
   // suppress the calling convention mismatch error; the error about static
   // function override (err_static_overrides_virtual from
   // Sema::CheckFunctionDeclaration) is more clear.
-  if (New->getStorageClass() == SC_Static)
+  if (New->getStorageClass() == StorageClass::Static)
     return false;
 
   Diag(New->getLocation(),
        diag::err_conflicting_overriding_cc_attributes)
     << New->getDeclName() << New->getType() << Old->getType();
   Diag(Old->getLocation(), diag::note_overridden_virtual_function);
   return true;
 }

clang/lib/Sema/SemaDeclObjC.cpp

if (R.isSingleResult()) {
              diag::note_previous_declaration);
       }
     }
 
     SourceLocation StartLoc = DI
       ? DI->getTypeLoc().getBeginLoc()
       : ArgInfo[i].NameLoc;
 
-    ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
-                                        ArgInfo[i].NameLoc, ArgInfo[i].Name,
-                                        ArgType, DI, SC_None);
+    ParmVarDecl *Param =
+        CheckParameter(ObjCMethod, StartLoc, ArgInfo[i].NameLoc,
+                       ArgInfo[i].Name, ArgType, DI, StorageClass::None);
 
     Param->setObjCMethodScopeInfo(i);
 
     Param->setObjCDeclQualifier(
       CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
 
     // Apply the attributes to the parameter.
     ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
   } else if (!T->isObjCObjectPointerType()) {
     Invalid = true;
     Diag(IdLoc, diag::err_catch_param_not_objc_type);
   } else if (!T->castAs<ObjCObjectPointerType>()->getInterfaceType()) {
     Invalid = true;
     Diag(IdLoc, diag::err_catch_param_not_objc_type);
   }
 
-  VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
-                                 T, TInfo, SC_None);
+  VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id, T,
+                                 TInfo, StorageClass::None);
   New->setExceptionVariable(true);
 
   // In ARC, infer 'retaining' for variables of retainable type.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
     Invalid = true;
 
   if (Invalid)
     New->setInvalidDecl();

clang/lib/Sema/SemaExpr.cpp

void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
   Diag(Decl->getLocation(), diag::note_availability_specified_here)
     << Decl << 1;
 }
 
 /// Determine whether a FunctionDecl was ever declared with an
 /// explicit storage class.
 static bool hasAnyExplicitStorageClass(const FunctionDecl *D) {
   for (auto I : D->redecls()) {
-    if (I->getStorageClass() != SC_None)
+    if (I->getStorageClass() != StorageClass::None)
       return true;
   }
   return false;
 }
 
 /// Check whether we're in an extern inline function and referring to a
 /// variable or function with internal linkage (C11 6.7.4p3).
 ///
if (!IsDeclTyDependent) {
       }
     }
 
     // Iterator declaration.
     assert(D.DeclIdent && "Identifier expected.");
     // Always try to create iterator declarator to avoid extra error messages
     // about unknown declarations use.
     auto *VD = VarDecl::Create(Context, CurContext, StartLoc, D.DeclIdentLoc,
-                               D.DeclIdent, DeclTy, TInfo, SC_None);
+                               D.DeclIdent, DeclTy, TInfo, StorageClass::None);
     VD->setImplicit();
     if (S) {
       // Check for conflicting previous declaration.
       DeclarationNameInfo NameInfo(VD->getDeclName(), D.DeclIdentLoc);
       LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                             ForVisibleRedeclaration);
       Previous.suppressDiagnostics();
       LookupName(Previous, S);
for (OMPIteratorExpr::IteratorDefinition &D : ID) {
         continue;
       }
 
       // Build counter update.
       // Build counter.
       auto *CounterVD =
           VarDecl::Create(Context, CurContext, D.IteratorDecl->getBeginLoc(),
                           D.IteratorDecl->getBeginLoc(), nullptr,
-                          Res.get()->getType(), nullptr, SC_None);
+                          Res.get()->getType(), nullptr, StorageClass::None);
       CounterVD->setImplicit();
       ExprResult RefRes =
           BuildDeclRefExpr(CounterVD, CounterVD->getType(), VK_LValue,
                            D.IteratorDecl->getBeginLoc());
       // Build counter update.
       // I = Begini + counter * Stepi;
       ExprResult UpdateRes;
       if (D.Range.Step) {
static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
   if (!NeedsNewDecl)
     return nullptr;
 
   FunctionProtoType::ExtProtoInfo EPI;
   EPI.Variadic = FT->isVariadic();
   QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
                                                 OverloadParams, EPI);
   DeclContext *Parent = FDecl->getParent();
-  FunctionDecl *OverloadDecl = FunctionDecl::Create(Context, Parent,
-                                                    FDecl->getLocation(),
-                                                    FDecl->getLocation(),
-                                                    FDecl->getIdentifier(),
-                                                    OverloadTy,
-                                                    /*TInfo=*/nullptr,
-                                                    SC_Extern, false,
-                                                    /*hasPrototype=*/true);
+  FunctionDecl *OverloadDecl = FunctionDecl::Create(
+      Context, Parent, FDecl->getLocation(), FDecl->getLocation(),
+      FDecl->getIdentifier(), OverloadTy,
+      /*TInfo=*/nullptr, StorageClass::Extern, false,
   SmallVector<ParmVarDecl*, 16> Params;
   FT = cast<FunctionProtoType>(OverloadTy);
   for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
     QualType ParamType = FT->getParamType(i);
     ParmVarDecl *Parm =
         ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
-                                SourceLocation(), nullptr, ParamType,
-                                /*TInfo=*/nullptr, SC_None, nullptr);
+                            /*TInfo=*/nullptr, StorageClass::None, nullptr);
     Parm->setScopeInfo(0, i);
     Params.push_back(Parm);
   }
   OverloadDecl->setParams(Params);
   Sema->mergeDeclAttributes(OverloadDecl, FDecl);
   return OverloadDecl;
 }
 
if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
     // The operand cannot be an element of a matrix.
     AddressOfError = AO_Matrix_Element;
   } else if (dcl) { // C99 6.5.3.2p1
     // We have an lvalue with a decl. Make sure the decl is not declared
     // with the register storage-class specifier.
     if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
       // in C++ it is not error to take address of a register
       // variable (c++03 7.1.1P3)
-      if (vd->getStorageClass() == SC_Register &&
+      if (vd->getStorageClass() == StorageClass::Register &&
           !getLangOpts().CPlusPlus) {
         AddressOfError = AO_Register_Variable;
       }
     } else if (isa<MSPropertyDecl>(dcl)) {
       AddressOfError = AO_Property_Expansion;
     } else if (isa<FunctionTemplateDecl>(dcl)) {
       return Context.OverloadTy;
     } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
       const FunctionType *FnType = FDT->castAs<FunctionType>();
       const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
       DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
       if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
         SourceLocation Loc = FD->getLocation();
         FunctionDecl *NewFD = FunctionDecl::Create(
             S.Context, FD->getDeclContext(), Loc, Loc,
             FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
-            SC_None, false /*isInlineSpecified*/, FD->hasPrototype(),
+            StorageClass::None, false /*isInlineSpecified*/, FD->hasPrototype(),
             /*ConstexprKind*/ ConstexprSpecKind::Unspecified);
 
         if (FD->getQualifier())
           NewFD->setQualifierInfo(FD->getQualifierLoc());
 
         SmallVector<ParmVarDecl*, 16> Params;
         for (const auto &AI : FT->param_types()) {
           ParmVarDecl *Param =

clang/lib/Sema/SemaExprCXX.cpp

void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
   } else {
     EPI.ExceptionSpec =
         getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
   }
 
   auto CreateAllocationFunctionDecl = [&](Attr *ExtraAttr) {
     QualType FnType = Context.getFunctionType(Return, Params, EPI);
     FunctionDecl *Alloc = FunctionDecl::Create(
-        Context, GlobalCtx, SourceLocation(), SourceLocation(), Name,
-        FnType, /*TInfo=*/nullptr, SC_None, false, true);
+        Context, GlobalCtx, SourceLocation(), SourceLocation(), Name, FnType,
+        /*TInfo=*/nullptr, StorageClass::None, false, true);
     Alloc->setImplicit();
     // Global allocation functions should always be visible.
     Alloc->setVisibleDespiteOwningModule();
 
     Alloc->addAttr(VisibilityAttr::CreateImplicit(
         Context, LangOpts.GlobalAllocationFunctionVisibilityHidden
                      ? VisibilityAttr::Hidden
                      : VisibilityAttr::Default));
 
     llvm::SmallVector<ParmVarDecl *, 3> ParamDecls;
     for (QualType T : Params) {
       ParamDecls.push_back(ParmVarDecl::Create(
           Context, Alloc, SourceLocation(), SourceLocation(), nullptr, T,
-          /*TInfo=*/nullptr, SC_None, nullptr));
+          /*TInfo=*/nullptr, StorageClass::None, nullptr));
       ParamDecls.back()->setImplicit();
     }
     Alloc->setParams(ParamDecls);
     if (ExtraAttr)
       Alloc->addAttr(ExtraAttr);
     AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(Alloc);
     Context.getTranslationUnitDecl()->addDecl(Alloc);
     IdResolver.tryAddTopLevelDecl(Alloc, Name);

clang/lib/Sema/SemaExprObjC.cpp

Method =
         ObjCMethodDecl::Create(CX, SourceLocation(), SourceLocation(), Sel,
                                S.NSNumberPointer, ReturnTInfo, S.NSNumberDecl,
                                /*isInstance=*/false, /*isVariadic=*/false,
                                /*isPropertyAccessor=*/false,
                                /*isSynthesizedAccessorStub=*/false,
                                /*isImplicitlyDeclared=*/true,
                                /*isDefined=*/false, ObjCMethodDecl::Required,
                                /*HasRelatedResultType=*/false);
-    ParmVarDecl *value = ParmVarDecl::Create(S.Context, Method,
-                                             SourceLocation(), SourceLocation(),
-                                             &CX.Idents.get("value"),
-                                             NumberType, /*TInfo=*/nullptr,
-                                             SC_None, nullptr);
+    ParmVarDecl *value = ParmVarDecl::Create(
+        S.Context, Method, SourceLocation(), SourceLocation(),
+        &CX.Idents.get("value"), NumberType, /*TInfo=*/nullptr,
+        StorageClass::None, nullptr);
     Method->setMethodParams(S.Context, value, None);
   }
 
   if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method))
     return nullptr;
 
   // Note: if the parameter type is out-of-line, we'll catch it later in the
   // implicit conversion.
if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) {
               NSStringPointer, ReturnTInfo, NSStringDecl,
               /*isInstance=*/false, /*isVariadic=*/false,
               /*isPropertyAccessor=*/false,
               /*isSynthesizedAccessorStub=*/false,
               /*isImplicitlyDeclared=*/true,
               /*isDefined=*/false, ObjCMethodDecl::Required,
               /*HasRelatedResultType=*/false);
           QualType ConstCharType = Context.CharTy.withConst();
-          ParmVarDecl *value =
-            ParmVarDecl::Create(Context, M,
-                                SourceLocation(), SourceLocation(),
-                                &Context.Idents.get("value"),
-                                Context.getPointerType(ConstCharType),
-                                /*TInfo=*/nullptr,
-                                SC_None, nullptr);
+          ParmVarDecl *value = ParmVarDecl::Create(
+              Context, M, SourceLocation(), SourceLocation(),
+              /*TInfo=*/nullptr, StorageClass::None, nullptr);
           M->setMethodParams(Context, value, None);
           BoxingMethod = M;
         }
 
         if (!validateBoxingMethod(*this, Loc, NSStringDecl,
                                   stringWithUTF8String, BoxingMethod))
            return ExprError();
 
if (!ValueWithBytesObjCTypeMethod) {
             /*isPropertyAccessor=*/false,
             /*isSynthesizedAccessorStub=*/false,
             /*isImplicitlyDeclared=*/true,
             /*isDefined=*/false, ObjCMethodDecl::Required,
             /*HasRelatedResultType=*/false);
 
         SmallVector<ParmVarDecl *, 2> Params;
 
-        ParmVarDecl *bytes =
-        ParmVarDecl::Create(Context, M,
-                            SourceLocation(), SourceLocation(),
-                            &Context.Idents.get("bytes"),
-                            Context.VoidPtrTy.withConst(),
-                            /*TInfo=*/nullptr,
-                            SC_None, nullptr);
+        ParmVarDecl *bytes = ParmVarDecl::Create(
+            Context, M, SourceLocation(), SourceLocation(),
+            &Context.Idents.get("bytes"), Context.VoidPtrTy.withConst(),
+            /*TInfo=*/nullptr, StorageClass::None, nullptr);
         Params.push_back(bytes);
 
         QualType ConstCharType = Context.CharTy.withConst();
-        ParmVarDecl *type =
-        ParmVarDecl::Create(Context, M,
-                            SourceLocation(), SourceLocation(),
-                            &Context.Idents.get("type"),
-                            Context.getPointerType(ConstCharType),
-                            /*TInfo=*/nullptr,
-                            SC_None, nullptr);
+        ParmVarDecl *type = ParmVarDecl::Create(
+            Context, M, SourceLocation(), SourceLocation(),
+            &Context.Idents.get("type"), Context.getPointerType(ConstCharType),
+            /*TInfo=*/nullptr, StorageClass::None, nullptr);
         Params.push_back(type);
 
         M->setMethodParams(Context, Params, None);
         BoxingMethod = M;
       }
 
       if (!validateBoxingMethod(*this, Loc, NSValueDecl,
                                 ValueWithBytesObjCType, BoxingMethod))
if (!Method && getLangOpts().DebuggerObjCLiteral) {
       Method = ObjCMethodDecl::Create(
           Context, SourceLocation(), SourceLocation(), Sel, IdT, ReturnTInfo,
           Context.getTranslationUnitDecl(), false /*Instance*/,
           false /*isVariadic*/,
           /*isPropertyAccessor=*/false, /*isSynthesizedAccessorStub=*/false,
           /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
           ObjCMethodDecl::Required, false);
       SmallVector<ParmVarDecl *, 2> Params;
-      ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
-                                                 SourceLocation(),
-                                                 SourceLocation(),
-                                                 &Context.Idents.get("objects"),
-                                                 Context.getPointerType(IdT),
-                                                 /*TInfo=*/nullptr,
-                                                 SC_None, nullptr);
+      ParmVarDecl *objects = ParmVarDecl::Create(
+          Context, Method, SourceLocation(), SourceLocation(),
+          &Context.Idents.get("objects"), Context.getPointerType(IdT),
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       Params.push_back(objects);
-      ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
-                                             SourceLocation(),
-                                             SourceLocation(),
-                                             &Context.Idents.get("cnt"),
-                                             Context.UnsignedLongTy,
-                                             /*TInfo=*/nullptr, SC_None,
-                                             nullptr);
+      ParmVarDecl *cnt = ParmVarDecl::Create(
+          Context, Method, SourceLocation(), SourceLocation(),
+          &Context.Idents.get("cnt"), Context.UnsignedLongTy,
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       Params.push_back(cnt);
       Method->setMethodParams(Context, Params, None);
     }
 
     if (!validateBoxingMethod(*this, Loc, NSArrayDecl, Sel, Method))
       return ExprError();
 
     // Dig out the type that all elements should be converted to.
if (!Method && getLangOpts().DebuggerObjCLiteral) {
           Context, SourceLocation(), SourceLocation(), Sel, IdT,
           nullptr /*TypeSourceInfo */, Context.getTranslationUnitDecl(),
           false /*Instance*/, false /*isVariadic*/,
           /*isPropertyAccessor=*/false,
           /*isSynthesizedAccessorStub=*/false,
           /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
           ObjCMethodDecl::Required, false);
       SmallVector<ParmVarDecl *, 3> Params;
-      ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
-                                                 SourceLocation(),
-                                                 SourceLocation(),
-                                                 &Context.Idents.get("objects"),
-                                                 Context.getPointerType(IdT),
-                                                 /*TInfo=*/nullptr, SC_None,
-                                                 nullptr);
+      ParmVarDecl *objects = ParmVarDecl::Create(
+          Context, Method, SourceLocation(), SourceLocation(),
+          &Context.Idents.get("objects"), Context.getPointerType(IdT),
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       Params.push_back(objects);
-      ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
-                                              SourceLocation(),
-                                              SourceLocation(),
-                                              &Context.Idents.get("keys"),
-                                              Context.getPointerType(IdT),
-                                              /*TInfo=*/nullptr, SC_None,
-                                              nullptr);
+      ParmVarDecl *keys = ParmVarDecl::Create(
+          Context, Method, SourceLocation(), SourceLocation(),
+          &Context.Idents.get("keys"), Context.getPointerType(IdT),
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       Params.push_back(keys);
-      ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
-                                             SourceLocation(),
-                                             SourceLocation(),
-                                             &Context.Idents.get("cnt"),
-                                             Context.UnsignedLongTy,
-                                             /*TInfo=*/nullptr, SC_None,
-                                             nullptr);
+      ParmVarDecl *cnt = ParmVarDecl::Create(
+          Context, Method, SourceLocation(), SourceLocation(),
+          &Context.Idents.get("cnt"), Context.UnsignedLongTy,
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       Params.push_back(cnt);
       Method->setMethodParams(Context, Params, None);
     }
 
     if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
                               Method))
        return ExprError();
 

clang/lib/Sema/SemaLambda.cpp

CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
     = IntroducerRange.getBegin().getRawEncoding();
   MethodNameLoc.CXXOperatorName.EndOpNameLoc
     = IntroducerRange.getEnd().getRawEncoding();
   CXXMethodDecl *Method = CXXMethodDecl::Create(
       Context, Class, EndLoc,
       DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
                           MethodNameLoc),
-      MethodType, MethodTypeInfo, SC_None,
+      MethodType, MethodTypeInfo, StorageClass::None,
       /*isInline=*/true, ConstexprKind, EndLoc, TrailingRequiresClause);
   Method->setAccess(AS_public);
   if (!TemplateParams)
     Class->addDecl(Method);
 
   // Temporarily set the lexical declaration context to the current
   // context, so that the Scope stack matches the lexical nesting.
   Method->setLexicalDeclContext(CurContext);
VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
   TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType, Loc);
   if (auto PETL = TSI->getTypeLoc().getAs<PackExpansionTypeLoc>())
     PETL.setEllipsisLoc(EllipsisLoc);
 
   // Create a dummy variable representing the init-capture. This is not actually
   // used as a variable, and only exists as a way to name and refer to the
   // init-capture.
   // FIXME: Pass in separate source locations for '&' and identifier.
-  VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,
-                                   Loc, Id, InitCaptureType, TSI, SC_Auto);
+  VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc, Loc, Id,
+                                   InitCaptureType, TSI, StorageClass::Auto);
   NewVD->setInitCapture(true);
   NewVD->setReferenced(true);
   // FIXME: Pass in a VarDecl::InitializationStyle.
   NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));
   NewVD->markUsed(Context);
   NewVD->setInit(Init);
   if (NewVD->isParameterPack())
     getCurLambda()->LocalPacks.push_back(NewVD);
static void addFunctionPointerConversion(Sema &S, SourceRange IntroducerRange,
   // This would avoid the 'const' qualifier of the calloperator from
   // contaminating the type of the invoker, which is currently adjusted
   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
   // trailing return type of the invoker would require a visitor to rebuild
   // the trailing return type and adjusting all back DeclRefExpr's to refer
   // to the new static invoker parameters - not the call operator's.
   CXXMethodDecl *Invoke = CXXMethodDecl::Create(
       S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc),
-      InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static,
+      InvokerFunctionTy, CallOperator->getTypeSourceInfo(),
+      StorageClass::Static,
       /*isInline=*/true, ConstexprSpecKind::Unspecified,
       CallOperator->getBody()->getEndLoc());
   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
     InvokerParams[I]->setOwningFunction(Invoke);
   Invoke->setParams(InvokerParams);
   Invoke->setAccess(AS_private);
   Invoke->setImplicit(true);
   if (Class->isGenericLambda()) {
ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
 
   Block->setIsConversionFromLambda(true);
 
   // Add capture. The capture uses a fake variable, which doesn't correspond
   // to any actual memory location. However, the initializer copy-initializes
   // the lambda object.
   TypeSourceInfo *CapVarTSI =
       Context.getTrivialTypeSourceInfo(Src->getType());
-  VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation,
-                                    ConvLocation, nullptr,
-                                    Src->getType(), CapVarTSI,
-                                    SC_None);
+  VarDecl *CapVar =
+      VarDecl::Create(Context, Block, ConvLocation, ConvLocation, nullptr,
+                      Src->getType(), CapVarTSI, StorageClass::None);
   BlockDecl::Capture Capture(/*variable=*/CapVar, /*byRef=*/false,
                              /*nested=*/false, /*copy=*/Init.get());
   Block->setCaptures(Context, Capture, /*CapturesCXXThis=*/false);
 
   // Add a fake function body to the block. IR generation is responsible
   // for filling in the actual body, which cannot be expressed as an AST.
   Block->setBody(new (Context) CompoundStmt(ConvLocation));
 
   // Create the block literal expression.
   Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
   ExprCleanupObjects.push_back(Block);
   Cleanup.setExprNeedsCleanups(true);
 
   return BuildBlock;
 }

clang/lib/Sema/SemaLookup.cpp

for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
 
     SourceLocation Loc = LR.getNameLoc();
     DeclContext *Parent = Context.getTranslationUnitDecl();
     FunctionDecl *NewOpenCLBuiltin;
 
     for (unsigned Index = 0; Index < GenTypeMaxCnt; Index++) {
       NewOpenCLBuiltin = FunctionDecl::Create(
           Context, Parent, Loc, Loc, II, FunctionList[Index],
-          /*TInfo=*/nullptr, SC_Extern, false,
+          /*TInfo=*/nullptr, StorageClass::Extern, false,
           FunctionList[Index]->isFunctionProtoType());
       NewOpenCLBuiltin->setImplicit();
 
       // Create Decl objects for each parameter, adding them to the
       // FunctionDecl.
       if (const FunctionProtoType *FP =
               dyn_cast<FunctionProtoType>(FunctionList[Index])) {
         SmallVector<ParmVarDecl *, 16> ParmList;
         for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
           ParmVarDecl *Parm = ParmVarDecl::Create(
               Context, NewOpenCLBuiltin, SourceLocation(), SourceLocation(),
               nullptr, FP->getParamType(IParm),
-              /*TInfo=*/nullptr, SC_None, nullptr);
+              /*TInfo=*/nullptr, StorageClass::None, nullptr);
           Parm->setScopeInfo(0, IParm);
           ParmList.push_back(Parm);
         }
         NewOpenCLBuiltin->setParams(ParmList);
       }
 
       // Add function attributes.
       if (OpenCLBuiltin.IsPure)

clang/lib/Sema/SemaObjCProperty.cpp

if (!SetterMethod) {
           if (*nullability == NullabilityKind::Unspecified)
             paramTy = Context.getAttributedType(attr::TypeNullable,
                                                 modifiedTy, modifiedTy);
         }
       }
 
       // Invent the arguments for the setter. We don't bother making a
       // nice name for the argument.
-      ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod,
-                                                  Loc, Loc,
-                                                  property->getIdentifier(),
-                                                  paramTy,
-                                                  /*TInfo=*/nullptr,
-                                                  SC_None,
-                                                  nullptr);
+      ParmVarDecl *Argument = ParmVarDecl::Create(
+          Context, SetterMethod, Loc, Loc, property->getIdentifier(), paramTy,
+          /*TInfo=*/nullptr, StorageClass::None, nullptr);
       SetterMethod->setMethodParams(Context, Argument, None);
 
       AddPropertyAttrs(*this, SetterMethod, property);
 
       if (property->isDirectProperty())
         SetterMethod->addAttr(ObjCDirectAttr::CreateImplicit(Context, Loc));
 
       CD->addDecl(SetterMethod);

clang/lib/Sema/SemaOpenMP.cpp

if (Iter == end()) {
     return DVar;
   }
 
   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
   // in a Construct, C/C++, predetermined, p.1]
   // Variables with automatic storage duration that are declared in a scope
   // inside the construct are private.
   if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
-      (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
+      (VD->getStorageClass() == StorageClass::Auto ||
+       VD->getStorageClass() == StorageClass::None)) {
     DVar.CKind = OMPC_private;
     return DVar;
   }
 
   DVar.DKind = Iter->Directive;
   // Explicitly specified attributes and local variables with predetermined
   // attributes.
   if (Iter->SharingMap.count(D)) {

 
 /// Build a variable declaration for OpenMP loop iteration variable.
 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
                              StringRef Name, const AttrVec *Attrs = nullptr,
                              DeclRefExpr *OrigRef = nullptr) {
   DeclContext *DC = SemaRef.CurContext;
   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
-  auto *Decl =
-      VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
+  auto *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo,
+                               StorageClass::None);
   if (Attrs) {
     for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
          I != E; ++I)
       Decl->addAttr(*I);
   }
   Decl->setImplicit();
   if (OrigRef) {
     Decl->addAttr(
const DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D,
   }
   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
   // in a Construct, C/C++, predetermined, p.1]
   //  Variables appearing in threadprivate directives are threadprivate.
   if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
        !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
          SemaRef.getLangOpts().OpenMPUseTLS &&
          SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
-      (VD && VD->getStorageClass() == SC_Register &&
+      (VD && VD->getStorageClass() == StorageClass::Register &&
        VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
     DVar.RefExpr = buildDeclRefExpr(
         SemaRef, VD, D->getType().getNonReferenceType(), D->getLocation());
     DVar.CKind = OMPC_threadprivate;
     addDSA(D, DVar.RefExpr, OMPC_threadprivate);
     return DVar;
   }
   if (SemaRef.getLangOpts().OpenMPCUDAMode && VD &&
for (Expr *RefExpr : VarList) {
     }
 
     // Check if this is a TLS variable. If TLS is not being supported, produce
     // the corresponding diagnostic.
     if ((VD->getTLSKind() != VarDecl::TLS_None &&
          !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
            getLangOpts().OpenMPUseTLS &&
            getASTContext().getTargetInfo().isTLSSupported())) ||
-        (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
-         !VD->isLocalVarDecl())) {
+        (VD->getStorageClass() == StorageClass::Register &&
+         VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
       Diag(ILoc, diag::err_omp_var_thread_local)
           << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
       bool IsDecl =
           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
       Diag(VD->getLocation(),
            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
           << VD;
       continue;
Sema::DeclGroupPtrTy Sema::ActOnOpenMPAllocateDirective(
   SmallVector<Expr *, 8> Vars;
   for (Expr *RefExpr : VarList) {
     auto *DE = cast<DeclRefExpr>(RefExpr);
     auto *VD = cast<VarDecl>(DE->getDecl());
 
     // Check if this is a TLS variable or global register.
     if (VD->getTLSKind() != VarDecl::TLS_None ||
         VD->hasAttr<OMPThreadPrivateDeclAttr>() ||
-        (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
-         !VD->isLocalVarDecl()))
+        (VD->getStorageClass() == StorageClass::Register &&
+         VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()))
       continue;
 
     // If the used several times in the allocate directive, the same allocator
     // must be used.
     if (checkPreviousOMPAllocateAttribute(*this, DSAStack, RefExpr, VD,
                                           AllocatorKind, Allocator))
       continue;
 
static void setPrototype(Sema &S, FunctionDecl *FD, FunctionDecl *FDWithProto,
   assert(FD->getType()->isFunctionNoProtoType() &&
          "Expected function with type with no prototype.");
   assert(FDWithProto->getType()->isFunctionProtoType() &&
          "Expected function with prototype.");
   // Synthesize parameters with the same types.
   FD->setType(NewType);
   SmallVector<ParmVarDecl *, 16> Params;
   for (const ParmVarDecl *P : FDWithProto->parameters()) {
-    auto *Param = ParmVarDecl::Create(S.getASTContext(), FD, SourceLocation(),
-                                      SourceLocation(), nullptr, P->getType(),
-                                      /*TInfo=*/nullptr, SC_None, nullptr);
+    auto *Param =
+        ParmVarDecl::Create(S.getASTContext(), FD, SourceLocation(),
+                            /*TInfo=*/nullptr, StorageClass::None, nullptr);
     Param->setScopeInfo(0, Params.size());
     Param->setImplicit();
     Params.push_back(Param);
   }
 
   FD->setParams(Params);
 }
 

 ExprResult
 Sema::ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, QualType MapperType,
                                                SourceLocation StartLoc,
                                                DeclarationName VN) {
   TypeSourceInfo *TInfo =
       Context.getTrivialTypeSourceInfo(MapperType, StartLoc);
   auto *VD = VarDecl::Create(Context, Context.getTranslationUnitDecl(),
                              StartLoc, StartLoc, VN.getAsIdentifierInfo(),
-                             MapperType, TInfo, SC_None);
+                             MapperType, TInfo, StorageClass::None);
   if (S)
     PushOnScopeChains(VD, S, /*AddToContext=*/false);
   Expr *E = buildDeclRefExpr(*this, VD, MapperType, StartLoc);
   DSAStack->addDeclareMapperVarRef(E);
   return E;
 }
 
 bool Sema::isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const {

clang/lib/Sema/SemaPseudoObject.cpp

AtIndexGetter = ObjCMethodDecl::Create(
         S.Context, SourceLocation(), SourceLocation(), AtIndexGetterSelector,
         S.Context.getObjCIdType() /*ReturnType*/, nullptr /*TypeSourceInfo */,
         S.Context.getTranslationUnitDecl(), true /*Instance*/,
         false /*isVariadic*/,
         /*isPropertyAccessor=*/false,
         /*isSynthesizedAccessorStub=*/false,
         /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
         ObjCMethodDecl::Required, false);
-    ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
-                                                SourceLocation(), SourceLocation(),
-                                                arrayRef ? &S.Context.Idents.get("index")
-                                                         : &S.Context.Idents.get("key"),
-                                                arrayRef ? S.Context.UnsignedLongTy
-                                                         : S.Context.getObjCIdType(),
-                                                /*TInfo=*/nullptr,
-                                                SC_None,
-                                                nullptr);
+    ParmVarDecl *Argument = ParmVarDecl::Create(
+        S.Context, AtIndexGetter, SourceLocation(), SourceLocation(),
+        arrayRef ? S.Context.UnsignedLongTy : S.Context.getObjCIdType(),
+        /*TInfo=*/nullptr, StorageClass::None, nullptr);
     AtIndexGetter->setMethodParams(S.Context, Argument, None);
   }
 
   if (!AtIndexGetter) {
     if (!BaseT->isObjCIdType()) {
       S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
       << BaseExpr->getType() << 0 << arrayRef;
       return false;
AtIndexSetter = ObjCMethodDecl::Create(
         S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
         ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
         true /*Instance*/, false /*isVariadic*/,
         /*isPropertyAccessor=*/false,
         /*isSynthesizedAccessorStub=*/false,
         /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
         ObjCMethodDecl::Required, false);
     SmallVector<ParmVarDecl *, 2> Params;
-    ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
-                                                SourceLocation(), SourceLocation(),
-                                                &S.Context.Idents.get("object"),
-                                                S.Context.getObjCIdType(),
-                                                /*TInfo=*/nullptr,
-                                                SC_None,
-                                                nullptr);
+    ParmVarDecl *object = ParmVarDecl::Create(
+        S.Context, AtIndexSetter, SourceLocation(), SourceLocation(),
+        &S.Context.Idents.get("object"), S.Context.getObjCIdType(),
+        /*TInfo=*/nullptr, StorageClass::None, nullptr);
     Params.push_back(object);
-    ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
-                                                SourceLocation(), SourceLocation(),
-                                                arrayRef ?  &S.Context.Idents.get("index")
-                                                         :  &S.Context.Idents.get("key"),
-                                                arrayRef ? S.Context.UnsignedLongTy
-                                                         : S.Context.getObjCIdType(),
-                                                /*TInfo=*/nullptr,
-                                                SC_None,
-                                                nullptr);
+    ParmVarDecl *key = ParmVarDecl::Create(
+        S.Context, AtIndexSetter, SourceLocation(), SourceLocation(),
+        arrayRef ? &S.Context.Idents.get("index")
+                 : &S.Context.Idents.get("key"),
+        arrayRef ? S.Context.UnsignedLongTy : S.Context.getObjCIdType(),
+        /*TInfo=*/nullptr, StorageClass::None, nullptr);
     Params.push_back(key);
     AtIndexSetter->setMethodParams(S.Context, Params, None);
   }
 
   if (!AtIndexSetter) {
     if (!BaseT->isObjCIdType()) {
       S.Diag(BaseExpr->getExprLoc(),
              diag::err_objc_subscript_method_not_found)

clang/lib/Sema/SemaStmt.cpp

 
 /// Build a variable declaration for a for-range statement.
 VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
                               QualType Type, StringRef Name) {
   DeclContext *DC = SemaRef.CurContext;
   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
   VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
-                                  TInfo, SC_None);
+                                  TInfo, StorageClass::None);
   Decl->setImplicit();
   return Decl;
 }
 
 }
 
 static bool ObjCEnumerationCollection(Expr *Collection) {
   return !Collection->isTypeDependent()

clang/lib/Sema/SemaStmtAsm.cpp

 // Extracting the register name from the Expression value,
 // if there is no register name to extract, returns ""
 static StringRef extractRegisterName(const Expr *Expression,
                                      const TargetInfo &Target) {
   Expression = Expression->IgnoreImpCasts();
   if (const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(Expression)) {
     // Handle cases where the expression is a variable
     const VarDecl *Variable = dyn_cast<VarDecl>(AsmDeclRef->getDecl());
-    if (Variable && Variable->getStorageClass() == SC_Register) {
+    if (Variable && Variable->getStorageClass() == StorageClass::Register) {
       if (AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>())
         if (Target.isValidGCCRegisterName(Attr->getLabel()))
           return Target.getNormalizedGCCRegisterName(Attr->getLabel(), true);
     }
   }
   return "";
 }
 

clang/lib/Sema/SemaTemplate.cpp

NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
     TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);
 
     FunctionProtoTypeLoc FPTL =
         TSI->getTypeLoc().castAs<FunctionProtoTypeLoc>();
 
     // Build the parameters, needed during deduction / substitution.
     SmallVector<ParmVarDecl*, 4> Params;
     for (auto T : ParamTypes) {
-      ParmVarDecl *NewParam = ParmVarDecl::Create(
-          SemaRef.Context, DC, Loc, Loc, nullptr, T,
-          SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
+      ParmVarDecl *NewParam =
+          ParmVarDecl::Create(SemaRef.Context, DC, Loc, Loc, nullptr, T,
+                              SemaRef.Context.getTrivialTypeSourceInfo(T, Loc),
+                              StorageClass::None, nullptr);
       NewParam->setScopeInfo(0, Params.size());
       FPTL.setParam(Params.size(), NewParam);
       Params.push_back(NewParam);
     }
 
     return buildDeductionGuide(Template->getTemplateParameters(),
                                ExplicitSpecifier(), TSI, Loc, Loc, Loc);
   }
if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
                                 Converted) &&
         (!Context.getLangOpts().CPlusPlus20 ||
          !TemplateParams->hasAssociatedConstraints())) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
       //      to the implicit argument list of the primary template.
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
           << /*variable template*/ 1
-        << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
+          << /*is definition*/ (SC != StorageClass::Extern &&
+                                !CurContext->isRecord())
           << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
       // FIXME: Recover from this by treating the declaration as a redeclaration
       // of the primary template.
       return true;
     }
   }
 
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *PrevDecl = nullptr;

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     Method->setRangeEnd(Destructor->getEndLoc());
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
     Method = CXXConversionDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier,
         Conversion->getConstexprKind(), Conversion->getEndLoc(),
         TrailingRequiresClause);
   } else {
-    StorageClass SC = D->isStatic() ? SC_Static : SC_None;
+    StorageClass SC = D->isStatic() ? StorageClass::Static : StorageClass::None;
     Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
                                    T, TInfo, SC, D->isInlineSpecified(),
                                    D->getConstexprKind(), D->getEndLoc(),
                                    TrailingRequiresClause);
   }
 
   if (D->isInlined())
     Method->setImplicitlyInline();

clang/lib/Serialization/ASTReader.cpp

for (auto &RecordPair : Merge.second) {
           break;
         }
 
         // CXXMethodDecl::isStatic uses the canonical Decl.  With Decl merging,
         // FirstDecl is the canonical Decl of SecondDecl, so the storage
         // class needs to be checked instead.
         const auto FirstStorage = FirstMethod->getStorageClass();
         const auto SecondStorage = SecondMethod->getStorageClass();
-        const bool FirstStatic = FirstStorage == SC_Static;
-        const bool SecondStatic = SecondStorage == SC_Static;
+        const bool FirstStatic = FirstStorage == StorageClass::Static;
+        const bool SecondStatic = SecondStorage == StorageClass::Static;
         if (FirstStatic != SecondStatic) {
           ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
                            FirstMethod->getSourceRange(), MethodStatic)
               << FirstMethodType << FirstName << FirstStatic;
           ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
                           SecondMethod->getSourceRange(), MethodStatic)
               << SecondMethodType << SecondName << SecondStatic;
           Diagnosed = true;

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
 
   mergeMergeable(FD);
 }
 
 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
   RedeclarableResult Redecl = VisitRedeclarable(VD);
   VisitDeclaratorDecl(VD);
 
-  VD->VarDeclBits.SClass = (StorageClass)Record.readInt();
+  VD->VarDeclBits.SClass =
+      static_cast<unsigned int>(static_cast<StorageClass>(Record.readInt()));
   VD->VarDeclBits.TSCSpec = Record.readInt();
   VD->VarDeclBits.InitStyle = Record.readInt();
   VD->VarDeclBits.ARCPseudoStrong = Record.readInt();
   if (!isa<ParmVarDecl>(VD)) {
     VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition =
         Record.readInt();
     VD->NonParmVarDeclBits.ExceptionVar = Record.readInt();
     VD->NonParmVarDeclBits.NRVOVariable = Record.readInt();
     VD->NonParmVarDeclBits.CXXForRangeDecl = Record.readInt();
     VD->NonParmVarDeclBits.ObjCForDecl = Record.readInt();
     VD->NonParmVarDeclBits.IsInline = Record.readInt();
     VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
     VD->NonParmVarDeclBits.IsConstexpr = Record.readInt();
     VD->NonParmVarDeclBits.IsInitCapture = Record.readInt();
     VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record.readInt();
     VD->NonParmVarDeclBits.ImplicitParamKind = Record.readInt();
     VD->NonParmVarDeclBits.EscapingByref = Record.readInt();
   }
   auto VarLinkage = Linkage(Record.readInt());
   VD->setCachedLinkage(VarLinkage);
 
   // Reconstruct the one piece of the IdentifierNamespace that we need.
-  if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
+  if (VD->getStorageClass() == StorageClass::Extern &&
+      VarLinkage != NoLinkage &&
       VD->getLexicalDeclContext()->isFunctionOrMethod())
     VD->setLocalExternDecl();
 
   if (uint64_t Val = Record.readInt()) {
     VD->setInit(Record.readExpr());
     if (Val != 1) {
       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
       Eval->HasConstantInitialization = (Val & 2) != 0;

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   for (const auto *P : D->chain())
     Record.AddDeclRef(P);
   Code = serialization::DECL_INDIRECTFIELD;
 }
 
 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
   VisitRedeclarable(D);
   VisitDeclaratorDecl(D);
-  Record.push_back(D->getStorageClass());
+  Record.push_back(static_cast<uint64_t>(D->getStorageClass()));
   Record.push_back(D->getTSCSpec());
   Record.push_back(D->getInitStyle());
   Record.push_back(D->isARCPseudoStrong());
   if (!isa<ParmVarDecl>(D)) {
     Record.push_back(D->isThisDeclarationADemotedDefinition());
     Record.push_back(D->isExceptionVariable());
     Record.push_back(D->isNRVOVariable());
     Record.push_back(D->isCXXForRangeDecl());
void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
   Record.push_back(D->hasUninstantiatedDefaultArg());
   if (D->hasUninstantiatedDefaultArg())
     Record.AddStmt(D->getUninstantiatedDefaultArg());
   Code = serialization::DECL_PARM_VAR;
 
   // If the assumptions about the DECL_PARM_VAR abbrev are true, use it.  Here
   // we dynamically check for the properties that we optimize for, but don't
   // know are true of all PARM_VAR_DECLs.
-  if (D->getDeclContext() == D->getLexicalDeclContext() &&
-      !D->hasAttrs() &&
-      !D->hasExtInfo() &&
-      !D->isImplicit() &&
-      !D->isUsed(false) &&
-      !D->isInvalidDecl() &&
-      !D->isReferenced() &&
-      D->getAccess() == AS_none &&
-      !D->isModulePrivate() &&
-      D->getStorageClass() == 0 &&
+  if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
+      !D->hasExtInfo() && !D->isImplicit() && !D->isUsed(false) &&
+      !D->isInvalidDecl() && !D->isReferenced() && D->getAccess() == AS_none &&
+      !D->isModulePrivate() && D->getStorageClass() == StorageClass::None &&
       D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
-      D->getFunctionScopeDepth() == 0 &&
-      D->getObjCDeclQualifier() == 0 &&
-      !D->isKNRPromoted() &&
-      !D->hasInheritedDefaultArg() &&
+      D->getFunctionScopeDepth() == 0 && D->getObjCDeclQualifier() == 0 &&
+      !D->isKNRPromoted() && !D->hasInheritedDefaultArg() &&
       D->getInit() == nullptr &&
-      !D->hasUninstantiatedDefaultArg())  // No default expr.
+      !D->hasUninstantiatedDefaultArg()) // No default expr.
     AbbrevToUse = Writer.getDeclParmVarAbbrev();
 
   // Check things we know are true of *every* PARM_VAR_DECL, which is more than
   // just us assuming it.
   assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
   assert(!D->isThisDeclarationADemotedDefinition()
          && "PARM_VAR_DECL can't be demoted definition.");
   assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");