Implement try/catch in the JS backend.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 // TODO(karlklose): share the [ParentVisitor].
 import '../../cps_ir/optimizers.dart';
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
-import '../../elements/elements.dart' show ClassElement, FieldElement, Element;
+import '../../elements/elements.dart'
+    show ClassElement, FieldElement, FunctionElement, Element;
 import '../../js_backend/codegen/glue.dart';
 import '../../dart2jslib.dart' show Selector, World;
 
 /// Rewrites the initial CPS IR to make Dart semantics explicit and inserts
 /// special nodes that respect JavaScript behavior.
 ///
 /// Performs the following rewrites:
 ///  - rewrite [IsTrue] in a [Branch] to do boolean conversion.

[asgerf, 2015/04/14 12:59:17]

Stale doc comment.

[Kevin Millikin (Google), 2015/04/15 07:52:22]

Thanks, updated.

 class UnsugarVisitor extends RecursiveVisitor {
   Glue _glue;
+  ParentVisitor _parentVisitor = new ParentVisitor();
 
   UnsugarVisitor(this._glue);
 
   void rewrite(FunctionDefinition function) {
     // Set all parent pointers.
-    new ParentVisitor().visit(function);
+    _parentVisitor.visit(function);
     visit(function);
   }
 
   @override
   visit(Node node) {
     Node result = node.accept(this);
     return result != null ? result : node;
   }
 
   Constant get trueConstant {
     return new Constant(
         new PrimitiveConstantExpression(
             new TrueConstantValue()));
   }
 
   void insertLetPrim(Primitive primitive, Expression node) {
     LetPrim let = new LetPrim(primitive);
     InteriorNode parent = node.parent;
     parent.body = let;
     let.body = node;
     node.parent = let;
     let.parent = parent;
   }
 
+  /// Insert a static call to [function] at the point of [node] with result
+  /// [result].
+  ///
+  /// Rewrite [node] to
+  ///
+  /// let cont continuation(result) = node
+  /// in invoke function arguments continuation
+  ///
+  /// The result parameter passed to this function because a common pattern is
+  /// to replace all uses of one of the arguments with the result.  To do that,
+  /// create a result parameter first, replace all uses of the arguments with
+  /// the result, and then insert the call with this function.

[asgerf, 2015/04/14 12:59:17]

The result parameter *is* passed ...

I don't see why we need the last comment, though. I think it's common enough to
tell a code generating function where to put the result.

[Kevin Millikin (Google), 2015/04/15 07:52:22]

Fair enough, I'll just remove that bit of the comment.

+  void insertStaticCall(FunctionElement function, List<Primitive> arguments,
+      Parameter result,
+      Expression node) {
+    InteriorNode parent = node.parent;
+    Continuation continuation = new Continuation([result]);
+    continuation.body = node;
+    _parentVisitor.processContinuation(continuation);
+
+    Selector selector = new Selector.fromElement(function);
+    // TODO(johnniwinther): Come up with an implementation of SourceInformation
+    // for calls such as this one that don't appear in the original source.
+    InvokeStatic invoke =
+        new InvokeStatic(function, selector, continuation, arguments, null);
+    _parentVisitor.processInvokeStatic(invoke);
+
+    LetCont letCont = new LetCont(continuation, invoke);
+    _parentVisitor.processLetCont(letCont);
+
+    parent.body = letCont;
+    letCont.parent = parent;
+  }
+
+  processLetHandler(LetHandler node) {
+    // BEFORE: Handlers have two parameters, exception and stack trace.
+    // AFTER: Handlers have a single parameter, which is unwrapped to get
+    // the exception and stack trace.
+    assert(node.handler.parameters.length == 2);
+    Parameter exceptionParameter = node.handler.parameters.first;
+    Parameter stackTraceParameter = node.handler.parameters.last;
+    Expression body = node.handler.body;
+    if (exceptionParameter.hasAtLeastOneUse ||
+        stackTraceParameter.hasAtLeastOneUse) {
+      Parameter exceptionValue = new Parameter(null);
+      exceptionValue.substituteFor(exceptionParameter);
+      insertStaticCall(_glue.getExceptionUnwrapper(), [exceptionParameter],
+          exceptionValue, body);
+
+      if (stackTraceParameter.hasAtLeastOneUse) {
+        Parameter stackTraceValue = new Parameter(null);
+        stackTraceValue.substituteFor(stackTraceParameter);
+        insertStaticCall(_glue.getTraceFromException(), [exceptionValue],
+            stackTraceValue, body);
+      }
+    }
+
+    assert(stackTraceParameter.hasNoUses);
+    node.handler.parameters.removeLast();
+  }
+
   processInvokeMethod(InvokeMethod node) {
     Selector selector = node.selector;
     // TODO(karlklose):  should we rewrite all selectors?
     if (!_glue.isInterceptedSelector(selector)) return;
 
     Primitive receiver = node.receiver.definition;
     Set<ClassElement> interceptedClasses =
         _glue.getInterceptedClassesOn(selector);
     _glue.registerSpecializedGetInterceptor(interceptedClasses);
 
@@ skipping 29 matching lines @@
         new LetPrim(i,
             new Branch(new IsTrue(i),
                 node.trueContinuation.definition,
                 node.falseContinuation.definition)));
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 }