better solution for the last test in constant switch folding

lib/compress.js

@@ -1368,7 +1368,8 @@ merge(Compressor.prototype, {
             self.expression = exp[0];
             if (!compressor.option("dead_code")) break out;
             var value = exp[1];
-            var in_substat = false;
+            var in_if = false;
+            var in_block = false;
             var started = false;
             var stopped = false;
             var ruined = false;
@@ -1377,32 +1378,36 @@ merge(Compressor.prototype, {
                     // no need to descend these node types
                     return node;
                 }
-                else if (node instanceof AST_Switch) {
+                else if (node instanceof AST_Switch && node === self) {
-                    if (node === self) {
+                    node = node.clone();
-                        node = node.clone();
-                        descend(node, this);
-                        return ruined ? node : make_node(AST_BlockStatement, node, {
-                            body: node.body.reduce(function(a, branch){
-                                return a.concat(branch.body);
-                            }, [])
-                        }).transform(compressor);
-                    }
-                }
-                else if (node instanceof AST_StatementWithBody || node instanceof AST_Switch || node instanceof AST_Try) {
-                    var save_substat = in_substat;
-                    in_substat = true;
                     descend(node, this);
-                    in_substat = save_substat;
+                    return ruined ? node : make_node(AST_BlockStatement, node, {
+                        body: node.body.reduce(function(a, branch){
+                            return a.concat(branch.body);
+                        }, [])
+                    }).transform(compressor);
+                }
+                else if (node instanceof AST_If || node instanceof AST_Try) {
+                    var save = in_if;
+                    in_if = !in_block;
+                    descend(node, this);
+                    in_if = save;
+                    return node;
+                }
+                else if (node instanceof AST_StatementWithBody || node instanceof AST_Switch) {
+                    var save = in_block;
+                    in_block = true;
+                    descend(node, this);
+                    in_block = save;
                     return node;
                 }
                 else if (node instanceof AST_Break && this.loopcontrol_target(node.label) === self) {
-                    if (in_substat) {
+                    if (in_if) {
-                        // won't handle situations like if (foo) break;
                         ruined = true;
                         return node;
-                    } else {
-                        stopped = true;
                     }
+                    if (in_block) return node;
+                    stopped = true;
                     return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
                 }
                 else if (node instanceof AST_SwitchBranch && this.parent() === self) {

test/compress/switch.js

@@ -176,11 +176,35 @@ constant_switch_8: {
         }
     }
     expect: {
-        OUT: switch (1) {
+        OUT: {
-          case 1:
             x();
             for (;;) break OUT;
             y();
         }
     }
 }
+
+constant_switch_9: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        OUT: switch (1) {
+          case 1:
+            x();
+            for (;;) if (foo) break OUT;
+            y();
+          case 1+1:
+            bar();
+          default:
+            def();
+        }
+    }
+    expect: {
+        OUT: {
+            x();
+            for (;;) if (foo) break OUT;
+            y();
+            bar();
+            def();
+        }
+    }
+}