dart2js cps: Refactor CallExpressions into Primitives.

pkg/compiler/lib/src/cps_ir/loop_hierarchy.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.loop_hierarchy;
 
 import 'cps_ir_nodes.dart';
 
 /// Determines the effective nesting of loops.
 ///
@@ skipping 81 matching lines @@
       loopDepth[cont] = currentDepth;
       Continuation target = _processBlock(cont.body, catchLoop);
       _markInnerLoop(loopTarget[cont], target);
       --currentDepth;
     } else {
       loopTarget[cont] = _processBlock(cont.body, catchLoop);
     }
     return loopTarget[cont];
   }
 
-  bool _isCallContinuation(Continuation cont) {
-    return cont.hasExactlyOneUse && cont.firstRef.parent is CallExpression;
-  }
-
   /// Analyzes a basic block and returns the innermost loop that
   /// can be invoked recursively from that block.
   Continuation _processBlock(Expression node, Continuation catchLoop) {
-    List<Continuation> callContinuations = <Continuation>[];
     for (; node is! TailExpression; node = node.next) {
       if (node is LetCont) {
         for (Continuation cont in node.continuations) {
-          if (!_isCallContinuation(cont)) {
-            // Process non-call continuations at the binding site, so they
-            // their loop target is known at all use sites.
-            _processContinuation(cont, catchLoop);
-          } else {
-            // To avoid deep recursion, do not analyze call continuations
-            // recursively. This basic block traversal steps into the
-            // call contiunation after visiting its use site. We store the
-            // continuations in a list so we can set the loop target once
-            // it is known.
-            callContinuations.add(cont);
-          }
+          _processContinuation(cont, catchLoop);
         }
       } else if (node is LetHandler) {
         catchLoop = _processContinuation(node.handler, catchLoop);
       }
     }
     Continuation target;
     if (node is InvokeContinuation) {
       if (node.isRecursive) {
         target = node.continuation.definition;
       } else {
         target = loopTarget[node.continuation.definition];
       }
     } else if (node is Branch) {
       target = _markInnerLoop(
           loopTarget[node.trueContinuation.definition],
           loopTarget[node.falseContinuation.definition]);
     } else {
       assert(node is Unreachable || node is Throw);
     }
-    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;
+    return _markInnerLoop(target, catchLoop);
   }
 }