Mark returns from inside the try of a try/catch as ones that exit the try.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 141 matching lines @@
   /// Construct a collector for a given environment and optionally a target.
   ///
   /// The environment is the one in effect at the point where the jump's
   /// continuation will be bound.  Continuations can take an extra argument
   /// (see [addJump]).
   JumpCollector(this._continuationEnvironment, this.target,
       bool hasExtraArgument) {
     if (hasExtraArgument) _continuationEnvironment.extend(null, null);
   }
 
+  /// Construct a collector for collecting only return jumps.
+  ///
+  /// There is no jump target, it is implicitly the exit from the function.
+  /// There is no environment at the destination.
+  JumpCollector.retrn(this._continuation)
+      : _continuationEnvironment = null, target = null;
+
   /// True if the collector has not recorded any jumps to its continuation.
   bool get isEmpty;
 
   /// The continuation encapsulated by this collector.
   ir.Continuation get continuation;
 
   /// The compile-time environment to be used for translating code in the body
   /// of the continuation.
   Environment get environment;
 
   /// Emit a jump to the continuation for a given [IrBuilder].
   ///
   /// Jumps can take a single extra argument.  This is used to pass return
   /// values to finally blocks for returns inside try/finally and to pass
   /// values of expressions that have internal control flow to their join-point
   /// continuations.
-  void addJump(IrBuilder builder, [ir.Primitive value]);
+  void addJump(IrBuilder builder,
+      [ir.Primitive value, SourceInformation sourceInformation]);
 
   /// Add a set of variables that were boxed on entry to a try block.
   ///
   /// All jumps from a try block to targets outside have to unbox the
   /// variables that were boxed on entry before invoking the target
   /// continuation.  Call this function before translating a try block and
   /// call [leaveTry] after translating it.
   void enterTry(Iterable<LocalVariableElement> boxedOnEntry) {
     // The boxed variables are maintained as a stack to make leaving easy.
     _boxedTryVariables.add(boxedOnEntry);
@@ skipping 63 matching lines @@
   ir.Continuation get continuation {
     if (_continuation == null) _setContinuation();
     return _continuation;
   }
 
   Environment get environment {
     if (_continuation == null) _setContinuation();
     return _continuationEnvironment;
   }
 
-  void addJump(IrBuilder builder, [ir.Primitive value]) {
+  void addJump(IrBuilder builder,
+      [ir.Primitive value, SourceInformation sourceInformation]) {
     assert(_continuation == null);
     _buildTryExit(builder);
     ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized(
         isEscapingTry: isEscapingTry);
     builder.add(invoke);
     _invocations.add(invoke);
     // Truncate the environment at the invocation site so it only includes
     // values that will be continuation arguments.  If an extra value is passed
     // it will already be included in the continuation environment, but it is
     // not present in the invocation environment.
@@ skipping 88 matching lines @@
     List<ir.Parameter> parameters =
         new List<ir.Parameter>.from(_continuationEnvironment.index2value);
     _continuation = new ir.Continuation(parameters, isRecursive: true);
   }
 
   bool isEmpty = true;
 
   ir.Continuation get continuation => _continuation;
   Environment get environment => _continuationEnvironment;
 
-  void addJump(IrBuilder builder, [ir.Primitive value]) {
+  void addJump(IrBuilder builder,
+      [ir.Primitive value, SourceInformation sourceInformation]) {
     assert(_continuation.parameters.length <= builder.environment.length);
     isEmpty = false;
     _buildTryExit(builder);
     // Truncate the environment at the invocation site so it only includes
     // values that will be continuation arguments.  If an extra value is passed
     // it will already be included in the continuation environment, but it is
     // not present in the invocation environment.
     int delta = builder.environment.length - _continuationEnvironment.length;
     if (value != null) ++delta;
     if (delta > 0) builder.environment.discard(delta);
     if (value != null) builder.environment.extend(null, value);
     builder.add(new ir.InvokeContinuation(_continuation,
         builder.environment.index2value,
         isRecursive: true,
         isEscapingTry: isEscapingTry));
     builder._current = null;
   }
 }
 
+/// Collect 'return' jumps.
+///
+/// A return jump is one that targets the return continuation of a function.
+/// Thus, returns from inside try/finally are not return jumps because they are
+/// intercepted by a block that contains the finally handler code.
+class ReturnJumpCollector extends JumpCollector {
+  bool isEmpty = true;
+  ir.Continuation get continuation => _continuation;
+  Environment environment = null;
+
+  /// Construct a return jump collector for a given return continuation.
+  ReturnJumpCollector(ir.Continuation continuation) : super.retrn(continuation);
+
+  void addJump(IrBuilder builder,
+      [ir.Primitive value, SourceInformation sourceInformation]) {
+    isEmpty = false;
+    builder.add(new ir.InvokeContinuation(continuation, <ir.Primitive>[value],
+        isEscapingTry: isEscapingTry,
+        sourceInformation: sourceInformation));
+    builder._current = null;
+  }
+}
+
 /// Function for building a node in the context of the current builder.
 typedef ir.Node BuildFunction(node);
 
 /// Function for building nodes in the context of the provided [builder].
 typedef ir.Node SubbuildFunction(IrBuilder builder);
 
 /// Mixin that provides encapsulated access to nested builders.
 abstract class IrBuilderMixin<N> {
   IrBuilder _irBuilder;
 
@@ skipping 58 matching lines @@
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
 
   /// The target of a return from the function.
   ///
   /// A null value indicates that the target is the function's return
   /// continuation.  Otherwise, when inside the try block of try/finally
   /// a return is intercepted to give a place to generate the finally code.
-  JumpCollector returnCollector = null;
+  JumpCollector returnCollector;
 
   /// Parameter holding the internal value of 'this' passed to the function.
   ///
   /// For nested functions, this is *not* captured receiver, but the function
   /// object itself.
   ir.Parameter thisParameter;
 
   /// If non-null, this refers to the receiver (`this`) in the enclosing method.
   ir.Primitive enclosingThis;
 
   final List<ir.Parameter> functionParameters = <ir.Parameter>[];
 
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
-  IrBuilderSharedState(this.program, this.constants, this.currentElement);
+  IrBuilderSharedState(this.program, this.constants, this.currentElement) {
+    returnCollector = new ReturnJumpCollector(returnContinuation);
+  }
 }
 
 class ThisParameterLocal implements Local {
   final ExecutableElement executableContext;
   ThisParameterLocal(this.executableContext);
   String get name => 'this';
   toString() => 'ThisParameterLocal($executableContext)';
 }
 
 /// The IR builder maintains an environment and an IR fragment.
@@ skipping 656 matching lines @@
         if (elseBuilder._root != null) _current = elseBuilder._current;
         environment = elseBuilder.environment;
       } else {
         _current = null;
       }
     } else {
       environment = join.environment;
     }
   }
 
-  void jumpTo(JumpCollector collector, [ir.Primitive value]) {
-    collector.addJump(this, value);
+  void jumpTo(JumpCollector collector,
+      [ir.Primitive value, SourceInformation sourceInformation]) {
+    collector.addJump(this, value, sourceInformation);
   }
 
   void addRecursiveContinuation(BackwardJumpCollector collector) {
     assert(environment.length == collector.environment.length);
     add(new ir.LetCont(collector.continuation,
             new ir.InvokeContinuation(collector.continuation,
                                       environment.index2value)));
     environment = collector.environment;
   }
 
@@ skipping 629 matching lines @@
     // variables are unboxed in the catch block and at the join point.
 
     void enterTry(IrBuilder builder) {
       // On entry to try of try/catch, update the builder's state to reflect the
       // variables that have been boxed.
       void interceptJump(JumpCollector collector) {
         collector.enterTry(variables.boxedOnEntry);
       }
       builder.state.breakCollectors.forEach(interceptJump);
       builder.state.continueCollectors.forEach(interceptJump);
+      interceptJump(builder.state.returnCollector);
     }
 
     void leaveTry(IrBuilder builder) {
       // On exit from try of try/catch, update the builder's state to reflect
       // the variables that are no longer boxed.
       void restoreJump(JumpCollector collector) {
         collector.leaveTry();
       }
       builder.state.breakCollectors.forEach(restoreJump);
       builder.state.continueCollectors.forEach(restoreJump);
+      restoreJump(builder.state.returnCollector);
     }
 
     List<ir.Parameter> buildCatch(IrBuilder builder,
                                   JumpCollector join) {
       // Translate the catch clauses.  Multiple clauses are translated as if
       // they were explicitly cascaded if/else type tests.
 
       // Handlers are always translated as having both exception and stack trace
       // parameters.  Multiple clauses do not have to use the same names for
       // them.  Choose the first of each as the name hint for the respective
@@ skipping 188 matching lines @@
   /// null.
   void buildReturn({ir.Primitive value, SourceInformation sourceInformation}) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
       value = buildNullConstant();
     }
-    if (state.returnCollector == null) {
-      add(new ir.InvokeContinuation(state.returnContinuation, [value],
-              sourceInformation: sourceInformation));
-      _current = null;
-    } else {
-      // Inside the try block of try/finally, all returns go to a join-point
-      // continuation that contains the finally code.  The return value is
-      // passed as an extra argument.
-      jumpTo(state.returnCollector, value);
-    }
+    jumpTo(state.returnCollector, value, sourceInformation);
   }
 
   /// Build a call to the closure conversion helper for the [Function] typed
   /// value in [value].
   ir.Primitive _convertDartClosure(ir.Primitive value, FunctionType type) {
     ir.Constant arity = buildIntegerConstant(type.computeArity());
     return buildStaticFunctionInvocation(
         program.closureConverter,
         CallStructure.TWO_ARGS,
         <ir.Primitive>[value, arity]);
@@ skipping 837 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }