Merge upstream stable (dlang/dmd@5f214609d9)

dmd/dcast.d

@@ -2565,6 +2565,23 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null)
         }
     }
 
+    // Casting to noreturn isn't an actual cast
+    // Rewrite cast(<qual> noreturn) <exp>
+    // as      <exp>, assert(false)
+    if (t.isTypeNoreturn())
+    {
+        // Don't generate an unreachable assert(false) if e will abort
+        if (e.type.isTypeNoreturn())
+        {
+            // Paint e to accomodate for different type qualifiers
+            e.type = t;
+            return e;
+        }
+
+        auto ini = t.defaultInitLiteral(e.loc);
+        return Expression.combine(e, ini);
+    }
+
     scope CastTo v = new CastTo(sc, t);
     e.accept(v);
     return v.result;

dmd/dinterpret.d

@@ -2214,6 +2214,15 @@ public:
         result = getVarExp(e.loc, istate, e.var, goal);
         if (exceptionOrCant(result))
             return;
+
+        // Visit the default initializer for noreturn variables
+        // (Custom initializers would abort the current function call and exit above)
+        if (result.type.ty == Tnoreturn)
+        {
+            result.accept(this);
+            return;
+        }
+
         if ((e.var.storage_class & (STC.ref_ | STC.out_)) == 0 && e.type.baseElemOf().ty != Tstruct)
         {
             /* Ultimately, STC.ref_|STC.out_ check should be enough to see the

dmd/parse.d

@@ -6230,7 +6230,7 @@ LagainStc:
                         // not merged into the current case. This can happen for
                         // case 1: ... break;
                         // debug { case 2: ... }
-                        if (cur.isBreakStatement())
+                        if (cur && cur.isBreakStatement())
                             break;
                     }
                     s = new AST.CompoundStatement(loc, statements);

dmd/typesem.d

@@ -4540,6 +4540,19 @@ Expression defaultInit(Type mt, const ref Loc loc)
         return new TupleExp(loc, exps);
     }
 
+    Expression visitNoreturn(TypeNoreturn mt)
+    {
+        static if (LOGDEFAULTINIT)
+        {
+            printf("TypeNoreturn::defaultInit() '%s'\n", mt.toChars());
+        }
+        auto cond = IntegerExp.createBool(false);
+        auto msg = new StringExp(loc, "Accessed expression of type `noreturn`");
+        auto ae = new AssertExp(loc, cond, msg);
+        ae.type = mt;
+        return ae;
+    }
+
     switch (mt.ty)
     {
         case Tvector:   return visitVector  (cast(TypeVector)mt);
@@ -4559,6 +4572,7 @@ Expression defaultInit(Type mt, const ref Loc loc)
         case Treference:
         case Tdelegate:
         case Tclass:    return new NullExp(loc, mt);
+        case Tnoreturn: return visitNoreturn(cast(TypeNoreturn) mt);
 
         default:        return mt.isTypeBasic() ?
                                 visitBasic(cast(TypeBasic)mt) :