dart2js cps: Refactor CallExpressions into Primitives.

pkg/compiler/lib/src/cps_ir/insert_refinements.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 cps_ir.optimization.insert_refinements;
 
 import 'optimizers.dart' show Pass;
 import 'cps_ir_nodes.dart';
 import '../common/names.dart';
 import '../types/types.dart' show TypeMask;
@@ skipping 57 matching lines @@
     } else {
       let.remove(); // Reuse the existing LetCont.
     }
     let.insertAbove(use);
   }
 
   Primitive unfoldInterceptor(Primitive prim) {
     return prim is Interceptor ? prim.input.definition : prim;
   }
 
-  /// Enqueues [cont] for processing in a context where [refined] is the
-  /// current refinement for its value.
-  void pushRefinement(Continuation cont, Refinement refined) {
+  /// Sets [refined] to be the current current refinement for its value,

[sra1, 2015/11/19 21:41:46]

current current?

[asgerf, 2015/11/20 16:23:54]

It is even more current than usual

+  /// and pushes an action that will restore the original scope again.
+  ///
+  /// The refinement is inserted as the child of [insertionParent] if it has
+  /// at least one use after its scope has been processed.
+  void applyRefinement(InteriorNode insertionParent, Refinement refined) {
     Primitive value = refined.effectiveDefinition;
     Primitive currentRefinement = refinementFor[value];
     pushAction(() {
       refinementFor[value] = currentRefinement;
       if (refined.hasNoUses) {
         // Clean up refinements that are not used.
         refined.destroy();
       } else {
         LetPrim let = new LetPrim(refined);
-        let.insertBelow(cont);
+        let.insertBelow(insertionParent);
       }
     });
-    push(cont);
+    refinementFor[value] = refined;

[sra1, 2015/11/19 21:41:46]

I think I prefer pushAction to be the last thing since that code happens after
the non-pushAction code.

[asgerf, 2015/11/20 16:23:54]

Done.

+  }
+
+  /// Enqueues [cont] for processing in a context where [refined] is the
+  /// current refinement for its value.
+  void pushRefinement(Continuation cont, Refinement refined) {
     pushAction(() {
-      refinementFor[value] = refined;
+      applyRefinement(cont, refined);
+      push(cont);
     });
   }
 
   void visitInvokeMethod(InvokeMethod node) {
-    Continuation cont = node.continuation.definition;
-
     // Update references to their current refined values.
     processReference(node.receiver);
     node.arguments.forEach(processReference);
 
     // If the call is intercepted, we want to refine the actual receiver,
     // not the interceptor.
     Primitive receiver = unfoldInterceptor(node.receiver.definition);
 
-    // Sink the continuation to the call to ensure everything in scope
-    // here is also in scope inside the continuations.
-    sinkContinuationToUse(cont, node);
-
     if (node.selector.isClosureCall) {
       // Do not try to refine the receiver of closure calls; the class world
       // does not know about closure classes.
-      push(cont);
     } else {
       // Filter away receivers that throw on this selector.
       TypeMask type = types.receiverTypeFor(node.selector, node.mask);
       Refinement refinement = new Refinement(receiver, type);
-      pushRefinement(cont, refinement);
+      LetPrim letPrim = node.parent;
+      applyRefinement(letPrim, refinement);
     }
   }
 
   void visitTypeCast(TypeCast node) {
-    Continuation cont = node.continuation.definition;
     Primitive value = node.value.definition;
 
     processReference(node.value);
     node.typeArguments.forEach(processReference);
 
     // Refine the type of the input.
-    sinkContinuationToUse(cont, node);
     TypeMask type = types.subtypesOf(node.dartType).nullable();
     Refinement refinement = new Refinement(value, type);
-    pushRefinement(cont, refinement);
+    LetPrim letPrim = node.parent;
+    applyRefinement(letPrim, refinement);
   }
 
   void visitRefinement(Refinement node) {
     // We found a pre-existing refinement node. These are generated by the
     // IR builder to hold information from --trust-type-annotations.
     // Update its input to use our own current refinement, then update the
     // environment to use this refinement.
     processReference(node.value);
     Primitive value = node.value.definition.effectiveDefinition;
     Primitive oldRefinement = refinementFor[value];
     refinementFor[value] = node;
     pushAction(() {
       refinementFor[value] = oldRefinement;
     });
   }
 
-  CallExpression getCallWithResult(Primitive prim) {
-    if (prim is Parameter && prim.parent is Continuation) {
-      Continuation cont = prim.parent;
-      if (cont.hasExactlyOneUse && cont.firstRef.parent is CallExpression) {
-        return cont.firstRef.parent;
-      }
-    }
-    return null;
-  }
-
   bool isTrue(Primitive prim) {
     return prim is Constant && prim.value.isTrue;
   }
 
   void visitBranch(Branch node) {
     processReference(node.condition);
     Primitive condition = node.condition.definition;
-    CallExpression call = getCallWithResult(condition);
 
     Continuation trueCont = node.trueContinuation.definition;
     Continuation falseCont = node.falseContinuation.definition;
 
     // Sink both continuations to the Branch to ensure everything in scope
     // here is also in scope inside the continuations.
     sinkContinuationToUse(trueCont, node);
     sinkContinuationToUse(falseCont, node);
 
     // If the condition is an 'is' check, promote the checked value.
@@ skipping 23 matching lines @@
         Refinement refinedTrue = new Refinement(second, types.nullType);
         Refinement refinedFalse = new Refinement(second, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else {
         push(trueCont);
         push(falseCont);
       }
     }
 
-    if (call is InvokeMethod && call.selector == Selectors.equals) {
-      refineEquality(call.arguments[0].definition,
-                     call.arguments[1].definition,
+    if (condition is InvokeMethod && condition.selector == Selectors.equals) {
+      refineEquality(condition.dartReceiver,
+                     condition.getDartArgument(0),
                      trueCont,
                      falseCont);
       return;
     }
 
     if (condition is ApplyBuiltinOperator &&
         condition.operator == BuiltinOperator.Identical) {
       refineEquality(condition.arguments[0].definition,
                      condition.arguments[1].definition,
                      trueCont,
                      falseCont);
       return;
     }
 
     push(trueCont);
     push(falseCont);
   }
 
   @override
   Expression traverseLetCont(LetCont node) {
     for (Continuation cont in node.continuations) {
-      if (cont.hasExactlyOneUse &&
-          (cont.firstRef.parent is InvokeMethod ||
-           cont.firstRef.parent is TypeCast ||
-           cont.firstRef.parent is Branch)) {
-        // Do not push the continuation here.
-        // visitInvokeMethod, visitBranch, and visitTypeCast will do that.
+      if (cont.hasExactlyOneUse && cont.firstRef.parent is Branch) {
+        // Do not push the branch continuations here. visitBranch will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }