[style] Just sort out cases

0 -> const -> wild -> shared -> ... -> immutable
dlang · Dec 21, 2013 · ca45ea0 · ca45ea0
1 parent 70d3f69
commit ca45ea0
Show file tree

Hide file tree

Showing 5 changed files with 164 additions and 166 deletions.
diff --git a/src/func.c b/src/func.c
@@ -277,32 +277,32 @@ void FuncDeclaration::semantic(Scope *sc)
         {
             case STCimmutable:
             case STCimmutable | STCconst:
-            case STCimmutable | STCconst | STCshared:
-            case STCimmutable | STCshared:
             case STCimmutable | STCwild:
-            case STCimmutable | STCconst | STCwild:
-            case STCimmutable | STCconst | STCshared | STCwild:
+            case STCimmutable | STCwild | STCconst:
+            case STCimmutable | STCshared:
+            case STCimmutable | STCshared | STCconst:
             case STCimmutable | STCshared | STCwild:
+            case STCimmutable | STCshared | STCwild | STCconst:
                 // Don't use immutableOf(), as that will do a merge()
                 type = type->makeImmutable();
                 break;
 
             case STCconst:
-            case STCconst | STCwild:
+            case STCwild | STCconst:
                 type = type->makeConst();
                 break;
 
-            case STCshared | STCconst:
-            case STCshared | STCconst | STCwild:
-                type = type->makeSharedConst();
+            case STCwild:
+                type = type->makeWild();
                 break;
 
             case STCshared:
                 type = type->makeShared();
                 break;
 
-            case STCwild:
-                type = type->makeWild();
+            case STCshared | STCconst:
+            case STCshared | STCwild | STCconst:
+                type = type->makeSharedConst();
                 break;
 
             case STCshared | STCwild:

diff --git a/src/glue.c b/src/glue.c
@@ -1290,16 +1290,16 @@ unsigned Type::totym()
         case MODwild:
             t |= mTYconst;
             break;
-        case MODimmutable:
-            t |= mTYimmutable;
-            break;
         case MODshared:
             t |= mTYshared;
             break;
-        case MODshared | MODwild:
         case MODshared | MODconst:
+        case MODshared | MODwild:
             t |= mTYshared | mTYconst;
             break;
+        case MODimmutable:
+            t |= mTYimmutable;
+            break;
         default:
             assert(0);
     }

diff --git a/src/mtype.c b/src/mtype.c
@@ -859,12 +859,12 @@ void Type::check()
             if (swto) assert(swto->mod == (MODshared | MODwild));
             break;
 
-        case MODimmutable:
+        case MODwild:
             if (cto) assert(cto->mod == MODconst);
-            if (ito) assert(ito->mod == 0);
+            if (ito) assert(ito->mod == MODimmutable);
             if (sto) assert(sto->mod == MODshared);
             if (scto) assert(scto->mod == (MODshared | MODconst));
-            if (wto) assert(wto->mod == MODwild);
+            if (wto) assert(wto->mod == 0);
             if (swto) assert(swto->mod == (MODshared | MODwild));
             break;
 
@@ -886,22 +886,22 @@ void Type::check()
             if (swto) assert(swto->mod == (MODshared | MODwild));
             break;
 
-        case MODwild:
+        case MODshared | MODwild:
             if (cto) assert(cto->mod == MODconst);
             if (ito) assert(ito->mod == MODimmutable);
             if (sto) assert(sto->mod == MODshared);
             if (scto) assert(scto->mod == (MODshared | MODconst));
-            if (wto) assert(wto->mod == 0);
-            if (swto) assert(swto->mod == (MODshared | MODwild));
+            if (wto) assert(wto->mod == MODwild);
+            if (swto) assert(swto->mod == 0);
             break;
 
-        case MODshared | MODwild:
+        case MODimmutable:
             if (cto) assert(cto->mod == MODconst);
-            if (ito) assert(ito->mod == MODimmutable);
+            if (ito) assert(ito->mod == 0);
             if (sto) assert(sto->mod == MODshared);
             if (scto) assert(scto->mod == (MODshared | MODconst));
             if (wto) assert(wto->mod == MODwild);
-            if (swto) assert(swto->mod == 0);
+            if (swto) assert(swto->mod == (MODshared | MODwild));
             break;
 
         default:
@@ -921,8 +921,8 @@ void Type::check()
                 assert(tn->mod & MODimmutable || tn->mod & MODconst);
                 break;
 
-            case MODimmutable:
-                assert(tn->mod == MODimmutable);
+            case MODwild:
+                assert(tn->mod);
                 break;
 
             case MODshared:
@@ -933,14 +933,14 @@ void Type::check()
                 assert(tn->mod & MODimmutable || tn->mod & (MODshared | MODconst));
                 break;
 
-            case MODwild:
-                assert(tn->mod);
-                break;
-
             case MODshared | MODwild:
                 assert(tn->mod == MODimmutable || tn->mod == (MODshared | MODconst) || tn->mod == (MODshared | MODwild));
                 break;
 
+            case MODimmutable:
+                assert(tn->mod == MODimmutable);
+                break;
+
             default:
                 assert(0);
         }
@@ -1065,8 +1065,8 @@ Type *Type::castMod(unsigned mod)
             t = unSharedOf()->constOf();
             break;
 
-        case MODimmutable:
-            t = immutableOf();
+        case MODwild:
+            t = unSharedOf()->wildOf();
             break;
 
         case MODshared:
@@ -1077,14 +1077,14 @@ Type *Type::castMod(unsigned mod)
             t = sharedConstOf();
             break;
 
-        case MODwild:
-            t = unSharedOf()->wildOf();
-            break;
-
         case MODshared | MODwild:
             t = sharedWildOf();
             break;
 
+        case MODimmutable:
+            t = immutableOf();
+            break;
+
         default:
             assert(0);
     }
@@ -1117,8 +1117,13 @@ Type *Type::addMod(unsigned mod)
                     t = constOf();
                 break;
 
-            case MODimmutable:
-                t = immutableOf();
+            case MODwild:
+                if (isConst())
+                    ;
+                else if (isShared())
+                    t = sharedWildOf();
+                else
+                    t = wildOf();
                 break;
 
             case MODshared:
@@ -1134,22 +1139,17 @@ Type *Type::addMod(unsigned mod)
                 t = sharedConstOf();
                 break;
 
-            case MODwild:
-                if (isConst())
-                    ;
-                else if (isShared())
-                    t = sharedWildOf();
-                else
-                    t = wildOf();
-                break;
-
             case MODshared | MODwild:
                 if (isConst())
                     t = sharedConstOf();
                 else
                     t = sharedWildOf();
                 break;
 
+            case MODimmutable:
+                t = immutableOf();
+                break;
+
             default:
                 assert(0);
         }