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 515 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) {

[sra1, 2015/11/30 18:59:40]

Can we tell if the unreachable code is not conditional?
Add a TODO if you don't want to tackle the following right now.

The exit is only valuable to the JS VM if the exit is conditional and the
condition constrains variables that are used after the test.

The following is a trivial example of useless exit insertion:

    ConstantMap: {
       ...
      $indexSet: function(receiver, key, val) {
        H.ConstantMap__throwUnmodifiable();
      },
--->
      $indexSet: function(receiver, key, val) {
        return H.ConstantMap__throwUnmodifiable();
      },


Slightly less trivial: conditional but no following code

      _eatEnd$0: function() {
        this._maybeEatWhitespaceOrComments$0();
        if (!this.get$endOfInput())
          this._layout$_error$1("expected end of input");
      },
--->
      _eatEnd$0: function() {
        this._maybeEatWhitespaceOrComments$0();
        if (!this.get$endOfInput())
          return this._layout$_error$1("expected end of input");
      },

[asgerf, 2015/12/01 12:40:20]

The easy fix was to look at the fallthrough stack, i.e. something like:

  if (isNullReturn(fallthough.target)) { 
    fallthrough.use();
  } else {
    return new js.Return(...);
  }

But this made a lot of code look awfully bad, for example:

  if (check)
    return ioore;
  following_code;

==>

  if (check)
    ioore;
  else {
    following_code;
  }

The short-if optimizations in visitIf needs to have higher priority than
omitting an unreachable 'return'.

There is now a separate stack to keep track of whether an unreachable node
should be emitted as 'return', which handles the two examples and without
disabling the short-if optimizations.

+      // 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);
+    }
   }
 
   @override
   void visitIf(tree_ir.If node) {
     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);
@@ skipping 126 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?
+    // 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 392 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);
     });
   }
 }