const(Object)ref

src/cast.c

@@ -1734,8 +1734,8 @@ int typeMerge(Scope *sc, Expression *e, Type **pt, Expression **pe1, Expression
     }
     else if (t1->ty == Tclass || t2->ty == Tclass)
     {
-        if (t1->mod != t2->mod)
-        {   unsigned char mod = MODmerge(t1->mod, t2->mod);
+        if (t1->head()->mod != t2->head()->mod)
+        {   unsigned char mod = MODmerge(t1->head()->mod, t2->head()->mod);
             t1 = t1->castMod(mod);
             t2 = t2->castMod(mod);
             t = t1;

src/declaration.c

@@ -91,7 +91,7 @@ void Declaration::checkModify(Loc loc, Scope *sc, Type *t)
     if (sc->incontract && isResult())
         error(loc, "cannot modify result '%s' in contract", toChars());
 
-    if (isCtorinit() && !t->isMutable())
+    if (isCtorinit() && !t->head()->isMutable())
     {   // It's only modifiable if inside the right constructor
         Dsymbol *s = sc->func;
         while (1)
@@ -904,16 +904,17 @@ void VarDeclaration::semantic(Scope *sc)
 
     /* Adjust storage class to reflect type
      */
-    if (type->isConst())
+    Type *thead = type->head();
+    if (thead->isConst())
     {   storage_class |= STCconst;
-        if (type->isShared())
+        if (thead->isShared())
             storage_class |= STCshared;
     }
-    else if (type->isImmutable())
+    else if (thead->isImmutable())
         storage_class |= STCimmutable;
-    else if (type->isShared())
+    else if (thead->isShared())
         storage_class |= STCshared;
-    else if (type->isWild())
+    else if (thead->isWild())
         storage_class |= STCwild;
 
     if (isSynchronized())

src/expression.c

@@ -1164,7 +1164,7 @@ Expression *Expression::modifiableLvalue(Scope *sc, Expression *e)
 
     // See if this expression is a modifiable lvalue (i.e. not const)
 #if DMDV2
-    if (type && (!type->isMutable() || !type->isAssignable()))
+    if (type && (!type->head()->isMutable() || !type->isAssignable()))
         error("%s is not mutable", e->toChars());
 #endif
     return toLvalue(sc, e);
@@ -6548,9 +6548,9 @@ Expression *DotVarExp::modifiableLvalue(Scope *sc, Expression *e)
 
     Type *t1 = e1->type->toBasetype();
 
-    if (!t1->isMutable() ||
-        (t1->ty == Tpointer && !t1->nextOf()->isMutable()) ||
-        !var->type->isMutable() ||
+    if (!t1->head()->isMutable() ||
+        (t1->ty == Tpointer && !t1->nextOf()->head()->isMutable()) ||
+        !var->type->head()->isMutable() ||
         !var->type->isAssignable() ||
         var->storage_class & STCmanifest
        )
@@ -9118,7 +9118,7 @@ Expression *IndexExp::modifiableLvalue(Scope *sc, Expression *e)
     modifiable = 1;
     if (e1->op == TOKstring)
         error("string literals are immutable");
-    if (type && (!type->isMutable() || !type->isAssignable()))
+    if (type && (!type->head()->isMutable() || !type->head()->isAssignable()))
         error("%s isn't mutable", e->toChars());
     Type *t1 = e1->type->toBasetype();
     if (t1->ty == Taarray)
@@ -9580,7 +9580,7 @@ Expression *AssignExp::semantic(Scope *sc)
     else if (e1->op == TOKslice)
     {
         Type *tn = e1->type->nextOf();
-        if (op == TOKassign && tn && (!tn->isMutable() || !tn->isAssignable()))
+        if (op == TOKassign && tn && (!tn->head()->isMutable() || !tn->head()->isAssignable()))
         {   error("slice %s is not mutable", e1->toChars());
             return new ErrorExp();
         }

src/func.c

@@ -1315,7 +1315,7 @@ void FuncDeclaration::semantic3(Scope *sc)
                     for (int i = 0; i < cd->fields.dim; i++)
                     {   VarDeclaration *v = (VarDeclaration *)cd->fields.data[i];
 
-                        if (v->ctorinit == 0 && v->isCtorinit() && !v->type->isMutable())
+                        if (v->ctorinit == 0 && v->isCtorinit() && !v->type->head()->isMutable())
                             error("missing initializer for final field %s", v->toChars());
                     }
                 }