dart2js cps: Ensure definitions are specialized before their uses.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../util/util.dart' show CURRENT_ELEMENT_SPANNABLE;
@@ skipping 36 matching lines @@
 
   final Map<cps_ir.Primitive, Variable> primitive2variable =
       <cps_ir.Primitive, Variable>{};
   final Map<cps_ir.MutableVariable, Variable> mutable2variable =
       <cps_ir.MutableVariable, Variable>{};
 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<cps_ir.Continuation, Label> labels = <cps_ir.Continuation, Label>{};
 
-  /// A stack of singly-used labels that can be safely inlined at their use
-  /// site.
-  ///
-  /// Code for continuations with exactly one use is inlined at the use site.
-  /// This is not safe if the code is moved inside the scope of an exception
-  /// handler (i.e., into a try block).  We keep a stack of singly-referenced
-  /// continuations that are in scope without crossing a binding for a handler.
-  List<cps_ir.Continuation> safeForInlining = <cps_ir.Continuation>[];
-
   ExecutableElement currentElement;
   /// The 'this' Parameter for currentElement or the enclosing method.
   cps_ir.Parameter thisParameter;
   cps_ir.Continuation returnContinuation;
 
   Builder parent;
 
   Builder(this.internalError, [this.parent]);
 
   Builder createInnerBuilder() {
@@ skipping 235 matching lines @@
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
     Expression value = visit(node.primitive);
     return Assign.makeStatement(variable, value, visit(node.body));
   }
 
   Statement visitLetCont(cps_ir.LetCont node) {
     // Introduce labels for continuations that need them.
-    int safeForInliningLengthOnEntry = safeForInlining.length;
     for (cps_ir.Continuation continuation in node.continuations) {
       if (continuation.hasMultipleUses || continuation.isRecursive) {
         labels[continuation] = new Label();
-      } else {
-        safeForInlining.add(continuation);
       }
     }
     Statement body = visit(node.body);
-    safeForInlining.length = safeForInliningLengthOnEntry;
     // Continuations are bound at the same level, but they have to be
     // translated as if nested.  This is because the body can invoke any
     // of them from anywhere, so it must be nested inside all of them.
     //
     // The continuation bodies are not always translated directly here because
     // they may have been already translated:
     //   * For singly-used continuations, the continuation's body is
     //     translated at the site of the continuation invocation.
     //   * For recursive continuations, there is a single non-recursive
     //     invocation.  The continuation's body is translated at the site
     //     of the non-recursive continuation invocation.
     // See visitInvokeContinuation for the implementation.
     Statement current = body;
     for (cps_ir.Continuation continuation in node.continuations.reversed) {
       Label label = labels[continuation];
       if (label != null && !continuation.isRecursive) {
         current =
             new LabeledStatement(label, current, visit(continuation.body));
       }
     }
     return current;
   }
 
   Statement visitLetHandler(cps_ir.LetHandler node) {
-    List<cps_ir.Continuation> saved = safeForInlining;
-    safeForInlining = <cps_ir.Continuation>[];
     Statement tryBody = visit(node.body);
-    safeForInlining = saved;
     List<Variable> catchParameters =
         node.handler.parameters.map(getVariable).toList();
     Statement catchBody = visit(node.handler.body);
     return new Try(tryBody, catchParameters, catchBody);
   }
 
   Statement visitInvokeStatic(cps_ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments,
@@ skipping 114 matching lines @@
             //     - There is a single non-recursive invocation.  Translate
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(labels[cont])
                   : new WhileTrue(labels[cont], visit(cont.body));
             } else {
               if (cont.hasExactlyOneUse) {
-                if (safeForInlining.contains(cont)) {
+                if (!node.isEscapingTry) {
                   return visit(cont.body);
                 }
                 labels[cont] = new Label();
               }
               return new Break(labels[cont]);
             }
           });
     }
   }
 
@@ skipping 119 matching lines @@
       return new ForeignStatement(
           node.codeTemplate,
           node.type,
           node.arguments.map(getVariableUse).toList(growable: false),
           node.nativeBehavior,
           node.dependency);
     }
   }
 }