anchor.diff:    }
   
     Expression visitConstant(Constant node) {
  -    if (!environment.isEmpty) {
  +    if (isRhsPropagationAllowed && !environment.isEmpty) {
         Constant constant = getRightHandConstant(environment.last);
         if (constant != null && constant.value == node.value) {
           return visitExpression(environment.removeLast());
  
positive.code:   /// foo() must be evaluated before bar(), so the propagation is only possible
    /// by commuting the operator.
    Expression visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
      if (environment.isEmpty || getLeftHand(environment.last) == null) {
        // If there is no recent assignment that might propagate, so there is no
        // opportunity for optimization here.
        _rewriteList(node.arguments);
        return node;
      }
      Variable propagatableVariable = getLeftHand(environment.last);
      BuiltinOperator commuted = commuteBinaryOperator(node.operator);
      if (commuted != null) {
        assert(node.arguments.length == 2); // Only binary operators can commute.
        Expression left = node.arguments[0];
        if (left is VariableUse && propagatableVariable == left.variable) {
          Expression right = node.arguments[1];
          if (right is This ||
              (right is VariableUse &&
               propagatableVariable != right.variable &&
               !constantEnvironment.containsKey(right.variable))) {
            // An assignment can be propagated if we commute the operator.
            node.operator = commuted;
            node.arguments[0] = right;
            node.arguments[1] = left;
          }
        }
      }
      _rewriteList(node.arguments);
      return node;
    }
  
  
negative.code: 
    /// Process nodes right-to-left, the opposite of evaluation order in the case
    /// of argument lists..
    void _rewriteList(List<Node> nodes, {bool rhsPropagation: true}) {
      allowRhsPropagation.add(rhsPropagation);
      for (int i = nodes.length - 1; i >= 0; --i) {
        nodes[i] = visitExpression(nodes[i]);
      }
      allowRhsPropagation.removeLast();
    }
  
    Expression visitInvokeStatic(InvokeStatic node) {
  