expand test options (#4475)

- fix corner cases in `hoist_vars` & `keep_fnames`

1 files changed, 58 insertions, 42 deletions

diff --git a/lib/compress.js b/lib/compress.js
index c556c492..103f47f1 100644
--- a/lib/compress.js
+++ b/lib/compress.js
@@ -6171,6 +6171,7 @@ merge(Compressor.prototype, {
             if (var_decl <= 1) hoist_vars = false;
         }
         if (!hoist_funs && !hoist_vars) return;
+        var consts = Object.create(null);
         var dirs = [];
         var hoisted = [];
         var vars = new Dictionary(), vars_found = 0;
@@ -6186,6 +6187,12 @@ merge(Compressor.prototype, {
                 return make_node(AST_EmptyStatement, node);
             }
             if (hoist_vars && node instanceof AST_Var) {
+                if (!all(node.definitions, function(defn) {
+                    var sym = defn.name;
+                    return sym instanceof AST_SymbolVar
+                        && !consts[sym.name]
+                        && self.find_variable(sym.name) === sym.definition();
+                })) return node;
                 node.definitions.forEach(function(def) {
                     vars.set(def.name.name, def);
                     ++vars_found;
@@ -6204,6 +6211,10 @@ merge(Compressor.prototype, {
                 });
             }
             if (node instanceof AST_Scope) return node;
+            if (node instanceof AST_SymbolConst) {
+                consts[node.name] = true;
+                return node;
+            }
         });
         self.transform(tt);
         if (vars_found > 0) {
@@ -6224,48 +6235,7 @@ merge(Compressor.prototype, {
             });
             if (defs.length > 0) {
                 // try to merge in assignments
-                for (var i = 0; i < self.body.length;) {
-                    if (self.body[i] instanceof AST_SimpleStatement) {
-                        var expr = self.body[i].body, sym, assign;
-                        if (expr instanceof AST_Assign
-                            && expr.operator == "="
-                            && (sym = expr.left) instanceof AST_Symbol
-                            && vars.has(sym.name))
-                        {
-                            var def = vars.get(sym.name);
-                            if (def.value) break;
-                            def.value = expr.right;
-                            remove(defs, def);
-                            defs.push(def);
-                            self.body.splice(i, 1);
-                            continue;
-                        }
-                        if (expr instanceof AST_Sequence
-                            && (assign = expr.expressions[0]) instanceof AST_Assign
-                            && assign.operator == "="
-                            && (sym = assign.left) instanceof AST_Symbol
-                            && vars.has(sym.name))
-                        {
-                            var def = vars.get(sym.name);
-                            if (def.value) break;
-                            def.value = assign.right;
-                            remove(defs, def);
-                            defs.push(def);
-                            self.body[i].body = make_sequence(expr, expr.expressions.slice(1));
-                            continue;
-                        }
-                    }
-                    if (self.body[i] instanceof AST_EmptyStatement) {
-                        self.body.splice(i, 1);
-                        continue;
-                    }
-                    if (self.body[i] instanceof AST_BlockStatement) {
-                        var tmp = [ i, 1 ].concat(self.body[i].body);
-                        self.body.splice.apply(self.body, tmp);
-                        continue;
-                    }
-                    break;
-                }
+                insert_vars(self.body);
                 defs = make_node(AST_Var, self, {
                     definitions: defs
                 });
@@ -6273,6 +6243,50 @@ merge(Compressor.prototype, {
             }
         }
         self.body = dirs.concat(hoisted, self.body);
+
+        function insert_vars(body) {
+            while (body.length) {
+                var stat = body[0];
+                if (stat instanceof AST_SimpleStatement) {
+                    var expr = stat.body, sym, assign;
+                    if (expr instanceof AST_Assign
+                        && expr.operator == "="
+                        && (sym = expr.left) instanceof AST_Symbol
+                        && vars.has(sym.name)) {
+                        var def = vars.get(sym.name);
+                        if (def.value) break;
+                        def.value = expr.right;
+                        remove(defs, def);
+                        defs.push(def);
+                        body.shift();
+                        continue;
+                    }
+                    if (expr instanceof AST_Sequence
+                        && (assign = expr.expressions[0]) instanceof AST_Assign
+                        && assign.operator == "="
+                        && (sym = assign.left) instanceof AST_Symbol
+                        && vars.has(sym.name)) {
+                        var def = vars.get(sym.name);
+                        if (def.value) break;
+                        def.value = assign.right;
+                        remove(defs, def);
+                        defs.push(def);
+                        stat.body = make_sequence(expr, expr.expressions.slice(1));
+                        continue;
+                    }
+                }
+                if (stat instanceof AST_EmptyStatement) {
+                    body.shift();
+                    continue;
+                }
+                if (stat instanceof AST_BlockStatement && !insert_vars(stat.body)) {
+                    body.shift();
+                    continue;
+                }
+                break;
+            }
+            return body.length;
+        }
     });
 
     function scan_local_returns(fn, transform) {
@@ -9352,6 +9366,8 @@ merge(Compressor.prototype, {
                                 scope.inlined = true;
                             } while (scope = scope.parent_scope);
                         }
+                    } else if (fixed.name && fixed.name.name == "await" && is_async(fixed)) {
+                        single_use = false;
                     }
                     if (single_use) fixed.parent_scope = self.scope;
                 } else if (!fixed || !fixed.is_constant_expression()) {