dart2dart: Implementation of simple try/catch.

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 136 matching lines @@
   Expression plug(Expression expr) {
     assert(continuations != null &&
            continuations.isNotEmpty &&
            continuations.first.body == null);
     return continuations.first.body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetCont(this);
 }
 
+// Binding an exception handler.
+//
+// let handler h(v0, v1) = E0 in E1
+//
+// The handler is a two-argument (exception, stack trace) continuation which
+// is implicitly the error continuation of all the code in its body E1.
+// [LetHandler] differs from a [LetCont] binding in that it (1) has the
+// runtime semantics of pushing/popping a handler from the dynamic exception
+// handler stack and (2) it does not have any explicit invocations.
+class LetHandler extends Expression implements InteriorNode {
+  Continuation handler;
+  Expression body;
+
+  LetHandler(this.handler, this.body);
+
+  accept(Visitor visitor) => visitor.visitLetHandler(this);
+}
+
 /// Binding mutable variables.
 ///
 /// let mutable v = P in E
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  They are therefore not [Primitive]s and not bound by [LetPrim]
 /// to prevent unrestricted use of references to them.  During one-pass
 /// construction, a [LetMutable] with an empty body is use to represent the
 /// one-hole context 'let mutable v = P in []'.
 class LetMutable extends Expression implements InteriorNode {
@@ skipping 699 matching lines @@
   }
 
   // Initializers
   T visitInitializer(Initializer node) => visitNode(node);
   T visitFieldInitializer(FieldInitializer node) => visitInitializer(node);
   T visitSuperInitializer(SuperInitializer node) => visitInitializer(node);
 
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
+  T visitLetHandler(LetHandler node) => visitExpression(node);
   T visitLetMutable(LetMutable node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeMethodDirectly(InvokeMethodDirectly node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitTypeOperator(TypeOperator node) => visitExpression(node);
   T visitSetMutableVariable(SetMutableVariable node) => visitExpression(node);
@@ skipping 92 matching lines @@
     visit(node.body);
   }
 
   processLetCont(LetCont node) {}
   visitLetCont(LetCont node) {
     processLetCont(node);
     node.continuations.forEach(visit);
     visit(node.body);
   }
 
+  processLetHandler(LetHandler node) {}
+  visitLetHandler(LetHandler node) {
+    processLetHandler(node);
+    visit(node.handler);
+    visit(node.body);
+  }
+
   processLetMutable(LetMutable node) {}
   visitLetMutable(LetMutable node) {
     processLetMutable(node);
     visit(node.variable);
     processReference(node.value);
     visit(node.body);
   }
 
   processInvokeStatic(InvokeStatic node) {}
   visitInvokeStatic(InvokeStatic node) {
@@ skipping 274 matching lines @@
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
     node.continuations.forEach(visit);
     visit(node.body);
   }
 
+  void visitLetHandler(LetHandler node) {
+    visit(node.handler);
+    // Handler parameters that were not used in the handler body will not have
+    // had register indexes assigned.  Assign them here, otherwise they will
+    // be eliminated later and they should not be (i.e., a catch clause that
+    // does not use the exception parameter should not have the exception
+    // parameter eliminated, because it would not be well-formed anymore).
+    // In any case release the parameter indexes because the parameters are
+    // not live in the try block.
+    node.handler.parameters.forEach((Parameter parameter) {
+      allocate(parameter);
+      release(parameter);
+    });
+    visit(node.body);
+  }
+
   void visitLetMutable(LetMutable node) {
     visit(node.body);
     visitReference(node.value);
   }
 
   void visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeContinuation(InvokeContinuation node) {
@@ skipping 103 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }