dart2dart: Implementation of simple try/catch.

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;
 import '../elements/elements.dart';
@@ skipping 542 matching lines @@
   Expression expression;
 
   ExpressionStatement(this.expression, this.next);
 
   accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitExpressionStatement(this, arg);
   }
 }
 
+// TODO(kmillikin): Do we want this 'TryStatement'?  Other than
+// LabeledStatement and EmptyStatement, the statement class names are not
+// suffixed with 'Statement'.
+class TryStatement extends Statement {

[floitsch, 2015/02/16 14:54:07]

Try should be good enough.

[Kevin Millikin (Google), 2015/02/25 11:06:36]

Done.

+  Statement tryBody;
+  List<Variable> catchParameters;
+  Statement catchBody;
+
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  TryStatement(this.tryBody, this.catchParameters, this.catchBody);
+
+  accept(StatementVisitor visitor) => visitor.visitTryStatement(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitTryStatement(this, arg);
+  }
+}
+
 abstract class ExecutableDefinition {
   ExecutableElement get element;
   Statement body;
 
   applyPass(Pass pass);
 }
 
 class FieldDefinition extends Node implements ExecutableDefinition {
   final FieldElement element;
   // The `body` of a field is its initializer.
@@ skipping 178 matching lines @@
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return 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 visitExpressionStatement(ExpressionStatement node);
+  S visitTryStatement(TryStatement node);
   S visitSetField(SetField node);
 }
 
 abstract class StatementVisitor1<S, A> {
   S visitStatement(Statement s, A arg) => s.accept1(this, arg);
   S visitLabeledStatement(LabeledStatement node, A arg);
   S visitAssign(Assign node, A arg);
   S visitReturn(Return 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 visitExpressionStatement(ExpressionStatement node, A arg);
+  S visitTryStatement(TryStatement node, A arg);
   S visitSetField(SetField node, A arg);
 }
 
 abstract class Visitor<S, E> implements ExpressionVisitor<E>,
                                         StatementVisitor<S> {
    E visitExpression(Expression e) => e.accept(this);
    S visitStatement(Statement s) => s.accept(this);
 }
 
 abstract class Visitor1<S, E, A> implements ExpressionVisitor1<E, A>,
@@ skipping 109 matching lines @@
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 
+  visitTryStatement(TryStatement node) {
+    visitStatement(node.tryBody);
+    visitStatement(node.catchBody);
+  }
+
   visitFieldInitializer(FieldInitializer node) {
     visitStatement(node.body);
   }
 
   visitSuperInitializer(SuperInitializer node) {
     node.arguments.forEach(visitStatement);
   }
 
   visitGetField(GetField node) {
     visitExpression(node.object);
   }
 
   visitSetField(SetField node) {
     visitExpression(node.object);
     visitExpression(node.value);
     visitStatement(node.next);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
   }
 }