dart2dart: Implementation of simple try/catch.

pkg/compiler/lib/src/cps_ir/shrinking_reductions.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 dart2js.cps_ir.optimizers;
 
 /**
  * [ShrinkingReducer] applies shrinking reductions to CPS terms as described
  * in 'Compiling with Continuations, Continued' by Andrew Kennedy.
  */
@@ skipping 245 matching lines @@
   // There is a restriction on continuation eta-redexes that the body is not an
   // invocation of the return continuation, because that leads to worse code
   // when translating back to direct style (it duplicates returns).  There is no
   // such restriction here because continuation beta-reduction is only performed
   // for singly referenced continuations. Thus, there is no possibility of code
   // duplication.
   if (cont.isReturnContinuation || !cont.hasExactlyOneUse) {
     return false;
   }
 
-  if (cont.firstRef.parent is InvokeContinuation) {
-    InvokeContinuation invoke = cont.firstRef.parent;
-    return (cont == invoke.continuation.definition);
+  if (cont.firstRef.parent is! InvokeContinuation) return false;
+
+  InvokeContinuation invoke = cont.firstRef.parent;
+  if (cont != invoke.continuation.definition) return false;
+
+  // Beta-reduction will move the continuation's body to its unique invocation
+  // site.  This is not safe if the body is moved into an exception handler
+  // binding.
+  Node current = invoke.parent;
+  while (current != cont.parent) {
+    if (current is LetHandler) return false;
+    current = current.parent;
   }
-
-  return false;
+  return true;
 }
 
 /// Returns true iff the continuation consists of a continuation
 /// invocation, passing on all parameters. Special cases exist (see below).
 bool _isEtaCont(Continuation cont) {
   if (cont.isReturnContinuation || cont.body is! InvokeContinuation) {
     return false;
   }
 
   InvokeContinuation invoke = cont.body;
@@ skipping 68 matching lines @@
 
   return true;
 }
 
 bool _isDeadParameter(Parameter parameter) {
   // We cannot remove function parameters as an intraprocedural optimization.
   if (parameter.parent is! Continuation || parameter.hasAtLeastOneUse) {
     return false;
   }
 
+  // We cannot remove exception handler parameters, they have a fixed arity
+  // of two.
+  if (parameter.parent.parent is LetHandler) {
+    return false;
+  }
+
   // We cannot remove the parameter to a call continuation, because the
   // resulting expression will not be well-formed (call continuations have
   // exactly one argument).  The return continuation is a call continuation, so
   // we cannot remove its dummy parameter.
   Continuation continuation = parameter.parent;
   if (continuation.isReturnContinuation) return false;
   Reference<Continuation> current = continuation.firstRef;
   while (current != null) {
     if (current.parent is! InvokeContinuation) return false;
     InvokeContinuation invoke = current.parent;
     if (invoke.continuation.definition != continuation) return false;
     current = current.next;
   }
   return true;
 }
 
 /// Traverses a term and adds any found redexes to the worklist.
 class _RedexVisitor extends RecursiveVisitor {
   final Set<_ReductionTask> worklist;
 
   _RedexVisitor(this.worklist);
 
   void processLetPrim(LetPrim node) {
     if (_isDeadVal(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.DEAD_VAL, node));
     }
   }
 
   void processContinuation(Continuation node) {
+    // While it would be nice to remove exception handlers that are provably
+    // unnecessary (e.g., the body cannot throw), that takes more sophisticated
+    // analysis than we do in this pass.
+    if (node.parent is LetHandler) return;
+
     // Continuation beta- and eta-redexes can overlap, namely when an eta-redex
     // is invoked exactly once.  We prioritize continuation beta-redexes over
     // eta-redexes because some reductions (e.g., dead parameter elimination)
     // can destroy a continuation eta-redex.  If we prioritized eta- over
     // beta-redexes, this would implicitly "create" the corresponding beta-redex
     // (in the sense that it would still apply) and the algorithm would not
     // detect it.
     if (_isDeadCont(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.DEAD_CONT, node));
     } else if (_isBetaContLin(node)){
@@ skipping 106 matching lines @@
 
   processLetCont(LetCont node) {
     int index = 0;
     node.continuations.forEach((Continuation continuation) {
       continuation.parent = node;
       continuation.parent_index = index++;
     });
     node.body.parent = node;
   }
 
+  processLetHandler(LetHandler node) {
+    node.handler.parent = node;
+    node.body.parent = node;
+  }
+
   processLetMutable(LetMutable node) {
     node.variable.parent = node;
     node.value.parent = node;
     node.body.parent = node;
   }
 
   processInvokeStatic(InvokeStatic node) {
     node.arguments.forEach((Reference ref) => ref.parent = node);
     node.continuation.parent = node;
   }
@@ skipping 150 matching lines @@
   }
 
   String toString() => "$kind: $node";
 }
 
 /// A dummy class used solely to mark nodes as deleted once they are removed
 /// from a term.
 class _DeletedNode extends Node {
   accept(_) => null;
 }