dart2js cps: Tolerate refinements in more cases.

pkg/compiler/lib/src/cps_ir/redundant_phi.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.
 
 library dart2js.cps_ir.redundant_phi_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminate redundant phis from the given [FunctionDefinition].
@@ skipping 43 matching lines @@
       }
     }
 
     if (invokes.isEmpty) {
       return; // Continuation is never invoked, can't optimize.
     }
 
     /// Returns the unique definition of parameter i if it exists and null
     /// otherwise. A definition is unique if it is the only value used to
     /// invoke the continuation, excluding feedback.
-    Definition uniqueDefinitionOf(int i) {
-      Definition value = null;
+    Primitive uniqueDefinitionOf(int i) {
+      Primitive value = null;
       for (InvokeContinuation invoke in invokes) {
-        Definition def = invoke.arguments[i].definition;
+        Primitive def = invoke.arguments[i].definition.effectiveDefinition;
 
         if (cont.parameters[i] == def) {
           // Invocation param == param in LetCont (i.e. a recursive call).
           continue;
         } else if (value == null) {
           value = def; // Set initial comparison value.
         } else if (value != def) {
           return null; // Differing invocation arguments.
         }
       }
@@ skipping 19 matching lines @@
       return true;
     }
 
     // Check if individual parameters are always called with a unique
     // definition, and remove them if that is the case. During each iteration,
     // we read the current parameter/argument from index `src` and copy it
     // to index `dst`.
     int dst = 0;
     for (int src = 0; src < cont.parameters.length; src++) {
       // Is the current phi redundant?
-      Definition uniqueDefinition = uniqueDefinitionOf(src);
+      Primitive uniqueDefinition = uniqueDefinitionOf(src);
       if (uniqueDefinition == null || !safeForHandlers(uniqueDefinition)) {
         // Reorganize parameters and arguments in case of deletions.
         if (src != dst) {
           cont.parameters[dst] = cont.parameters[src];
           for (InvokeContinuation invoke in invokes) {
             invoke.arguments[dst] = invoke.arguments[src];
           }
         }
         dst++;
         continue;
       }
 
-      Definition oldDefinition = cont.parameters[src];
+      Primitive oldDefinition = cont.parameters[src];
 
       // Add continuations of about-to-be modified invokes to worklist since
       // we might introduce new optimization opportunities.
       for (Reference ref = oldDefinition.firstRef;
            ref != null;
            ref = ref.next) {
         Node parent = ref.parent;
         if (parent is InvokeContinuation) {
           Continuation thatCont = parent.continuation.definition;
           if (thatCont != cont) {
@@ skipping 64 matching lines @@
 /// Returns the LetCont that now binds [continuation].
 LetCont _makeUniqueBinding(Continuation continuation) {
   LetCont letCont = continuation.parent;
   if (letCont.continuations.length == 1) return letCont;
   letCont.continuations.remove(continuation);
   LetCont newBinding = new LetCont(continuation, null);
   continuation.parent = newBinding;
   newBinding.insertBelow(letCont);
   return newBinding;
 }