dart2dart: Implementation of simple try/catch.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 433 matching lines @@
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
     irBuilder.buildReturn(build(node.expression));
     return null;
   }
 
+  ir.Primitive visitTryStatement(ast.TryStatement node) {
+    assert(this.irBuilder.isOpen);
+    // Try/catch is not yet implemented in the JS backend.
+    if (this.irBuilder.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) {
+      return giveup(node, 'not exactly one catch block');
+    }
+    // 'on T' catch blocks are not yet implemented.
+    if ((node.catchBlocks.nodes.head as ast.CatchBlock).onKeyword != null) {
+      return giveup(node, '"on T" catch block');
+    }
+    // Finally blocks are not yet implemented.
+    if (node.finallyBlock != null) {
+      return giveup(node, 'try/finally');
+    }
+
+    // Catch handlers are in scope for their body.  The CPS translation of
+    // [[try tryBlock catch (e) catchBlock; successor]] is:
+    //
+    // let cont join(v0, v1, ...) = [[successor]] in
+    //   let mutable m0 = x0 in
+    //     let mutable m1 = x1 in
+    //       ...
+    //       let handler catch_(e) =
+    //         let prim p0 = GetMutable(m0) in
+    //           let prim p1 = GetMutable(m1) in
+    //             ...
+    //             [[catchBlock]]
+    //             join(p0, p1, ...)
+    //       in
+    //         [[tryBlock]]
+    //         let prim p0' = GetMutable(m0) in
+    //           let prim p1' = GetMutable(m1) in
+    //             ...
+    //             join(p0', p1', ...)
+    //
+    // In other words, both the try and catch block are in the scope of the
+    // join-point continuation, and they are both in the scope of a sequence
+    // of mutable bindings for the variables assigned in the try.  The join-
+    // point continuation is not in the scope of these mutable bindings.
+    // The tryBlock is in the scope of a binding for the catch handler.  Each
+    // instruction (specifically, each call) in the tryBlock is in the dynamic
+    // scope of the handler.  The mutable bindings are dereferenced at the end
+    // of the try block and at the beginning of the catch block, so the
+    // variables are unboxed in the catch block and at the join point.
+
+    IrBuilder tryCatchBuilder = irBuilder.makeDelimitedBuilder();
+    TryStatementInfo tryInfo = tryCatchBuilder.tryStatements[node];
+    // Variables that are boxed due to being captured in a closure are boxed
+    // for their entire lifetime, and so they do not need to be boxed on
+    // entry to any try block.  We check for them here because we can not
+    // identify all of them in the same pass where we identify the variables
+    // assigned in the try (the may be captured by a closure after the try
+    // statement).
+    Iterable<LocalVariableElement> boxedOnEntry =
+        tryInfo.boxedOnEntry.where((LocalVariableElement variable) {
+      return !tryCatchBuilder.mutableCapturedVariables.contains(variable);
+    });
+    for (LocalVariableElement variable in boxedOnEntry) {
+      assert(!tryCatchBuilder.isInMutableVariable(variable));
+      ir.Primitive value = tryCatchBuilder.buildLocalGet(variable);
+      tryCatchBuilder.makeMutableVariable(variable);
+      tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
+    }
+
+    IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
+    IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
+    List<ir.Parameter> joinParameters =
+        new List<ir.Parameter>.generate(irBuilder.environment.length, (i) {
+      return new ir.Parameter(irBuilder.environment.index2variable[i]);
+    });
+    ir.Continuation joinContinuation = new ir.Continuation(joinParameters);
+
+    void interceptJumps(JumpCollector collector) {
+      collector.enterTry(boxedOnEntry);
+    }
+    void restoreJumps(JumpCollector collector) {
+      collector.leaveTry();
+    }
+    tryBuilder.state.breakCollectors.forEach(interceptJumps);
+    tryBuilder.state.continueCollectors.forEach(interceptJumps);
+    withBuilder(tryBuilder, () {
+      visit(node.tryBlock);
+    });
+    tryBuilder.state.breakCollectors.forEach(restoreJumps);
+    tryBuilder.state.continueCollectors.forEach(restoreJumps);
+    if (tryBuilder.isOpen) {
+      for (LocalVariableElement variable in boxedOnEntry) {
+        assert(tryBuilder.isInMutableVariable(variable));
+        ir.Primitive value = tryBuilder.buildLocalGet(variable);
+        tryBuilder.environment.update(variable, value);
+      }
+      tryBuilder.jumpTo(joinContinuation);
+    }
+
+    for (LocalVariableElement variable in boxedOnEntry) {
+      assert(catchBuilder.isInMutableVariable(variable));
+      ir.Primitive value = catchBuilder.buildLocalGet(variable);
+      // Note that we remove the variable from the set of mutable variables
+      // here (and not above for the try body).  This is because the set of
+      // mutable variables is global for the whole function and not local to
+      // a delimited builder.
+      catchBuilder.removeMutableVariable(variable);
+      catchBuilder.environment.update(variable, value);
+    }
+    ast.CatchBlock catchClause = node.catchBlocks.nodes.head;
+    assert(catchClause.exception != null);
+    LocalVariableElement exceptionElement = elements[catchClause.exception];
+    ir.Parameter exceptionParameter = new ir.Parameter(exceptionElement);
+    catchBuilder.environment.extend(exceptionElement, exceptionParameter);
+    ir.Parameter traceParameter;
+    if (catchClause.trace != null) {
+      LocalVariableElement traceElement = elements[catchClause.trace];
+      traceParameter = new ir.Parameter(traceElement);
+      catchBuilder.environment.extend(traceElement, traceParameter);
+    } else {
+      // Use a dummy continuation parameter for the stack trace parameter.
+      // This will ensure that all handlers have two parameters and so they
+      // can be treated uniformly.
+      traceParameter = new ir.Parameter(null);
+    }
+    withBuilder(catchBuilder, () {
+      visit(catchClause.block);
+    });
+    if (catchBuilder.isOpen) {
+      catchBuilder.jumpTo(joinContinuation);
+    }
+    List<ir.Parameter> catchParameters =
+        <ir.Parameter>[exceptionParameter, traceParameter];
+    ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
+    catchContinuation.body = catchBuilder._root;
+
+    tryCatchBuilder.add(new ir.LetHandler(catchContinuation, tryBuilder._root));
+    tryCatchBuilder._current = null;
+
+    irBuilder.add(new ir.LetCont(joinContinuation, tryCatchBuilder._root));
+    for (int i = 0; i < irBuilder.environment.length; ++i) {
+      irBuilder.environment.index2value[i] = joinParameters[i];
+    }
+    return null;
+  }
+
   // ==== Expressions ====
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
   }
 
   // For all simple literals:
   // Build(Literal(c), C) = C[let val x = Constant(c) in [], x]
@@ skipping 513 matching lines @@
   throw ABORT_IRNODE_BUILDER;
 }
 
 /// Classifies local variables and local functions as captured, if they
 /// are accessed from within a nested function.
 ///
 /// This class is specific to the [DartIrBuilder], in that it gives up if it
 /// sees a feature that is currently unsupport by that builder. In particular,
 /// loop variables captured in a for-loop initializer, condition, or update
 /// expression are unsupported.
-class DartCapturedVariables extends ast.Visitor
-                             implements DartCapturedVariableInfo {
+class DartCapturedVariables extends ast.Visitor {
   final TreeElements elements;
   DartCapturedVariables(this.elements);
 
   FunctionElement currentFunction;
   bool insideInitializer = false;
   Set<Local> capturedVariables = new Set<Local>();
 
+  Map<ast.TryStatement, TryStatementInfo> tryStatements =
+      <ast.TryStatement, TryStatementInfo>{};
+
+  List<TryStatementInfo> tryNestingStack = <TryStatementInfo>[];
+  bool get inTryStatement => tryNestingStack.isNotEmpty;
+
   void markAsCaptured(Local local) {
     capturedVariables.add(local);
   }
 
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
@@ skipping 27 matching lines @@
   }
 
   visitSend(ast.Send node) {
     handleSend(node);
     node.visitChildren(this);
   }
 
   visitSendSet(ast.SendSet node) {
     handleSend(node);
     Element element = elements[node];
-    // Initializers in an initializer-list can communicate via parameters.
-    // If a parameter is stored in an initializer list we box it.
-    if (insideInitializer &&
-        Elements.isLocal(element) &&
-        element.isParameter) {
+    if (Elements.isLocal(element)) {
       LocalElement local = element;
-      // TODO(sigurdm): Fix this.
-      // Though these variables do not outlive the activation of the function,
-      // they still need to be boxed.  As a simplification, we treat them as if
-      // they are captured by a closure (i.e., they do outlive the activation of
-      // the function).
-      markAsCaptured(local);
+      if (insideInitializer) {
+        assert(local.isParameter);
+        // Initializers in an initializer-list can communicate via parameters.
+        // If a parameter is stored in an initializer list we box it.
+        // TODO(sigurdm): Fix this.
+        // Though these variables do not outlive the activation of the
+        // function, they still need to be boxed.  As a simplification, we
+        // treat them as if they are captured by a closure (i.e., they do
+        // outlive the activation of the function).
+        markAsCaptured(local);
+      } else if (inTryStatement) {
+        assert(local.isParameter || local.isVariable);
+        // Search for the position of the try block containing the variable
+        // declaration, or -1 if it is declared outside the outermost try.
+        int i = tryNestingStack.length - 1;
+        while (i >= 0 && !tryNestingStack[i].declared.contains(local)) {
+          --i;
+        }
+        // If there is a next inner try, then the variable should be boxed on
+        // entry to it.
+        if (i + 1 < tryNestingStack.length) {
+          tryNestingStack[i + 1].boxedOnEntry.add(local);
+        }
+      }
     }
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     if (currentFunction.asyncMarker != AsyncMarker.SYNC) {
       giveup(node, "cannot handle async/sync*/async* functions");
     }
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
+
+  visitTryStatement(ast.TryStatement node) {
+    TryStatementInfo info = new TryStatementInfo();
+    tryStatements[node] = info;
+    tryNestingStack.add(info);
+    visit(node.tryBlock);
+    assert(tryNestingStack.last == info);
+    tryNestingStack.removeLast();
+
+    visit(node.catchBlocks);
+    if (node.finallyBlock != null) visit(node.finallyBlock);
+  }
+
+  visitVariableDefinitions(ast.VariableDefinitions node) {
+    if (inTryStatement) {
+      for (ast.Node definition in node.definitions.nodes) {
+        LocalVariableElement local = elements[definition];
+        assert(local != null);
+        // In the closure conversion pass we check for isInitializingFormal,
+        // but I'm not sure it can arise.
+        assert(!local.isInitializingFormal);
+        tryNestingStack.last.declared.add(local);
+      }
+    }
+    node.visitChildren(this);
+  }
 }
 
 /// IR builder specific to the Dart backend, coupled to the [DartIrBuilder].
 class DartIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [DartIrBuilder].
   DartIrBuilder get irBuilder => super.irBuilder;
 
   DartIrBuilderVisitor(TreeElements elements,
                    Compiler compiler,
                    SourceFile sourceFile)
@@ skipping 624 matching lines @@
     for (String argName in selector.getOrderedNamedArguments()) {
       int nameIndex = selector.namedArguments.indexOf(argName);
       int translatedIndex = selector.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
 
 }