enhance awaits (#4969)

lib/compress.js

@@ -309,18 +309,14 @@ merge(Compressor.prototype, {
         var self = this;
         var tt = new TreeTransformer(function(node) {
             if (insert && node instanceof AST_SimpleStatement) {
-                return make_node(AST_Return, node, {
+                return transform ? transform(node) : make_node(AST_Return, node, { value: node.body });
-                    value: node.body
-                });
             }
             if (!insert && node instanceof AST_Return) {
                 return transform ? transform(node) : make_node(AST_SimpleStatement, node, {
                     body: node.value || make_node(AST_UnaryPrefix, node, {
                         operator: "void",
-                        expression: make_node(AST_Number, node, {
+                        expression: make_node(AST_Number, node, { value: 0 }),
-                            value: 0
+                    }),
-                        })
-                    })
                 });
             }
             if (node instanceof AST_Lambda && node !== self) {
@@ -7533,8 +7529,43 @@ merge(Compressor.prototype, {
                         node.value = value.drop_side_effect_free(compressor);
                     }
                 });
+                if (async && compressor.option("awaits")) {
+                    exp.process_expression(true, function(node) {
+                        var body = node.body;
+                        if (body instanceof AST_Await) {
+                            if (is_primitive(compressor, body.expression)) {
+                                body = body.expression.drop_side_effect_free(compressor, true);
+                                if (!body) return make_node(AST_EmptyStatement, node);
+                                node.body = body;
+                            }
+                        } else if (body instanceof AST_Sequence) {
+                            var tail = body.tail_node();
+                            if (tail instanceof AST_Await && is_primitive(compressor, tail.expression)) {
+                                tail = tail.expression.drop_side_effect_free(compressor);
+                                body.expressions.pop();
+                                if (tail) body.expressions.push(tail);
+                            }
+                        }
+                        return node;
+                    });
+                    if (all(exp.body, is_empty) && !(is_arrow(exp) && exp.value)) {
+                        var ctor;
+                        switch (exp.CTOR) {
+                          case AST_AsyncArrow:
+                            ctor = AST_Arrow;
+                            break;
+                          case AST_AsyncFunction:
+                            ctor = AST_Function;
+                            break;
+                          case AST_AsyncGeneratorFunction:
+                            ctor = AST_GeneratorFunction;
+                            break;
+                        }
+                        return make_node(ctor, exp, exp);
+                    }
+                }
+                return exp.clone();
             }
-            return drop_body;
         }
         def(AST_Call, function(compressor, first_in_statement) {
             var self = this;
@@ -7557,10 +7588,11 @@ merge(Compressor.prototype, {
                 var opt = call.transform(compressor);
                 if (opt !== call) return opt.drop_side_effect_free(compressor, first_in_statement);
             }
-            if (drop_returns(compressor, exp)) {
+            var dropped = drop_returns(compressor, exp);
+            if (dropped) {
                 // always shallow clone to ensure stripping of negated IIFEs
                 self = self.clone();
-                self.expression = exp.clone();
+                self.expression = dropped;
                 // avoid extraneous traversal
                 if (exp._squeezed) self.expression._squeezed = true;
             }
@@ -7759,10 +7791,11 @@ merge(Compressor.prototype, {
                 return make_sequence(self, expressions).drop_side_effect_free(compressor, first_in_statement);
             }
             var tag = self.tag;
-            if (drop_returns(compressor, tag)) {
+            var dropped = drop_returns(compressor, tag);
+            if (dropped) {
                 // always shallow clone to signal internal changes
                 self = self.clone();
-                self.tag = tag.clone();
+                self.tag = dropped;
                 // avoid extraneous traversal
                 if (tag._squeezed) self.tag._squeezed = true;
             }
@@ -9817,15 +9850,23 @@ merge(Compressor.prototype, {
         }
         if (compressor.option("side_effects")) {
             var exp = self.expression;
-            if (exp instanceof AST_Await) return exp;
+            if (exp instanceof AST_Await) return exp.optimize(compressor);
             if (exp instanceof AST_UnaryPrefix) {
-                if (exp.expression instanceof AST_Await) return exp;
+                if (exp.expression instanceof AST_Await) return exp.optimize(compressor);
                 if (exp.operator == "void") return make_node(AST_UnaryPrefix, self, {
                     operator: "void",
-                    expression: make_node(AST_Await, self, {
+                    expression: make_node(AST_Await, self, { expression: exp.expression }),
-                        expression: exp.expression,
+                }).optimize(compressor);
-                    }),
+            }
-                });
+            for (var level = 0, node = self, parent; parent = compressor.parent(level++); node = parent) {
+                if (is_arrow(parent)) {
+                    if (parent.value === node) return exp.optimize(compressor);
+                } else if (parent instanceof AST_Return) {
+                    return exp.optimize(compressor);
+                } else if (parent instanceof AST_Sequence) {
+                    if (parent.tail_node() === node) continue;
+                }
+                break;
             }
         }
         return self;

test/compress/awaits.js

@@ -227,9 +227,7 @@ inline_await_1_trim: {
         console.log("PASS");
     }
     expect: {
-        (async function() {
+        void 0;
-            await 0;
-        })();
         console.log("PASS");
     }
     expect_stdout: "PASS"
@@ -334,7 +332,7 @@ inline_await_3_trim: {
     }
     expect: {
         (async function() {
-            return a = "PASS", b = console.log, await b(a);
+            return a = "PASS", b = console.log, b(a);
             var a, b;
         })();
     }