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.

[karlklose, 2015/02/16 10:15:48]

Make this a DartDoc comment ('///'), and maybe put the TODO outside in a normal
comment.

[Kevin Millikin (Google), 2015/02/24 11:59:25]

OK.  But I'll just address the TODO before submitting, it was a "draft" TODO :)

+//
+// let handler h(v0 ...) = E0 in E1
+//
+// The handler is a continuation which is implicitly the error continuation of
+// all the code in its body E1.  The handler parameters represent the
+// exception and possibly the stack trace.  (TODO(kmillikin): should we just
+// ensure that they always have two parameters?)  It differs from let cont
+// binding a call continuation 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 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 695 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);
+    // Assign indices to unused handler parameters, because they should
+    // not be eliminated.  Then release all of them because they are not
+    // live in the try block.
+    node.handler.parameters.forEach((p) {

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

We tend to type (even for closures) and not to abbreviate.

[Kevin Millikin (Google), 2015/02/24 11:59:25]

Done.

+      allocate(p);
+      release(p);

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

I'm not sure I understand (even with the comment). Maybe create a function that
does the combination and has a clearer name?

[Kevin Millikin (Google), 2015/02/24 11:59:25]

The clearest name I can think of is "AllocateThenRelease" :)  I think a comment
here would have to describe both this algorithm and also what we do with the
result to make sense, and this doesn't seem like the right place for that.

We probably just need comments for functions allocate and release.

====
What's happening here is that this is a backward pass over the CPS term and it
assigns indexes to used variables when it sees their last use, then releases
those indexes when it passes their definitions (moving backwards) because the
index can be used for another variable whose last use occurs before this one's
definition.

Variables that don't get assigned an index must not have had any uses, and so
they are eliminated from the output.

So: after visiting the catch block, if the catch parameters are unused they
still need to be assigned indexes to ensure that they are not eliminated.  And
in any case, they need to be released so that their index can be possibly
reused.

I've rewritten the comment, it's longer but I'm not sure it's any better.

+    });
+    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);
   }
 }