CPS implementation of throw and rethrow.

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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 412 matching lines @@
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
 
   ConcatenateStrings(List<Primitive> args, Continuation cont)
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
+/// Throw a value.
+///
+/// Throw is an expression, i.e., it always occurs in tail position with
+/// respect to a body or expression.
+class Throw extends Expression {
+  Reference<Primitive> value;
+
+  Throw(Primitive value) : value = new Reference<Primitive>(value);
+
+  accept(Visitor visitor) => visitor.visitThrow(this);
+}
+
+/// Rethrow
+///
+/// Rethrow can only occur inside a continuation bound by [LetHandler].  It
+/// implicitly throws the exception parameter of the enclosing handler with
+/// the same stack trace as the enclosing handler.
+class Rethrow extends Expression {
+  accept(Visitor visitor) => visitor.visitRethrow(this);
+}
+
+/// A throw occurring in non-tail position.
+///
+/// The CPS translation of an expression produces a primitive as the value
+/// of the expression.  For convenience in the implementation of the
+/// translation, a [NonTailThrow] is used as that value.  A cleanup pass
+/// removes these and replaces them with [Throw] expressions.
+class NonTailThrow extends Primitive {
+  final Reference<Primitive> value;
+
+  NonTailThrow(Primitive value) : value = new Reference<Primitive>(value);
+
+  accept(Visitor visitor) => visitor.visitNonTailThrow(this);
+}
+
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutableVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutableVariable extends Primitive {
   final Reference<MutableVariable> variable;
 
@@ skipping 500 matching lines @@
   T visitLetPrim(LetPrim node);
   T visitLetCont(LetCont node);
   T visitLetHandler(LetHandler node);
   T visitLetMutable(LetMutable node);
   T visitInvokeContinuation(InvokeContinuation node);
   T visitInvokeStatic(InvokeStatic node);
   T visitInvokeMethod(InvokeMethod node);
   T visitInvokeMethodDirectly(InvokeMethodDirectly node);
   T visitInvokeConstructor(InvokeConstructor node);
   T visitConcatenateStrings(ConcatenateStrings node);
+  T visitThrow(Throw node);
+  T visitRethrow(Rethrow node);
   T visitBranch(Branch node);
   T visitTypeOperator(TypeOperator node);
   T visitSetMutableVariable(SetMutableVariable node);
   T visitDeclareFunction(DeclareFunction node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
   T visitReifyTypeVar(ReifyTypeVar node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutableVariable(GetMutableVariable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
+  T visitNonTailThrow(NonTailThrow node);
 
   // JavaScript specific nodes.
 
   // Conditions.
   T visitIsTrue(IsTrue node);
 
   // Expressions.
   T visitSetField(SetField node);
 
   // Definitions.
@@ skipping 134 matching lines @@
     node.arguments.forEach(processReference);
   }
 
   processConcatenateStrings(ConcatenateStrings node) {}
   visitConcatenateStrings(ConcatenateStrings node) {
     processConcatenateStrings(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
+  processThrow(Throw node) {}
+  visitThrow(Throw node) {
+    processThrow(node);
+    processReference(node.value);
+  }
+
+  processRethrow(Rethrow node) {}
+  visitRethrow(Rethrow node) {
+    processRethrow(node);
+  }
+
   processBranch(Branch node) {}
   visitBranch(Branch node) {
     processBranch(node);
     processReference(node.trueContinuation);
     processReference(node.falseContinuation);
     visit(node.condition);
   }
 
   processTypeOperator(TypeOperator node) {}
   visitTypeOperator(TypeOperator node) {
@@ skipping 29 matching lines @@
   processLiteralMap(LiteralMap node) {}
   visitLiteralMap(LiteralMap node) {
     processLiteralMap(node);
     for (LiteralMapEntry entry in node.entries) {
       processReference(entry.key);
       processReference(entry.value);
     }
   }
 
   processConstant(Constant node) {}
-  visitConstant(Constant node) => processConstant(node);
+  visitConstant(Constant node)  {
+    processConstant(node);
+  }
 
   processReifyTypeVar(ReifyTypeVar node) {}
-  visitReifyTypeVar(ReifyTypeVar node) => processReifyTypeVar(node);
+  visitReifyTypeVar(ReifyTypeVar node) {
+    processReifyTypeVar(node);
+  }
 
   processCreateFunction(CreateFunction node) {}
   visitCreateFunction(CreateFunction node) {
     processCreateFunction(node);
     visit(node.definition);
   }
 
   processMutableVariable(node) {}
   visitMutableVariable(MutableVariable node) {
     processMutableVariable(node);
   }
 
   processGetMutableVariable(GetMutableVariable node) {}
   visitGetMutableVariable(GetMutableVariable node) {
     processGetMutableVariable(node);
     processReference(node.variable);
   }
 
   processParameter(Parameter node) {}
-  visitParameter(Parameter node) => processParameter(node);
+  visitParameter(Parameter node) {
+    processParameter(node);
+  }
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
     if (node.body != null) visit(node.body);
   }
 
   // Conditions.
 
@@ skipping 53 matching lines @@
   visitReadTypeVariable(ReadTypeVariable node) {
     processReadTypeVariable(node);
     processReference(node.target);
   }
 
   processTypeExpression(TypeExpression node) {}
   visitTypeExpression(TypeExpression node) {
     processTypeExpression(node);
     node.arguments.forEach(processReference);
   }
+
+  processNonTailThrow(NonTailThrow node) {}
+  visitNonTailThrow(NonTailThrow node) {
+    processNonTailThrow(node);
+    processReference(node.value);
+  }
 }