Implement try/catch in the JS backend.

In the CPS IR, exception handlers initially have two parameters for
the exception and the stack trace.  In JavaScript:

1. Unwrap the caught value to get the exception that was thrown and
   use the unwrapped value in place of the exception parameter.

2. Get the stack trace from the (unwrapped) exception that was thrown.

3. Remove the stack trace parameter.

BUG=
[email protected]

Review URL: https://codereview.chromium.org//1083663005

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@45152 260f80e4-7a28-3924-810f-c04153c831b5

Author: [email protected]

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

@@ -490,10 +490,6 @@ abstract class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
   }
 
   visitTryStatement(ast.TryStatement node) {
-    // Try/catch is not yet implemented in the JS backend.
-    if (tryStatements == null) {
-      return giveup(node, 'try/catch in the JS backend');
-    }
     // Multiple catch blocks are not yet implemented.
     if (node.catchBlocks.isEmpty ||
         node.catchBlocks.nodes.tail == null) {
@@ -2560,6 +2556,17 @@ class JsIrBuilderVisitor extends IrBuilderVisitor {
     return parameters;
   }
 
+  DartCapturedVariables _analyzeCapturedVariables(ast.Node node) {
+    DartCapturedVariables variables = new DartCapturedVariables(elements);
+    try {
+      variables.analyze(node);
+    } catch (e) {
+      bailoutMessage = variables.bailoutMessage;
+      rethrow;
+    }
+    return variables;
+  }
+
   /// Builds the IR for the body of a constructor.
   ///
   /// This function is invoked from one or more "factory" constructors built by
@@ -2572,6 +2579,15 @@ class JsIrBuilderVisitor extends IrBuilderVisitor {
         node,
         elements);
 
+    // We compute variables boxed in mutable variables on entry to each try
+    // block, not including variables captured by a closure (which are boxed
+    // in the heap).  This duplicates some of the work of closure conversion
+    // without directly using the results.  This duplication is wasteful and
+    // error-prone.
+    // TODO(kmillikin): We should combine closure conversion and try/catch
+    // variable analysis in some way.
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
+    tryStatements = variables.tryStatements;
     JsIrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
@@ -2594,6 +2610,8 @@ class JsIrBuilderVisitor extends IrBuilderVisitor {
         element,
         node,
         elements);
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
+    tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

@@ -37,11 +37,12 @@ abstract class Definition<T extends Definition<T>> extends Node {
 
   bool get hasAtMostOneUse  => firstRef == null || firstRef.next == null;
   bool get hasExactlyOneUse => firstRef != null && firstRef.next == null;
+  bool get hasNoUses => firstRef == null;
   bool get hasAtLeastOneUse => firstRef != null;
   bool get hasMultipleUses  => !hasAtMostOneUse;
 
   void substituteFor(Definition<T> other) {
-    if (other.firstRef == null) return;
+    if (other.hasNoUses) return;
     Reference<T> previous, current = other.firstRef;
     do {
       current.definition = this;
@@ -51,6 +52,7 @@ abstract class Definition<T extends Definition<T>> extends Node {
     previous.next = firstRef;
     if (firstRef != null) firstRef.previous = previous;
     firstRef = other.firstRef;
+    other.firstRef = null;
   }
 }
 

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

@@ -425,13 +425,13 @@ class CodeGenerator extends tree_ir.StatementVisitor
   @override
   void visitIf(tree_ir.If node) {
     accumulator.add(new js.If(visitExpression(node.condition),
-                              buildBody(node.thenStatement),
-                              buildBody(node.elseStatement)));
+                              buildBodyStatement(node.thenStatement),
+                              buildBodyStatement(node.elseStatement)));
   }
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
-    accumulator.add(buildLabeled(() => buildBody(node.body),
+    accumulator.add(buildLabeled(() => buildBodyStatement(node.body),
                                  node.label,
                                  node.next));
     visitStatement(node.next);
@@ -476,20 +476,29 @@ class CodeGenerator extends tree_ir.StatementVisitor
   }
 
   /// Builds a nested statement.
-  js.Statement buildBody(tree_ir.Statement statement) {
+  js.Statement buildBodyStatement(tree_ir.Statement statement) {
     List<js.Statement> savedAccumulator = accumulator;
-    accumulator = new List<js.Statement>();
+    accumulator = <js.Statement>[];
     visitStatement(statement);
     js.Statement result = _bodyAsStatement();
     accumulator = savedAccumulator;
     return result;
   }
 
+  js.Block buildBodyBlock(tree_ir.Statement statement) {
+    List<js.Statement> savedAccumulator = accumulator;
+    accumulator = <js.Statement>[];
+    visitStatement(statement);
+    js.Statement result = new js.Block(accumulator);
+    accumulator = savedAccumulator;
+    return result;
+  }
+
   js.Statement buildWhile(js.Expression condition,
                           tree_ir.Statement body,
                           tree_ir.Label label,
                           tree_ir.Statement fallthroughStatement) {
-    return buildLabeled(() => new js.While(condition, buildBody(body)),
+    return buildLabeled(() => new js.While(condition, buildBodyStatement(body)),
                         label,
                         fallthroughStatement);
   }
@@ -517,8 +526,13 @@ class CodeGenerator extends tree_ir.StatementVisitor
 
   @override
   void visitTry(tree_ir.Try node) {
-    // TODO(kmillikin): implement TryStatement.
-    return giveup(node);
+    js.Block tryBlock = buildBodyBlock(node.tryBody);
+    tree_ir.Variable exceptionVariable = node.catchParameters.first;
+    js.VariableDeclaration exceptionParameter =
+        new js.VariableDeclaration(getVariableName(exceptionVariable));
+    js.Block catchBlock = buildBodyBlock(node.catchBody);
+    js.Catch catchPart = new js.Catch(exceptionParameter, catchBlock);
+    accumulator.add(new js.Try(tryBlock, catchPart, null));
   }
 
   @override

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

@@ -121,6 +121,14 @@ class Glue {
         _backend.namer.globalObjectFor(_backend.interceptorsLibrary));
   }
 
+  FunctionElement getExceptionUnwrapper() {
+    return _backend.getExceptionUnwrapper();
+  }
+
+  FunctionElement getTraceFromException() {
+    return _backend.getTraceFromException();
+  }
+
   FunctionElement getCreateRuntimeType() {
     return _backend.getCreateRuntimeType();
   }

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

@@ -6,7 +6,8 @@ import '../../cps_ir/cps_ir_nodes.dart';
 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;
 
@@ -15,14 +16,16 @@ import '../../dart2jslib.dart' show Selector, World;
 ///
 /// Performs the following rewrites:
 ///  - rewrite [IsTrue] in a [Branch] to do boolean conversion.
+///  - converts two-parameter exception handlers to one-parameter ones.
 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);
   }
 
@@ -47,6 +50,62 @@ class UnsugarVisitor extends RecursiveVisitor {
     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
+  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?