enhance `conditionals` (#3798)

1 files changed, 94 insertions, 41 deletions

diff --git a/lib/compress.js b/lib/compress.js
index 3aa9f0bc..872e2bbf 100644
--- a/lib/compress.js
+++ b/lib/compress.js
@@ -5222,50 +5222,53 @@ merge(Compressor.prototype, {
             self.body = self.alternative || make_node(AST_EmptyStatement, self);
             self.alternative = tmp;
         }
-        if (self.body instanceof AST_SimpleStatement
-            && self.alternative instanceof AST_SimpleStatement) {
-            return make_node(AST_SimpleStatement, self, {
-                body: make_node(AST_Conditional, self, {
-                    condition   : self.condition,
-                    consequent  : self.body.body,
-                    alternative : self.alternative.body
-                })
-            }).optimize(compressor);
-        }
-        if (is_empty(self.alternative) && self.body instanceof AST_SimpleStatement) {
-            if (self_condition_length === negated_length && !negated_is_best
-                && self.condition instanceof AST_Binary && self.condition.operator == "||") {
-                // although the code length of self.condition and negated are the same,
-                // negated does not require additional surrounding parentheses.
-                // see https://github.com/mishoo/UglifyJS2/issues/979
-                negated_is_best = true;
-            }
-            if (negated_is_best) return make_node(AST_SimpleStatement, self, {
-                body: make_node(AST_Binary, self, {
-                    operator : "||",
-                    left     : negated,
-                    right    : self.body.body
-                }).transform(compressor)
-            }).optimize(compressor);
-            return make_node(AST_SimpleStatement, self, {
-                body: make_node(AST_Binary, self, {
-                    operator : "&&",
-                    left     : self.condition,
-                    right    : self.body.body
-                }).transform(compressor)
+        var body = [], var_defs = [], refs = [];
+        var body_exprs = sequencesize(self.body, body, var_defs, refs);
+        var alt_exprs = sequencesize(self.alternative, body, var_defs, refs);
+        if (body_exprs && alt_exprs) {
+            if (var_defs.length > 0) body.push(make_node(AST_Var, self, {
+                definitions: var_defs
+            }));
+            if (body_exprs.length == 0) {
+                body.push(make_node(AST_SimpleStatement, self.condition, {
+                    body: alt_exprs.length > 0 ? make_node(AST_Binary, self, {
+                        operator : "||",
+                        left     : self.condition,
+                        right    : make_sequence(self.alternative, alt_exprs)
+                    }).transform(compressor) : self.condition.clone()
+                }).optimize(compressor));
+            } else if (alt_exprs.length == 0) {
+                if (self_condition_length === negated_length && !negated_is_best
+                    && self.condition instanceof AST_Binary && self.condition.operator == "||") {
+                    // although the code length of self.condition and negated are the same,
+                    // negated does not require additional surrounding parentheses.
+                    // see https://github.com/mishoo/UglifyJS2/issues/979
+                    negated_is_best = true;
+                }
+                body.push(make_node(AST_SimpleStatement, self, {
+                    body: make_node(AST_Binary, self, {
+                        operator : negated_is_best ? "||" : "&&",
+                        left     : negated_is_best ? negated : self.condition,
+                        right    : make_sequence(self.body, body_exprs)
+                    }).transform(compressor)
+                }).optimize(compressor));
+            } else {
+                body.push(make_node(AST_SimpleStatement, self, {
+                    body: make_node(AST_Conditional, self, {
+                        condition   : self.condition,
+                        consequent  : make_sequence(self.body, body_exprs),
+                        alternative : make_sequence(self.alternative, alt_exprs)
+                    })
+                }).optimize(compressor));
+            }
+            refs.forEach(function(ref) {
+                ref.definition().references.push(ref);
+            });
+            return make_node(AST_BlockStatement, self, {
+                body: body
             }).optimize(compressor);
         }
         if (is_empty(self.body)) {
-            if (is_empty(self.alternative)) return make_node(AST_SimpleStatement, self.condition, {
-                body: self.condition.clone()
-            }).optimize(compressor);
-            if (self.alternative instanceof AST_SimpleStatement) return make_node(AST_SimpleStatement, self, {
-                body: make_node(AST_Binary, self, {
-                    operator : "||",
-                    left     : self.condition,
-                    right    : self.alternative.body
-                }).transform(compressor)
-            }).optimize(compressor);
             self = make_node(AST_If, self, {
                 condition: negated,
                 body: self.alternative,
@@ -5320,6 +5323,56 @@ merge(Compressor.prototype, {
         }
         if (compressor.option("typeofs")) mark_locally_defined(self.condition, self.body, self.alternative);
         return self;
+
+        function sequencesize(stat, defuns, var_defs, refs) {
+            if (stat == null) return [];
+            if (stat instanceof AST_BlockStatement) {
+                var exprs = [];
+                for (var i = 0; i < stat.body.length; i++) {
+                    var line = stat.body[i];
+                    if (line instanceof AST_Defun) {
+                        defuns.push(line);
+                    } else if (line instanceof AST_EmptyStatement) {
+                        continue;
+                    } else if (line instanceof AST_SimpleStatement) {
+                        if (!compressor.option("sequences") && exprs.length > 0) return;
+                        exprs.push(line.body);
+                    } else if (line instanceof AST_Var) {
+                        if (!compressor.option("sequences") && exprs.length > 0) return;
+                        line.definitions.forEach(process_var_def);
+                    } else {
+                        return;
+                    }
+                }
+                return exprs;
+            }
+            if (stat instanceof AST_Defun) {
+                defuns.push(stat);
+                return [];
+            }
+            if (stat instanceof AST_EmptyStatement) return [];
+            if (stat instanceof AST_SimpleStatement) return [ stat.body ];
+            if (stat instanceof AST_Var) {
+                var exprs = [];
+                stat.definitions.forEach(process_var_def);
+                return exprs;
+            }
+
+            function process_var_def(var_def) {
+                var_defs.push(make_node(AST_VarDef, var_def, {
+                    name: var_def.name,
+                    value: null
+                }));
+                if (!var_def.value) return;
+                var ref = make_node(AST_SymbolRef, var_def.name, var_def.name);
+                exprs.push(make_node(AST_Assign, var_def, {
+                    operator: "=",
+                    left: ref,
+                    right: var_def.value
+                }));
+                refs.push(ref);
+            }
+        }
     });
 
     OPT(AST_Switch, function(self, compressor) {