Replace STCxxx with STC enum

```
replacements=(
"STCautoref autoref"
"STCinference inference"
"STCinit init"
"STCscopeinferred scopeinferred"
"STCundefined undefined_"
"STCstatic static_"
"STCextern extern_"
"STCconst const_"
"STCfinal final_"
"STCabstract abstract_"
"STCparameter parameter"
"STCfield field"
"STCoverride override_"
"STCauto auto_"
"STCsynchronized synchronized_"
"STCdeprecated deprecated_"
"STCin in_"
"STCout out_"
"STClazy lazy_"
"STCforeach foreach_"
"STCvariadic variadic"
"STCctorinit ctorinit"
"STCtemplateparameter templateparameter"
"STCscope scope_"
"STCimmutable immutable_"
"STCref ref_"
"STCmanifest manifest"
"STCnodtor nodtor"
"STCnothrow nothrow_"
"STCpure pure_"
"STCtls tls"
"STCalias alias_"
"STCshared shared_"
"STCgshared gshared"
"STCwild wild"
"STCproperty property"
"STCsafe safe"
"STCtrusted trusted"
"STCsystem system"
"STCctfe ctfe"
"STCdisable disable"
"STCresult result"
"STCnodefaultctor nodefaultctor"
"STCtemp temp"
"STCrvalue rvalue"
"STCnogc nogc"
"STCvolatile volatile_"
"STCreturn return_"
"STCexptemp exptemp"
"STCmaybescope maybescope"
"STCfuture future"
"STClocal local"
"STC_TYPECTOR TYPECTOR"
"STC_FUNCATTR FUNCATTR"
)
for r in "${replacements[@]}" ; do
    w=($r)
    sed "s/${w[0]}/STC.${w[1]}/g" -i **/*.d
done
```

Author: wilzbach

src/dmd/aggregate.d

@@ -120,7 +120,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
     Scope* newScope(Scope* sc)
     {
         auto sc2 = sc.push(this);
-        sc2.stc &= STCsafe | STCtrusted | STCsystem;
+        sc2.stc &= STC.safe | STC.trusted | STC.system;
         sc2.parent = this;
         if (isUnionDeclaration())
             sc2.inunion = 1;
@@ -166,7 +166,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
             auto v = s.isVarDeclaration();
             if (!v)
                 return 0;
-            if (v.storage_class & STCmanifest)
+            if (v.storage_class & STC.manifest)
                 return 0;
 
             auto ad = cast(AggregateDeclaration)param;
@@ -180,14 +180,14 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
             if (v.aliassym)
                 return 0;   // If this variable was really a tuple, skip it.
 
-            if (v.storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCctfe | STCtemplateparameter))
+            if (v.storage_class & (STC.static_ | STC.extern_ | STC.tls | STC.gshared | STC.manifest | STC.ctfe | STC.templateparameter))
                 return 0;
             if (!v.isField() || v.semanticRun < PASSsemanticdone)
                 return 1;   // unresolvable forward reference
 
             ad.fields.push(v);
 
-            if (v.storage_class & STCref)
+            if (v.storage_class & STC.ref_)
                 return 0;
             auto tv = v.type.baseElemOf();
             if (tv.ty != Tstruct)
@@ -472,7 +472,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
                 }
                 else
                 {
-                    if ((vx.storage_class & STCnodefaultctor) && !ctorinit)
+                    if ((vx.storage_class & STC.nodefaultctor) && !ctorinit)
                     {
                         .error(loc, "field `%s.%s` must be initialized because it has no default constructor",
                             type.toChars(), vx.toChars());
@@ -614,7 +614,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
             return;
         if (isUnionDeclaration() || isInterfaceDeclaration())
             return;
-        if (storage_class & STCstatic)
+        if (storage_class & STC.static_)
             return;
 
         // If nested struct, add in hidden 'this' pointer to outer scope
@@ -656,13 +656,13 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
 
             assert(!vthis);
             vthis = new ThisDeclaration(loc, t);
-            //vthis.storage_class |= STCref;
+            //vthis.storage_class |= STC.ref_;
 
             // Emulate vthis.addMember()
             members.push(vthis);
 
             // Emulate vthis.dsymbolSemantic()
-            vthis.storage_class |= STCfield;
+            vthis.storage_class |= STC.field;
             vthis.parent = this;
             vthis.protection = Prot(PROTpublic);
             vthis.alignment = t.alignment();

src/dmd/astbase.d

@@ -296,16 +296,16 @@ extern (C++) class StorageClassDeclaration : AttribDeclaration
         /* These sets of storage classes are mutually exclusive,
          * so choose the innermost or most recent one.
          */
-        if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest))
-            scstc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest);
-        if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared))
-            scstc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared);
-        if (stc & (STCconst | STCimmutable | STCmanifest))
-            scstc &= ~(STCconst | STCimmutable | STCmanifest);
-        if (stc & (STCgshared | STCshared | STCtls))
-            scstc &= ~(STCgshared | STCshared | STCtls);
-        if (stc & (STCsafe | STCtrusted | STCsystem))
-            scstc &= ~(STCsafe | STCtrusted | STCsystem);
+        if (stc & (STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.manifest))
+            scstc &= ~(STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.manifest);
+        if (stc & (STC.auto_ | STC.scope_ | STC.static_ | STC.tls | STC.manifest | STC.gshared))
+            scstc &= ~(STC.auto_ | STC.scope_ | STC.static_ | STC.tls | STC.manifest | STC.gshared);
+        if (stc & (STC.const_ | STC.immutable_ | STC.manifest))
+            scstc &= ~(STC.const_ | STC.immutable_ | STC.manifest);
+        if (stc & (STC.gshared | STC.shared_ | STC.tls))
+            scstc &= ~(STC.gshared | STC.shared_ | STC.tls);
+        if (stc & (STC.safe | STC.trusted | STC.system))
+            scstc &= ~(STC.safe | STC.trusted | STC.system);
         scstc |= stc;
         //printf("scstc = x%llx\n", scstc);
         return createNewScope(sc, scstc, sc.linkage, sc.cppmangle,
@@ -349,13 +349,13 @@ extern (C++) class StorageClassDeclaration : AttribDeclaration
             {
                 Dsymbol s = (*d)[i];
                 //printf("\taddMember %s to %s\n", s.toChars(), sds.toChars());
-                // STClocal needs to be attached before the member is added to the scope (because it influences the parent symbol)
+                // STC.local needs to be attached before the member is added to the scope (because it influences the parent symbol)
                 if (auto decl = s.isDeclaration())
                 {
-                    decl.storage_class |= stc & STClocal;
+                    decl.storage_class |= stc & STC.local;
                     if (auto sdecl = s.isStorageClassDeclaration()) // TODO: why is this not enough to deal with the nested case?
                     {
-                        sdecl.stc |= stc & STClocal;
+                        sdecl.stc |= stc & STC.local;
                     }
                 }
                 s.addMember(sc2, sds);
@@ -386,7 +386,7 @@ extern (C++) final class DeprecatedDeclaration : StorageClassDeclaration
 
     extern (D) this(Expression msg, Dsymbols* decl)
     {
-        super(STCdeprecated, decl);
+        super(STC.deprecated_, decl);
         this.msg = msg;
     }
 
@@ -397,7 +397,7 @@ extern (C++) final class DeprecatedDeclaration : StorageClassDeclaration
     }
 
     /**
-     * Provides a new scope with `STCdeprecated` and `Scope.depdecl` set
+     * Provides a new scope with `STC.deprecated_` and `Scope.depdecl` set
      *
      * Calls `StorageClassDeclaration.newScope` (as it must be called or copied
      * in any function overriding `newScope`), then set the `Scope`'s depdecl.
@@ -1142,7 +1142,7 @@ extern (C++) final class StaticForeachDeclaration : AttribDeclaration
  * another scope, like:
  *
  *      static foreach (i; 0 .. 10) // loop variables for different indices do not conflict.
- *      { // this body is expanded into 10 ForwardingAttribDeclarations, where `i` has storage class STClocal
+ *      { // this body is expanded into 10 ForwardingAttribDeclarations, where `i` has storage class STC.local
  *          mixin("enum x" ~ to!string(i) ~ " = i"); // ok, can access current loop variable
  *      }
  *

src/dmd/attrib.d

@@ -510,9 +510,9 @@ int blockExit(Statement s, FuncDeclaration func, bool mustNotThrow)
         {
             // Assume the worst
             result = BE.fallthru | BE.return_ | BE.goto_ | BE.halt;
-            if (!(s.stc & STCnothrow))
+            if (!(s.stc & STC.nothrow_))
             {
-                if (mustNotThrow && !(s.stc & STCnothrow))
+                if (mustNotThrow && !(s.stc & STC.nothrow_))
                     s.deprecation("asm statement is assumed to throw - mark it with `nothrow` if it does not");
                 else
                     result |= BE.throw_;

src/dmd/blockexit.d

@@ -260,10 +260,10 @@ private bool Dsymbol_canThrow(Dsymbol s, FuncDeclaration func, bool mustNotThrow
         s = s.toAlias();
         if (s != vd)
             return Dsymbol_canThrow(s, func, mustNotThrow);
-        if (vd.storage_class & STCmanifest)
+        if (vd.storage_class & STC.manifest)
         {
         }
-        else if (vd.isStatic() || vd.storage_class & (STCextern | STCtls | STCgshared))
+        else if (vd.isStatic() || vd.storage_class & (STC.extern_ | STC.tls | STC.gshared))
         {
         }
         else