dart2dart: Implementation of simple try/catch.

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.dart

 // Copyright (c) 2014, 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 tree_ir.optimization;
 
 /**
  * Performs the following transformations on the tree:
  * - Assignment propagation
  * - If-to-conditional conversion
@@ skipping 93 matching lines @@
   /// for a break to L' if L maps to L'.
   Map<Label, Jump> labelRedirects = <Label, Jump>{};
 
   /// Rewriter for methods.
   StatementRewriter() : constantEnvironment = <Variable, Expression>{};
 
   /// Rewriter for nested functions.
   StatementRewriter.nested(StatementRewriter parent)
       : constantEnvironment = parent.constantEnvironment;
 
-  /// Returns the redirect target of [label] or [label] itself if it should not
+  /// A set of labels that can be safely inlined at their use.
+  ///
+  /// The successor statements for labeled statements that have only one break
+  /// from them are normally rewritten inline at the site of the break.  This
+  /// is not safe if the code would be moved inside the scope of an exception
+  /// handler (i.e., if the code would be moved into a try from outside it).
+  Set<Label> safeForInlining = new Set<Label>();
+
+  /// Returns the redirect target of [jump] or [jump] itself if it should not
   /// be redirected.
   Jump redirect(Jump jump) {
     Jump newJump = labelRedirects[jump.target];
     return newJump != null ? newJump : jump;
   }
 
   rewriteExecutableDefinition(ExecutableDefinition definition) {
     inEmptyEnvironment(() {
       definition.body = visitStatement(definition.body);
     });
@@ skipping 178 matching lines @@
     node.value = visitExpression(node.value);
     return node;
   }
 
 
   Statement visitBreak(Break node) {
     // Redirect through chain of breaks.
     // Note that useCount was accounted for at visitLabeledStatement.
     // Note redirect may return either a Break or Continue statement.
     Jump jump = redirect(node);
-    if (jump is Break && jump.target.useCount == 1) {
+    if (jump is Break &&
+        jump.target.useCount == 1 &&
+        safeForInlining.contains(jump.target)) {
       --jump.target.useCount;
       return visitStatement(jump.target.binding.next);
     }
     return jump;
   }
 
   Statement visitContinue(Continue node) {
     return node;
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
     if (node.next is Jump) {
       // Eliminate label if next is a break or continue statement
       // Breaks to this label are redirected to the outer label.
       // Note that breakCount for the two labels is updated proactively here
       // so breaks can reliably tell if they should inline their target.
       Jump next = node.next;
       Jump newJump = redirect(next);
       labelRedirects[node.label] = newJump;
       newJump.target.useCount += node.label.useCount - 1;
       node.label.useCount = 0;
       Statement result = visitStatement(node.body);
       labelRedirects.remove(node.label); // Save some space.
       return result;
     }
 
+    safeForInlining.add(node.label);
     node.body = visitStatement(node.body);
+    safeForInlining.remove(node.label);
 
     if (node.label.useCount == 0) {
       // Eliminate the label if next was inlined at a break
       return node.body;
     }
 
     // Do not propagate assignments into the successor statements, since they
     // may be overwritten by assignments in the body.
     inEmptyEnvironment(() {
       node.next = visitStatement(node.next);
@@ skipping 39 matching lines @@
       node.body = visitStatement(node.body);
     });
     return node;
   }
 
   Statement visitWhileCondition(WhileCondition node) {
     // Not introduced yet
     throw "Unexpected WhileCondition in StatementRewriter";
   }
 
+  Statement visitTry(Try node) {
+    Set<Label> saved = safeForInlining;
+    safeForInlining = new Set<Label>();
+    node.tryBody = visitStatement(node.tryBody);
+    safeForInlining = saved;
+    node.catchBody = visitStatement(node.catchBody);
+    return node;
+  }
+
   Expression visitConstant(Constant node) {
     return node;
   }
 
   Expression visitThis(This node) {
     return node;
   }
 
   Expression visitReifyTypeVar(ReifyTypeVar node) {
     return node;
@@ skipping 215 matching lines @@
   }
 
   Expression makeCondition(Expression e, bool polarity) {
     return polarity ? e : new Not(e);
   }
 
   Statement getBranch(If node, bool polarity) {
     return polarity ? node.thenStatement : node.elseStatement;
   }
 }