Support simple try in analyzer2dart.

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 435 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);
+  visitTryStatement(ast.TryStatement node) {
     // 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);
+    List<CatchClauseInfo> catchClauseInfos = <CatchClauseInfo>[];
+    for (ast.CatchBlock catchClause in node.catchBlocks.nodes) {
+      assert(catchClause.exception != null);
+      LocalVariableElement exceptionVariable = elements[catchClause.exception];
+      LocalVariableElement stackTraceVariable;
+      if (catchClause.trace != null) {
+        stackTraceVariable = elements[catchClause.trace];
+      }
+      catchClauseInfos.add(new CatchClauseInfo(
+          exceptionVariable: exceptionVariable,
+          stackTraceVariable: stackTraceVariable,
+          buildCatchBlock: subbuild(catchClause.block)));
     }
 
-    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;
+    irBuilder.buildTry(
+        tryStatementInfo: irBuilder.tryStatements[node],
+        buildTryBlock: subbuild(node.tryBlock),
+        catchClauseInfos: catchClauseInfos);
   }
 
   // ==== Expressions ====
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
   }
 
@@ skipping 1331 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }