dart2js CPS: Support try/catch/finally.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 93 matching lines @@
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
   /// copied into [ir.MutableVariable]s on entry to the try and copied out on
   /// exit.
-  Map<ast.TryStatement, TryStatementInfo> tryStatements = null;
+  Map<ast.Node, TryStatementInfo> tryStatements = null;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
@@ skipping 299 matching lines @@
     }
     ir.Primitive value = visit(node.expression);
     JumpTarget target = elements.getTargetDefinition(node);
     Element error =
         (compiler.backend as JavaScriptBackend).getFallThroughError();
     irBuilder.buildSimpleSwitch(target, value, cases, defaultCase, error,
         sourceInformationBuilder.buildGeneric(node));
   }
 
   visitTryStatement(ast.TryStatement node) {
-    // Try/catch/finally is not yet implemented.
-    if (!node.catchBlocks.isEmpty && node.finallyBlock != null) {
-      return giveup(node, 'try/catch/finally');
-    }
-
     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];
       }
       DartType type;
       if (catchClause.onKeyword != null) {
         type = elements.getType(catchClause.type);
       }
       catchClauseInfos.add(new CatchClauseInfo(
           type: type,
           exceptionVariable: exceptionVariable,
           stackTraceVariable: stackTraceVariable,
           buildCatchBlock: subbuild(catchClause.block)));
     }
 
-    SubbuildFunction buildFinallyBlock =
-        node.finallyBlock == null ? null : subbuild(node.finallyBlock);
-    irBuilder.buildTry(
-        tryStatementInfo: tryStatements[node],
-        buildTryBlock: subbuild(node.tryBlock),
-        catchClauseInfos: catchClauseInfos,
-        buildFinallyBlock: buildFinallyBlock,
-        closureClassMap: closureClassMap);
+    assert(!node.catchBlocks.isEmpty || node.finallyBlock != null);
+    if (!node.catchBlocks.isEmpty && node.finallyBlock != null) {
+      // Try/catch/finally is encoded in terms of try/catch and try/finally:
+      //
+      // try tryBlock catch (ex, st) catchBlock finally finallyBlock
+      // ==>
+      // try { try tryBlock catch (ex, st) catchBlock } finally finallyBlock
+      irBuilder.buildTryFinally(tryStatements[node.finallyBlock],
+          (IrBuilder inner) {
+            inner.buildTryCatch(tryStatements[node.catchBlocks],
+                subbuild(node.tryBlock),
+                catchClauseInfos);
+          },
+          subbuild(node.finallyBlock));
+    } else if (!node.catchBlocks.isEmpty) {
+      irBuilder.buildTryCatch(tryStatements[node.catchBlocks],
+          subbuild(node.tryBlock),
+          catchClauseInfos);
+    } else {
+      irBuilder.buildTryFinally(tryStatements[node.finallyBlock],
+          subbuild(node.tryBlock),
+          subbuild(node.finallyBlock));
+    }
   }
 
   // ## Expressions ##
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
   }
 
@@ skipping 1478 matching lines @@
 /// loop variables captured in a for-loop initializer, condition, or update
 /// expression are unsupported.
 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>{};
+  /// A map containing variables boxed inside try blocks.
+  ///
+  /// The map is keyed by the [NodeList] of catch clauses for try/catch and
+  /// by the finally block for try/finally.  try/catch/finally is treated
+  /// as a try/catch nested in the try block of a try/finally.
+  Map<ast.Node, TryStatementInfo> tryStatements =
+      <ast.Node, TryStatementInfo>{};
 
   List<TryStatementInfo> tryNestingStack = <TryStatementInfo>[];
   bool get inTryStatement => tryNestingStack.isNotEmpty;
 
   String bailoutMessage = null;
 
   giveup(ast.Node node, [String reason]) {
     bailoutMessage = '($node): $reason';
     throw ABORT_IRNODE_BUILDER;
   }
@@ skipping 96 matching lines @@
     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);
+    // Try/catch/finally is treated as two simpler constructs: try/catch and
+    // try/finally.  The encoding is:
+    //
+    // try S0 catch (ex, st) S1 finally S2
+    // ==>
+    // try { try S0 catch (ex, st) S1 } finally S2
+    //
+    // The analysis associates variables assigned in S0 with the catch clauses
+    // and variables assigned in S0 and S1 with the finally block.
+    TryStatementInfo enterTryFor(ast.Node node) {
+      TryStatementInfo info = new TryStatementInfo();
+      tryStatements[node] = info;
+      tryNestingStack.add(info);
+      return info;
+    }
+    void leaveTryFor(TryStatementInfo info) {
+      assert(tryNestingStack.last == info);
+      tryNestingStack.removeLast();
+    }
+    bool hasCatch = !node.catchBlocks.isEmpty;
+    bool hasFinally = node.finallyBlock != null;
+    TryStatementInfo catchInfo, finallyInfo;
+    // There is a nesting stack of try blocks, so the outer try/finally block
+    // is added first.
+    if (hasFinally) finallyInfo = enterTryFor(node.finallyBlock);
+    if (hasCatch) catchInfo = enterTryFor(node.catchBlocks);
     visit(node.tryBlock);
-    assert(tryNestingStack.last == info);
-    tryNestingStack.removeLast();
 
-    visit(node.catchBlocks);
-    if (node.finallyBlock != null) visit(node.finallyBlock);
+    if (hasCatch) {
+      leaveTryFor(catchInfo);
+      visit(node.catchBlocks);
+    }
+    if (hasFinally) {
+      leaveTryFor(finallyInfo);
+      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);
@@ skipping 1085 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }