CPS implementation of throw and rethrow.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, GenericType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 564 matching lines @@
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
   accept(StatementVisitor visitor) => visitor.visitReturn(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitReturn(this, arg);
 }
 
+/// A throw statement.
+///
+/// In the Tree IR, throw is a statement (like JavaScript and unlike Dart).
+class Throw extends Statement {
+  Expression value;
+
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  Throw(this.value);
+
+  accept(StatementVisitor visitor) => visitor.visitThrow(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitThrow(this, arg);
+}
+
+/// A rethrow exit from the function.
+///
+/// Rethrow can only occur nested inside a catch block.  It implicitly throws
+/// the block's caught exception value without changing the caught stack trace.
+class Rethrow extends Statement {
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  Rethrow();
+
+  accept(StatementVisitor visitor) => visitor.visitRethrow(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitRethrow(this, arg);
+}
+
 /**
  * A conditional branch based on the true value of an [Expression].
  */
 class If extends Statement {
   Expression condition;
   Statement thenStatement;
   Statement elseStatement;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
@@ skipping 346 matching lines @@
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
   E visitTypeExpression(TypeExpression node, A arg);
   E visitSetField(SetField node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitReturn(Return node);
+  S visitThrow(Throw node);
+  S visitRethrow(Rethrow node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
   S visitWhileCondition(WhileCondition node);
   S visitFunctionDeclaration(FunctionDeclaration node);
   S visitVariableDeclaration(VariableDeclaration node);
   S visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
 }
 
 abstract class StatementVisitor1<S, A> {
   S visitStatement(Statement node, A arg) => node.accept1(this, arg);
   S visitLabeledStatement(LabeledStatement node, A arg);
   S visitReturn(Return node, A arg);
+  S visitThrow(Throw node, A arg);
+  S visitRethrow(Rethrow node, A arg);
   S visitBreak(Break node, A arg);
   S visitContinue(Continue node, A arg);
   S visitIf(If node, A arg);
   S visitWhileTrue(WhileTrue node, A arg);
   S visitWhileCondition(WhileCondition node, A arg);
   S visitFunctionDeclaration(FunctionDeclaration node, A arg);
   S visitVariableDeclaration(VariableDeclaration node, A arg);
   S visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
 }
@@ skipping 111 matching lines @@
 
   visitLabeledStatement(LabeledStatement node) {
     visitStatement(node.body);
     visitStatement(node.next);
   }
 
   visitReturn(Return node) {
     visitExpression(node.value);
   }
 
+  visitThrow(Throw node) {
+    visitExpression(node.value);
+  }
+
+  visitRethrow(Rethrow node) {}
+
   visitBreak(Break node) {}
 
   visitContinue(Continue node) {}
 
   visitIf(If node) {
     visitExpression(node.condition);
     visitStatement(node.thenStatement);
     visitStatement(node.elseStatement);
   }
 
@@ skipping 159 matching lines @@
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
   visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
+  visitThrow(Throw node) {
+    node.value = visitExpression(node.value);
+    return node;
+  }
+
+  visitRethrow(Rethrow node) => node;
+
   visitBreak(Break node) => node;
 
   visitContinue(Continue node) => node;
 
   visitIf(If node) {
     node.condition = visitExpression(node.condition);
     node.thenStatement = visitStatement(node.thenStatement);
     node.elseStatement = visitStatement(node.elseStatement);
     return node;
   }
@@ skipping 54 matching lines @@
   visitReadTypeVariable(ReadTypeVariable node) {
     node.target = visitExpression(node.target);
     return node;
   }
 
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }