CPS implementation of throw and rethrow.

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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 1746 matching lines @@
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     // TODO(kmillikin): Handle multiple catch clauses.
     assert(catchClauseInfos.length == 1);
     for (CatchClauseInfo catchClauseInfo in catchClauseInfos) {
       LocalVariableElement exceptionVariable =
           catchClauseInfo.exceptionVariable;
       ir.Parameter exceptionParameter = new ir.Parameter(exceptionVariable);
-      catchBuilder.environment.extend(exceptionVariable, exceptionParameter);
+      catchBuilder.declareLocalVariable(exceptionVariable,

[Kevin Millikin (Google), 2015/04/17 09:52:10]

It is necessary to 'declare' these parameters in case they are captured by a
closure.  This helper function will emit the backend-specific boxing code in
case they are captured.

+                                        initialValue: exceptionParameter);
       ir.Parameter traceParameter;
       LocalVariableElement stackTraceVariable =
           catchClauseInfo.stackTraceVariable;
       if (stackTraceVariable != null) {
         traceParameter = new ir.Parameter(stackTraceVariable);
-        catchBuilder.environment.extend(stackTraceVariable, traceParameter);
+        catchBuilder.declareLocalVariable(stackTraceVariable,
+                                          initialValue: traceParameter);
       } else {
         // Use a dummy continuation parameter for the stack trace parameter.
         // This will ensure that all handlers have two parameters and so they
         // can be treated uniformly.
         traceParameter = new ir.Parameter(null);
       }
       catchClauseInfo.buildCatchBlock(catchBuilder);
       if (catchBuilder.isOpen) catchBuilder.jumpTo(join);
       List<ir.Parameter> catchParameters =
           <ir.Parameter>[exceptionParameter, traceParameter];
@@ skipping 90 matching lines @@
     assert(isOpen);
     for (JumpCollector collector in collectors) {
       if (target == collector.target) {
         jumpTo(collector);
         return true;
       }
     }
     return false;
   }
 
+  void buildThrow(ir.Primitive value) {
+    assert(isOpen);
+    add(new ir.Throw(value));
+    _current = null;
+  }
+
+  ir.Primitive buildNonTailThrow(ir.Primitive value) {
+    assert(isOpen);
+    return addPrimitive(new ir.NonTailThrow(value));
+  }
+
+  void buildRethrow() {
+    assert(isOpen);
+    add(new ir.Rethrow());

[asgerf, 2015/04/17 10:33:01]

I would imagine this needs a reference to the exception variable in JS.

[Kevin Millikin (Google), 2015/04/17 11:17:07]

It will be translated by the unsugar pass to 'throw e' where e is that variable.

+    _current = null;
+  }
+
   /// Create a negation of [condition].
   ir.Primitive buildNegation(ir.Primitive condition) {
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
@@ skipping 746 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }