dart2js cps: Refactor CallExpressions into Primitives.

pkg/compiler/lib/src/cps_ir/share_interceptors.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.share_interceptors;
 
 import 'optimizers.dart';
 import 'cps_ir_nodes.dart';
 import 'loop_hierarchy.dart';
 import 'cps_fragment.dart';
@@ skipping 124 matching lines @@
     InterceptorConstantValue constant = getInterceptorConstant(interceptor);
 
     if (constant == null) return;
 
     if (interceptor.isAlwaysIntercepted) {
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type,
           sourceInformation: interceptor.sourceInformation);
       constantPrim.useElementAsHint(interceptor.hint);
-      constantPrim.substituteFor(interceptor);
-      interceptor.destroy();
+      interceptor..replaceUsesWith(constantPrim)..destroy();
       let.remove();
     } else if (interceptor.isAlwaysNullOrIntercepted) {
       Primitive input = interceptor.input.definition;
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type.nonNullable(),
           sourceInformation: interceptor.sourceInformation);
       CpsFragment cps = new CpsFragment(interceptor.sourceInformation);
       Parameter param = new Parameter(interceptor.hint);
       Continuation cont = cps.letCont(<Parameter>[param]);
       if (interceptor.interceptedClasses.every(hasNoFalsyValues)) {
         // If null is the only falsy value, compile as "x && CONST".
         cps.ifFalsy(input).invokeContinuation(cont, [input]);
       } else {
         // If there are other falsy values compile as "x == null ? x : CONST".
         Primitive condition = cps.applyBuiltin(
             BuiltinOperator.LooseEq,
             [input, cps.makeNull()]);
         cps.ifTruthy(condition).invokeContinuation(cont, [input]);
       }
       cps.invokeContinuation(cont, [constantPrim]);
       cps.context = cont;
       cps.insertAbove(let);
-      param.substituteFor(interceptor);
-      interceptor.destroy();
+      interceptor..replaceUsesWith(param)..destroy();
       let.remove();
     }
   }
 
   @override
   Expression traverseLetPrim(LetPrim node) {
     loopHeaderFor[node.primitive] = currentLoopHeader;
     Expression next = node.body;
     if (node.primitive is! Interceptor) {
       return next;
     }
     Interceptor interceptor = node.primitive;
     Primitive input = interceptor.input.definition;
 
     // Try to reuse an existing interceptor for the same input.
     Interceptor existing = interceptorFor[input];
     if (existing != null) {
       existing.interceptedClasses.addAll(interceptor.interceptedClasses);
       existing.flags |= interceptor.flags;
-      existing.substituteFor(interceptor);
-      interceptor.destroy();
+      interceptor..replaceUsesWith(existing)..destroy();
       node.remove();
       return next;
     }
 
     // Put this interceptor in the environment.
     interceptorFor[input] = interceptor;
 
     // Determine how far the interceptor can be lifted. The outermost loop
     // that contains the input binding should also contain the interceptor
     // binding.
@@ skipping 47 matching lines @@
 
 class ShareConstants extends TrampolineRecursiveVisitor {
   Map<ConstantValue, Constant> sharedConstantFor = <ConstantValue, Constant>{};
 
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
     if (node.primitive is Constant && shouldShareConstant(node.primitive)) {
       Constant prim = node.primitive;
       Constant existing = sharedConstantFor[prim.value];
       if (existing != null) {
-        existing.substituteFor(prim);
         existing.useElementAsHint(prim.hint);
-        prim.destroy();
+        prim..replaceUsesWith(existing)..destroy();
         node.remove();
         return next;
       }
       sharedConstantFor[prim.value] = prim;
       pushAction(() {
         assert(sharedConstantFor[prim.value] == prim);
         sharedConstantFor.remove(prim.value);
       });
     }
     return next;
   }
 
   bool shouldShareConstant(Constant constant) {
     return constant.value.isInterceptor;
   }
 }