dart2js cps: Rewrite mutable variables to continuation parameters.

pkg/compiler/lib/src/cps_ir/type_propagation.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.
 
 import 'optimizers.dart';
 
 import '../constants/constant_system.dart';
 import '../resolution/operators.dart';
 import '../constants/values.dart';
 import '../dart_types.dart' as types;
@@ skipping 581 matching lines @@
     parent.body = replacement;
     replacement.parent = parent;
     node.parent = null;
     if (unlink) {
       RemovalVisitor.remove(node);
     }
     reanalyze(replacement);
   }
 
   /// Inserts [insertedCode] before [node].
-  /// 
+  ///
   /// [node] will end up in the hole of [insertedCode], and [insertedCode]
   /// will become rooted where [node] was.
   void insertBefore(Expression node, CpsFragment insertedCode) {
     if (insertedCode.isEmpty) return; // Nothing to do.
     assert(insertedCode.isOpen);
     InteriorNode parent = node.parent;
     InteriorNode context = insertedCode.context;
 
     parent.body = insertedCode.root;
     insertedCode.root.parent = parent;
 
     // We want to recompute the types for [insertedCode] without
     // traversing the entire subtree of [node]. Temporarily close the
     // term with a dummy node while recomputing types.
-    context.body = new Unreachable(); 
+    context.body = new Unreachable();
     new ParentVisitor().visit(insertedCode.root);
     reanalyze(insertedCode.root);
 
     context.body = node;
     node.parent = context;
   }
 
   /// Make a constant primitive for [constant] and set its entry in [values].
   Constant makeConstantPrimitive(ConstantValue constant) {
     Constant primitive = new Constant(constant);
@@ skipping 18 matching lines @@
     return letPrim;
   }
 
   /// Side-effect free expressions with constant results are be replaced by:
   ///
   ///    (LetPrim p = constant (InvokeContinuation k p)).
   ///
   /// The new expression will be visited.
   ///
   /// Returns true if the node was replaced.
-  bool constifyExpression(Invoke node) {
+  bool constifyExpression(CallExpression node) {
     Continuation continuation = node.continuation.definition;
     ConstantValue constant = replacements[node];
     if (constant == null) return false;
     Constant primitive = makeConstantPrimitive(constant);
     LetPrim letPrim = makeLetPrimInvoke(primitive, continuation);
     replaceSubtree(node, letPrim);
     visitLetPrim(letPrim);
     return true;
   }
 
@@ skipping 18 matching lines @@
       visitInvokeContinuation(invoke);
       return;
     }
     if (boolifiedValue == AbstractBool.False) {
       InvokeContinuation invoke = new InvokeContinuation(falseCont, []);
       replaceSubtree(node, invoke);
       visitInvokeContinuation(invoke);
       return;
     }
 
-    if (condition is ApplyBuiltinOperator && 
+    if (condition is ApplyBuiltinOperator &&
         condition.operator == BuiltinOperator.LooseEq) {
       Primitive leftArg = condition.arguments[0].definition;
       Primitive rightArg = condition.arguments[1].definition;
       AbstractValue left = getValue(leftArg);
       AbstractValue right = getValue(rightArg);
-      if (right.isNullConstant && 
+      if (right.isNullConstant &&
           lattice.isDefinitelyNotNumStringBool(left)) {
         // Rewrite:
         //   if (x == null) S1 else S2
         //     =>
         //   if (x) S2 else S1   (note the swapped branches)
         Branch branch = new Branch(new IsTrue(leftArg), falseCont, trueCont);
         replaceSubtree(node, branch);
         return;
-      } else if (left.isNullConstant && 
+      } else if (left.isNullConstant &&
                  lattice.isDefinitelyNotNumStringBool(right)) {
         Branch branch = new Branch(new IsTrue(rightArg), falseCont, trueCont);
         replaceSubtree(node, branch);
         return;
       }
     }
   }
 
   /// Replaces [node] with a more specialized instruction, if possible.
   ///
@@ skipping 115 matching lines @@
                                   target,
                                   getDartArgument(node, 0));
       set.body = new InvokeContinuation(cont, <Primitive>[]);
       replaceSubtree(node, set);
       visitSetField(set);
       return true;
     }
   }
 
   /// Create a check that throws if [index] is not a valid index on [list].
-  /// 
+  ///
   /// This function assumes that [index] is an integer.
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
   CpsFragment makeBoundsCheck(Primitive list,
                               Primitive index,
                               SourceInformation sourceInfo) {
     CpsFragment cps = new CpsFragment(sourceInfo);
     Continuation fail = cps.letCont();
     Primitive isTooSmall = cps.applyBuiltin(
@@ skipping 30 matching lines @@
 
   /// Counts number of index accesses on [list] and determines based on
   /// that number if we should try to inline them.
   ///
   /// This is a short-term solution to avoid inserting a lot of bounds checks,
   /// since there is currently no optimization for eliminating them.
   bool hasTooManyIndexAccesses(Primitive list) {
     int count = 0;
     for (Reference ref = list.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
-      if (use is InvokeMethod && 
+      if (use is InvokeMethod &&
           (use.selector.isIndex || use.selector.isIndexSet) &&
           getDartReceiver(use) == list) {
         ++count;
       } else if (use is GetIndex && use.object.definition == list) {
         ++count;
       } else if (use is SetIndex && use.object.definition == list) {
         ++count;
       }
       if (count > 2) return true;
     }
     return false;
   }
 
   /// Tries to replace [node] with one or more direct array access operations.
   ///
   /// Returns `true` if the node was replaced.
   bool specializeArrayAccess(InvokeMethod node) {
     Primitive list = getDartReceiver(node);
     AbstractValue listValue = getValue(list);
     // Ensure that the object is a native list or null.
     if (!lattice.isDefinitelyNativeList(listValue, allowNull: true)) {
       return false;
     }
-    bool isFixedLength = 
+    bool isFixedLength =
         lattice.isDefinitelyFixedNativeList(listValue, allowNull: true);
     bool isMutable =
         lattice.isDefinitelyMutableNativeList(listValue, allowNull: true);
     SourceInformation sourceInfo = node.sourceInformation;
     Continuation cont = node.continuation.definition;
     switch (node.selector.name) {
       case 'length':
         if (!node.selector.isGetter) return false;
         CpsFragment cps = new CpsFragment(sourceInfo);
         cps.invokeContinuation(cont, [cps.letPrim(new GetLength(list))]);
@@ skipping 102 matching lines @@
           }
         }
 
         // Rewrite the iterator variable to 'current' and 'index' variables.
         Primitive originalLength = new GetLength(list);
         originalLength.hint = new OriginalLengthEntity();
         MutableVariable index = new MutableVariable(new LoopIndexEntity());
         MutableVariable current = new MutableVariable(new LoopItemEntity());
 
         // Rewrite all uses of the iterator.
-        while (iterator.firstRef != null) { 
+        while (iterator.firstRef != null) {
           InvokeMethod use = iterator.firstRef.parent;
           Continuation useCont = use.continuation.definition;
-          if (use.selector == currentSelector) { 
+          if (use.selector == currentSelector) {
             // Rewrite iterator.current to a use of the 'current' variable.
             Parameter result = useCont.parameters.single;
             if (result.hint != null) {
               // If 'current' was originally moved into a named variable, use
               // that variable name for the mutable variable.
-              current.hint = result.hint; 
+              current.hint = result.hint;
             }
-            LetPrim let = 
+            LetPrim let =
                 makeLetPrimInvoke(new GetMutableVariable(current), useCont);
             replaceSubtree(use, let);
           } else {
             assert (use.selector == moveNextSelector);
-            // Rewrite iterator.moveNext() to: 
+            // Rewrite iterator.moveNext() to:
             //
             //   if (index < list.length) {
             //     current = null;
             //     continuation(false);
             //   } else {
             //     current = list[index];
             //     index = index + 1;
             //     continuation(true);
             //   }
             //
             // (The above does not show concurrent modification checks)
 
             // [cps] contains the code we insert instead of moveNext().
             CpsFragment cps = new CpsFragment(node.sourceInformation);
 
             // We must check for concurrent modification when calling moveNext.
             // When moveNext is used as a loop condition, the check prevents
-            // `index < list.length` from becoming the loop condition, and we 
+            // `index < list.length` from becoming the loop condition, and we
             // get code like this:
             //
             //    while (true) {
             //      if (originalLength !== list.length) throw;
-            //      if (index < list.length) { 
+            //      if (index < list.length) {
             //        ...
-            //      } else { 
-            //        ... 
-            //        break; 
+            //      } else {
+            //        ...
+            //        break;
             //      }
             //    }
             //
             // For loops, we therefore check for concurrent modification before
             // invoking the recursive continuation, so the loop becomes:
             //
             //    if (originalLength !== list.length) throw;
             //    while (index < list.length) {
             //      ...
             //      if (originalLength !== list.length) throw;
             //    }
             //
-            // The check before the loop can often be eliminated because it 
+            // The check before the loop can often be eliminated because it
             // follows immediately after the 'iterator' call.
             InteriorNode parent = getEffectiveParent(use);
             if (!isFixedLength) {
               if (parent is Continuation && parent.isRecursive) {
                 // Check for concurrent modification before every invocation
                 // of the continuation.
-                // TODO(asgerf): Do this in a continuation so multiple 
+                // TODO(asgerf): Do this in a continuation so multiple
                 //               continues can share the same code.
-                for (Reference ref = parent.firstRef; 
-                     ref != null; 
+                for (Reference ref = parent.firstRef;
+                     ref != null;
                      ref = ref.next) {
                   Expression invocationCaller = ref.parent;
                   if (getEffectiveParent(invocationCaller) == iteratorCont) {
                     // No need to check for concurrent modification immediately
                     // after the call to 'iterator'.
                     continue;
                   }
                   CpsFragment check = makeConcurrentModificationCheck(
                       list, originalLength, sourceInfo);
                   insertBefore(invocationCaller, check);
                 }
               } else {
                 cps.append(makeConcurrentModificationCheck(
                     list, originalLength, sourceInfo));
               }
             }
 
             // Check if there are more elements.
             Primitive hasMore = cps.applyBuiltin(
                 BuiltinOperator.NumLt,
                 [cps.getMutable(index), cps.letPrim(new GetLength(list))]);
 
             // Return false if there are no more.
             CpsFragment falseBranch = cps.ifFalse(hasMore);
             falseBranch
               ..setMutable(current, falseBranch.makeNull())
               ..invokeContinuation(useCont, [falseBranch.makeFalse()]);
 
             // Return true if there are more element.
-            cps.setMutable(current, 
+            cps.setMutable(current,
                 cps.letPrim(new GetIndex(list, cps.getMutable(index))));
             cps.setMutable(index, cps.applyBuiltin(
                 BuiltinOperator.NumAdd,
                 [cps.getMutable(index), cps.makeOne()]));
             cps.invokeContinuation(useCont, [cps.makeTrue()]);
 
             // Replace the moveNext() call. It will be visited later.
             replaceSubtree(use, cps.result);
           }
         }
@@ skipping 19 matching lines @@
 
       // TODO(asgerf): Rewrite 'add', 'removeLast', ...
 
       default:
         return false;
     }
   }
 
   /// If [prim] is the parameter to a call continuation, returns the
   /// corresponding call.
-  Invoke getInvocationWithResult(Primitive prim) {
+  CallExpression getCallWithResult(Primitive prim) {
     if (prim is Parameter && prim.parent is Continuation) {
       Continuation cont = prim.parent;
       if (cont.hasExactlyOneUse) {
         Node use = cont.firstRef.parent;
-        if (use is Invoke) {
+        if (use is CallExpression) {
           return use;
         }
       }
     }
     return null;
   }
 
   /// Returns the first parent of [node] that is not a pure expression.
   InteriorNode getEffectiveParent(Expression node) {
     while (true) {
@@ skipping 40 matching lines @@
           target,
           new Selector.fromElement(target),
           node.arguments,
           node.continuation,
           node.sourceInformation);
       node.receiver.unlink();
       replaceSubtree(node, invoke, unlink: false);
       visitInvokeStatic(invoke);
       return true;
     }
-    Invoke tearOffInvoke = getInvocationWithResult(tearOff);
+    CallExpression tearOffInvoke = getCallWithResult(tearOff);
     if (tearOffInvoke is InvokeMethod && tearOffInvoke.selector.isGetter) {
       Selector getter = tearOffInvoke.selector;
 
       // TODO(asgerf): Support torn-off intercepted methods.
       if (isInterceptedSelector(getter)) return false;
 
       Continuation getterCont = tearOffInvoke.continuation.definition;
 
       // TODO(asgerf): Support torn-off intercepted methods.
       if (isInterceptedSelector(getter)) return false;
@@ skipping 1027 matching lines @@
   Map<Definition, AbstractValue> values;
 
   ResetAnalysisInfo(this.reachableNodes, this.values);
 
   visit(Node node) {
     reachableNodes.remove(node);
     if (node is Definition) values.remove(node);
     node.accept(this);
   }
 }