dart2js cps: Avoid deep recursion using trampolines and basic blocks.

pkg/compiler/lib/src/cps_ir/let_sinking.dart

 // Copyright (c) 2015, 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.cps_ir.let_sinking;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Sinks single-use primitives to the use when this is safe and profitable.
@@ skipping 20 matching lines @@
   LoopHierarchy loopHierarchy;
   List<Continuation> stack = <Continuation>[];
   Set<LetPrim> sunkNodes = new Set<LetPrim>();
 
   void rewrite(FunctionDefinition node) {
     new ParentVisitor().visit(node);
     loopHierarchy = new LoopHierarchy(node);
     visit(node.body);
   }
 
-  void visitLetPrim(LetPrim node) {
+  @override
+  Expression traverseLetPrim(LetPrim node) {
+    pushAction(() {
+      if (node.primitive != null) {
+        // The primitive could not be sunk. Sink dependencies to this location.
+        visit(node.primitive);
+      } else {
+        // The primitive was sunk. Destroy the old LetPrim.
+        InteriorNode parent = node.parent;
+        parent.body = node.body;
+        node.body.parent = parent;
+      }
+    });
+
     // Visit the body, wherein this primitive may be sunk to its use site.
-    visit(node.body);
-
-    if (node.primitive != null) {
-      // The primitive could not be sunk. Sink dependencies to this location.
-      visit(node.primitive);
-    } else {
-      // The primitive was sunk. Destroy the old LetPrim.
-      InteriorNode parent = node.parent;
-      parent.body = node.body;
-      node.body.parent = parent;
-    }
+    return node.body;
   }
 
   void processReference(Reference ref) {
     Definition definition = ref.definition;
     if (definition is Primitive && 
         definition is! Parameter &&
         definition.hasExactlyOneUse &&
         definition.isSafeForReordering) {
       // Check if use is in the same loop.
       LetPrim binding = definition.parent;
@@ skipping 170 matching lines @@
     target = _markInnerLoop(target, catchLoop);
     for (Continuation cont in callContinuations) {
       // Store the loop target on each call continuation in the basic block.
       // Because we walk over call continuations as part of the basic block
       // traversal, these do not get their loop target set otherwise.
       loopTarget[cont] = target;
     }
     return target;
   }
 }