anchor.diff:          }
           if (!isExtendable) return false;
           Primitive addedList = getDartArgument(node, 0);
  -        if (addedList is! LiteralList) return false;
  +        // Rewrite addAll([x1, ..., xN]) to push(x1, ..., xN).
  +        // Ensure that the list is not mutated between creation and use.
  +        // We aim for the common case where this is the only use of the list, 
  +        // which also guarantees that this list is not mutated before use.
  +        if (addedList is! LiteralList || !addedList.hasExactlyOneUse) {
  +          return false;
  +        }
           LiteralList addedLiteral = addedList;
           CpsFragment cps = new CpsFragment(sourceInfo);
           cps.invokeBuiltin(BuiltinMethod.Push, 
  
positive.code:     }
    }
  
    Primitive visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
      if (node.method == BuiltinMethod.Push) {
        // Convert consecutive pushes into a single push.
        InteriorNode parent = getEffectiveParent(node.parent);
  
negative.code:         ApplyBuiltinMethod previous = parent.primitive;
          if (previous.method == BuiltinMethod.Push && 
              previous.receiver.definition == node.receiver.definition) {
            // We found two consecutive pushes. 
            // Move all arguments from the first push onto the second one.
            List<Reference<Primitive>> arguments = previous.arguments;
            for (Reference ref in arguments) {
              ref.parent = node;
            }
            arguments.addAll(node.arguments);
            node.arguments = arguments;
            // Elimnate the old push.
            previous.receiver.unlink();
            assert(previous.hasNoUses);
            parent.parent.body = parent.body;
            parent.body.parent = parent.parent;
          }
        }
      }
    }
  
    Primitive visitTypeTest(TypeTest node) {
  