dart2js cps: Emit 'return' after throwing call to assist VM analysis.

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 '../../closure.dart' show
     ClosureClassElement;
@@ skipping 50 matching lines @@
   Set<String> usedVariableNames = new Set<String>();
 
   final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();
 
   /// Stacks whose top element is the current target of an unlabeled break
   /// or continue. For continues, this is the loop node itself.
   final tree_ir.FallthroughStack shortBreak = new tree_ir.FallthroughStack();
   final tree_ir.FallthroughStack shortContinue =
       new tree_ir.FallthroughStack();
 
+  /// When the top element is true, [Unreachable] statements will be emitted
+  /// as [Return]s, otherwise they are emitted as empty because they are
+  /// followed by the end of the method.
+  ///
+  /// Note on why the [fallthrough] stack should not be used for this:
+  /// Ordinary statements may choose whether to use the [fallthrough] target,
+  /// and the choice to do so may disable an optimization in [visitIf].
+  /// But omitting an unreachable 'return' should have lower priority than
+  /// the optimizations in [visitIf], so [visitIf] will instead tell the
+  /// [Unreachable] statements whether they may use fallthrough or not.
+  List<bool> emitUnreachableAsReturn = <bool>[false];
+
   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) {
     registerDefaultParameterValues(function.element);
     currentFunction = function.element;
@@ skipping 446 matching lines @@
       shortContinue.use();
       accumulator.add(new js.Continue(null));
     } 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);
+    js.Expression exp = visitExpression(node.expression);
+    if (node.next is tree_ir.Unreachable && emitUnreachableAsReturn.last) {
+      // Emit as 'return exp' to assist local analysis in the VM.
+      accumulator.add(new js.Return(exp));
+    } else {
+      accumulator.add(new js.ExpressionStatement(exp));
+      visitStatement(node.next);
+    }
+  }
+
+  bool isNullReturn(tree_ir.Statement node) {
+    return node is tree_ir.Return && isNull(node.value);
+  }
+
+  bool isEndOfMethod(tree_ir.Statement node) {
+    return isNullReturn(node) ||
+           node is tree_ir.Break && isNullReturn(node.target.binding.next);
   }
 
   @override
   void visitIf(tree_ir.If node) {
     js.Expression condition = visitExpression(node.condition);
     int usesBefore = fallthrough.useCount;
+    // Unless the 'else' part ends the method. make sure to terminate any
+    // uncompletable code paths in the 'then' part.
+    emitUnreachableAsReturn.add(!isEndOfMethod(node.elseStatement));
     js.Statement thenBody = buildBodyStatement(node.thenStatement);
+    emitUnreachableAsReturn.removeLast();
     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);
     }
@@ skipping 50 matching lines @@
   js.Expression makeSequence(List<tree_ir.Expression> list) {
     return list.map(visitExpression).reduce((x,y) => new js.Binary(',', x, y));
   }
 
   @override
   void visitFor(tree_ir.For node) {
     js.Expression condition = visitExpression(node.condition);
     shortBreak.push(node.next);
     shortContinue.push(node);
     fallthrough.push(node);
+    emitUnreachableAsReturn.add(true);
     js.Statement body = buildBodyStatement(node.body);
+    emitUnreachableAsReturn.removeLast();
     fallthrough.pop();
     shortContinue.pop();
     shortBreak.pop();
     js.Statement loopNode;
     if (node.updates.isEmpty) {
       loopNode = new js.While(condition, body);
     } else { // Compile as a for loop.
       js.Expression init;
       if (accumulator.isNotEmpty &&
           accumulator.last is js.ExpressionStatement) {
         // Take the preceding expression from the accumulator and use
         // it as the initializer expression.
         js.ExpressionStatement initStmt = accumulator.removeLast();
         init = initStmt.expression;
       }
       js.Expression update = makeSequence(node.updates);
       loopNode = new js.For(init, condition, update, body);
     }
     accumulator.add(insertLabel(node.label, loopNode));
     visitStatement(node.next);
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
     js.Expression condition = new js.LiteralBool(true);
     // A short break in the while will jump to the current fallthrough target.
     shortBreak.push(fallthrough.target);
     shortContinue.push(node);
     fallthrough.push(node);
+    emitUnreachableAsReturn.add(true);
     js.Statement jsBody = buildBodyStatement(node.body);
+    emitUnreachableAsReturn.removeLast();
     fallthrough.pop();
     shortContinue.pop();
     if (shortBreak.useCount > 0) {
       // Short breaks use the current fallthrough target.
       fallthrough.use();
     }
     shortBreak.pop();
     accumulator.add(insertLabel(node.label, new js.While(condition, jsBody)));
   }
 
@@ skipping 18 matching lines @@
     accumulator.add(new js.Throw(visitExpression(node.value)));
   }
 
   @override
   void visitRethrow(tree_ir.Rethrow node) {
     glue.reportInternalError('rethrow seen in JavaScript output');
   }
 
   @override
   void visitUnreachable(tree_ir.Unreachable node) {
-    // Output nothing.
-    // TODO(asgerf): Emit a throw/return to assist local analysis in the VM?
+    if (emitUnreachableAsReturn.last) {
+      // Emit a return to assist local analysis in the VM.
+      accumulator.add(new js.Return());
+    }
   }
 
   @override
   void visitTry(tree_ir.Try node) {
     js.Block tryBlock = buildBodyBlock(node.tryBody);
     tree_ir.Variable exceptionVariable = node.catchParameters.first;
     js.VariableDeclaration exceptionParameter =
         new js.VariableDeclaration(getVariableName(exceptionVariable));
     js.Block catchBlock = buildBodyBlock(node.catchBody);
     js.Catch catchPart = new js.Catch(exceptionParameter, catchBlock);
@@ skipping 388 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }