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 82 matching lines @@
  */
 class StatementRewriter extends Visitor<Statement, Expression> with PassMixin {
   // The binding environment.  The rightmost element of the list is the nearest
   // available enclosing binding.
   List<Assign> environment;
 
   /// Substitution map for labels. Any break to a label L should be substituted
   /// for a break to L' if L maps to L'.
   Map<Label, Jump> labelRedirects = <Label, Jump>{};
 
-  /// Returns the redirect target of [label] or [label] itself if it should not
+  // The successor statements for labeled statements that have only one break

[karlklose, 2015/02/16 10:15:48]

Use '///'.

+  // from them are normally rewritten inline at the site of the break.  This is
+  // not safe if the code would be move inside the scope of an exception

[karlklose, 2015/02/16 10:15:48]

'move' -> 'moved'.

+  // handler (i.e., if the code would be moved into a try from outside it.

[karlklose, 2015/02/16 10:15:48]

Missing ')'.

[Kevin Millikin (Google), 2015/02/25 11:06:36]

That's embarassing for a Lisper.

+  List<Label> safeForHandlers = <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) {
     definition.body = rewriteInEmptyEnvironment(definition.body);
   }
@@ skipping 144 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 &&
+        safeForHandlers.contains(jump.target)) {

[asgerf, 2015/02/20 10:10:07]

Isn't this a bit expensive? It looks like a quadratic behavior will kick in very
easily.

Wouldn't it be better to use a Set, or at least only add singly-used labels to
the list to make it shorter (so it becomes "safeForInlining").

[Kevin Millikin (Google), 2015/02/25 11:06:36]

I don't think it's best to add only singly-used labels, since it's difficult to
reason about the way that we adjust the use counts of labels on the fly.

I'll change it to a Set, though that might have a higher cost than List for
'pushing' and 'popping'.  I suppose it's not necessary to ever remove labels
from the set --- do you think it's a good idea not to remove them?

I'll still change the name to safeForInlining, because that's better (having
multiple uses doesn't make a label 'unsafe' anyway).

[asgerf, 2015/02/25 11:55:11]

Ah, I forgot the use-counts on labels change during this phase.

I like to remove garbage from maps and sets when it's easy to do so. It usually
pays off.

       --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;
     }
 
+    safeForHandlers.add(node.label);
     node.body = visitStatement(node.body);
+    safeForHandlers.removeLast();
 
     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.
     List<Assign> savedEnvironment = environment;
     environment = <Assign>[];
@@ skipping 45 matching lines @@
     assert(environment.isEmpty);
     environment = savedEnvironment;
     return node;
   }
 
   Statement visitWhileCondition(WhileCondition node) {
     // Not introduced yet
     throw "Unexpected WhileCondition in StatementRewriter";
   }
 
+  Statement visitTryStatement(TryStatement node) {
+    List<Label> saved = safeForHandlers;
+    safeForHandlers = <Label>[];
+    node.tryBody = visitStatement(node.tryBody);
+    safeForHandlers = 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 219 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;
   }
 }