dart2js: Remove rethrow from the CPS and Tree IRs.

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/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 589 matching lines @@
 
   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 of an exception.
-///
-/// Rethrow can only occur nested inside a catch block.  It implicitly throws
-/// the block's caught exception value without changing the caught stack
-/// trace.  It does not have a successor statement.
-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 438 matching lines @@
   E visitGetIndex(GetIndex node, A arg);
   E visitSetIndex(SetIndex node, A arg);
   E visitAwait(Await 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 visitFor(For node);
   S visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
   S visitUnreachable(Unreachable node);
   S visitForeignStatement(ForeignStatement node);
   S visitYield(Yield node);
   S visitNullCheck(NullCheck 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 visitFor(For node, A arg);
   S visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
   S visitUnreachable(Unreachable node, A arg);
   S visitForeignStatement(ForeignStatement node, A arg);
   S visitYield(Yield node, A arg);
@@ skipping 78 matching lines @@
   }
 
   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 219 matching lines @@
   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 180 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }