dart2js cps: Ensure definitions are specialized before their uses.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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_nodes;
 
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../types/types.dart' show TypeMask;
@@ skipping 550 matching lines @@
 
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends Expression {
   Reference<Continuation> continuation;
   List<Reference<Primitive>> arguments;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
+  /// True if this invocation escapes from the body of a [LetHandler]
+  /// (i.e. a try block). Notably, such an invocation cannot be inlined.
+  bool isEscapingTry;
+
   InvokeContinuation(Continuation cont, List<Primitive> args,
-                     {this.isRecursive: false})
+                     {this.isRecursive: false,
+                      this.isEscapingTry: false})
       : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(cont.parameters == null || cont.parameters.length == args.length);
     if (isRecursive) cont.isRecursive = true;
   }
 
   /// A continuation invocation whose target and arguments will be filled
   /// in later.
   ///
   /// Used as a placeholder for a jump whose target is not yet created
   /// (e.g., in the translation of break and continue).
-  InvokeContinuation.uninitialized({this.isRecursive: false})
+  InvokeContinuation.uninitialized({this.isRecursive: false, 
+                                    this.isEscapingTry: false})
       : continuation = null,
         arguments = null;
 
   accept(Visitor visitor) => visitor.visitInvokeContinuation(this);
 }
 
 /// The base class of things which can be tested and branched on.
 abstract class Condition extends Node {
 }
 
@@ skipping 295 matching lines @@
   // gives constant-time access to the continuation from the parent.
   int parent_index;
 
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive;
 
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters, {this.isRecursive: false});
 
-  Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
+  Continuation.retrn() 
+    : parameters = <Parameter>[new Parameter(null)],
+      isRecursive = false;
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
 /// Identifies a mutable variable.
 class MutableVariable extends Definition {
   Entity hint;
 
   MutableVariable(this.hint);
 
@@ skipping 430 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }