dart2js cps: Rewrite mutable variables to continuation parameters.

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 '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 175 matching lines @@
     for (Iterable<LocalVariableElement> boxedOnEntry in _boxedTryVariables) {
       for (LocalVariableElement variable in boxedOnEntry) {
         assert(builder.isInMutableVariable(variable));
         ir.Primitive value = builder.buildLocalVariableGet(variable);
         builder.environment.update(variable, value);
       }
     }
   }
 
   /// True if a jump inserted now will escape from a try block.
-  /// 
+  ///
   /// Concretely, this is true when [enterTry] has been called without
   /// its corresponding [leaveTry] call.
   bool get isEscapingTry => _boxedTryVariables.isNotEmpty;
 }
 
 /// A class to collect 'forward' jumps.
 ///
 /// A forward jump to a continuation in the sense of the CPS translation is
 /// a jump where the jump is emitted before any code in the body of the
 /// continuation is translated.  They have the property that continuation
@@ skipping 332 matching lines @@
         mutableVariables);
   }
 
   /// True if [local] should currently be accessed from a [ir.MutableVariable].
   bool isInMutableVariable(Local local) {
     return mutableVariables.containsKey(local);
   }
 
   /// Creates a [ir.MutableVariable] for the given local.
   void makeMutableVariable(Local local) {
-    mutableVariables[local] = new ir.MutableVariable(local);
+    mutableVariables[local] =
+        new ir.MutableVariable(local);
   }
 
   /// Remove an [ir.MutableVariable] for a local.
   ///
   /// Subsequent access to the local will be direct rather than through the
   /// mutable variable.
   void removeMutableVariable(Local local) {
     mutableVariables.remove(local);
   }
 
@@ skipping 1872 matching lines @@
   ir.Primitive buildThis() {
     if (state.enclosingThis != null) return state.enclosingThis;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
   ir.Primitive buildFieldGet(ir.Primitive receiver, FieldElement target) {
     return addPrimitive(new ir.GetField(receiver, target));
   }
 
-  void buildFieldSet(ir.Primitive receiver, 
-                     FieldElement target, 
+  void buildFieldSet(ir.Primitive receiver,
+                     FieldElement target,
                      ir.Primitive value) {
     add(new ir.SetField(receiver, target, value));
   }
 
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
     add(new ir.SetField(buildThis(), target, value));
@@ skipping 120 matching lines @@
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
 
   ir.Primitive buildForeignCode(js.Template codeTemplate,
                                 List<ir.Primitive> arguments,
                                 NativeBehavior behavior,
                                 {Element dependency}) {
     types.TypeMask type = program.getTypeMaskForForeign(behavior);
-    if (codeTemplate.isExpression) {
-      return _continueWithExpression((k) => new ir.ForeignCode(
+    ir.Primitive result = _continueWithExpression((k) => new ir.ForeignCode(
         codeTemplate,
         type,
         arguments,
         behavior,
-        continuation: k,
+        k,
         dependency: dependency));
-    } else {
-      assert(isOpen);
-      add(new ir.ForeignCode(codeTemplate, type, arguments, behavior,
-          dependency: dependency));
+    if (!codeTemplate.isExpression) {
+      // Close the term if this is a "throw" expression.
+      add(new ir.Unreachable());
       _current = null;
-      return null;
     }
+    return result;
   }
 
   /// Creates a type test or type cast of [value] against [type].
   ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
                                  {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
 
     type = program.unaliasType(type);
@@ skipping 147 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);
 }