dart2js cps: Better fallthrough analysis and eliminate "return null".

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../tree_ir/tree_ir_nodes.dart' show BuiltinOperator;
@@ skipping 28 matching lines @@
   /// Maps variables to their name.
   Map<tree_ir.Variable, String> variableNames = <tree_ir.Variable, String>{};
 
   /// Maps local constants to their name.
   Maplet<VariableElement, String> constantNames =
       new Maplet<VariableElement, String>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   Set<String> usedVariableNames = new Set<String>();
 
-  /// Input to [visitStatement]. Denotes the statement that will execute next
-  /// if the statements produced by [visitStatement] complete normally.
-  /// Set to null if control will fall over the end of the method.
-  tree_ir.Statement fallthrough = null;
+  final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();
 
   Set<tree_ir.Label> usedLabels = new Set<tree_ir.Label>();
 
   List<js.Statement> accumulator = new List<js.Statement>();
 
   CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
   js.Fun buildFunction(tree_ir.FunctionDefinition function) {
     currentFunction = function.element;
@@ skipping 338 matching lines @@
 
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
     return new js.Assignment(
         buildVariableAccess(node.variable),
         visitExpression(node.value));
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
-    tree_ir.Statement fallthrough = this.fallthrough;
-    if (node.target.binding == fallthrough) {
+    tree_ir.Statement next = fallthrough.target;
+    if (node.target.binding == next) {
       // Fall through to continue target
-    } else if (fallthrough is tree_ir.Continue &&
-               fallthrough.target == node.target) {
+      fallthrough.use();
+    } else if (next is tree_ir.Continue && next.target == node.target) {
       // Fall through to equivalent continue
+      fallthrough.use();
     } else {
       usedLabels.add(node.target);
       accumulator.add(new js.Continue(node.target.name));
     }
   }
 
   @override
+  void visitBreak(tree_ir.Break node) {
+    tree_ir.Statement next = fallthrough.target;
+    if (node.target.binding.next == next) {
+      // Fall through to break target
+      fallthrough.use();
+    } else if (next is tree_ir.Break && next.target == node.target) {
+      // Fall through to equivalent break
+      fallthrough.use();
+    } else {
+      usedLabels.add(node.target);
+      accumulator.add(new js.Break(node.target.name));
+    }
+  }
+
+  @override
   void visitExpressionStatement(tree_ir.ExpressionStatement node) {
     accumulator.add(new js.ExpressionStatement(
         visitExpression(node.expression)));
     visitStatement(node.next);
   }
 
   @override
   void visitIf(tree_ir.If node) {
-    accumulator.add(new js.If(visitExpression(node.condition),
-                              buildBodyStatement(node.thenStatement),
-                              buildBodyStatement(node.elseStatement)));
+    js.Expression condition = visitExpression(node.condition);
+    int usesBefore = fallthrough.useCount;
+    js.Statement thenBody = buildBodyStatement(node.thenStatement);
+    bool thenHasFallthrough = (fallthrough.useCount > usesBefore);
+    if (thenHasFallthrough) {
+      js.Statement elseBody = buildBodyStatement(node.elseStatement);
+      accumulator.add(new js.If(condition, thenBody, elseBody));
+    } else {
+      // The 'then' body cannot complete normally, so emit a short 'if'
+      // and put the 'else' body after it.
+      accumulator.add(new js.If.noElse(condition, thenBody));
+      visitStatement(node.elseStatement);
+    }
   }
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
     accumulator.add(buildLabeled(() => buildBodyStatement(node.body),
                                  node.label,
                                  node.next));
     visitStatement(node.next);
   }
 
   js.Statement buildLabeled(js.Statement buildBody(),
-                tree_ir.Label label,
-                tree_ir.Statement fallthroughStatement) {
-    tree_ir.Statement savedFallthrough = fallthrough;
-    fallthrough = fallthroughStatement;
+                            tree_ir.Label label,
+                            tree_ir.Statement fallthroughStatement) {
+    fallthrough.push(fallthroughStatement);
     js.Statement result = buildBody();
     if (usedLabels.remove(label)) {
       result = new js.LabeledStatement(label.name, result);
     }
-    fallthrough = savedFallthrough;
+    fallthrough.pop();
     return result;
   }
 
-  @override
-  void visitBreak(tree_ir.Break node) {
-    tree_ir.Statement fallthrough = this.fallthrough;
-    if (node.target.binding.next == fallthrough) {
-      // Fall through to break target
-    } else if (fallthrough is tree_ir.Break &&
-               fallthrough.target == node.target) {
-      // Fall through to equivalent break
-    } else {
-      usedLabels.add(node.target);
-      accumulator.add(new js.Break(node.target.name));
-    }
-  }
-
   /// Returns the current [accumulator] wrapped in a block if neccessary.
   js.Statement _bodyAsStatement() {
     if (accumulator.length == 0) {
       return new js.EmptyStatement();
     }
     if (accumulator.length == 1) {
       return accumulator.single;
     }
     return new js.Block(accumulator);
   }
@@ skipping 35 matching lines @@
                    node));
     visitStatement(node.next);
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
     accumulator.add(
         buildWhile(new js.LiteralBool(true), node.body, node.label, node));
   }
 
+  bool isNull(tree_ir.Expression node) {
+    return node is tree_ir.Constant && node.value.isNull;
+  }
+
   @override
   void visitReturn(tree_ir.Return node) {
-    accumulator.add(new js.Return(visitExpression(node.value)));
+    if (isNull(node.value) && fallthrough.target == null) {
+      // Do nothing. Implicitly return JS undefined by falling over the end.
+      registry.registerCompileTimeConstant(new NullConstantValue());
+      fallthrough.use();
+    } else {
+      accumulator.add(new js.Return(visitExpression(node.value)));
+    }
   }
 
   @override
   void visitThrow(tree_ir.Throw node) {
     accumulator.add(new js.Throw(visitExpression(node.value)));
   }
 
   @override
   void visitRethrow(tree_ir.Rethrow node) {
     glue.reportInternalError('rethrow seen in JavaScript output');
@@ skipping 223 matching lines @@
         return js.js("typeof # === 'number' && Math.floor(#) === #", args);
     }
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }