anchor.diff:    }
   
     void visitMutableVariable(MutableVariable node) {
  -    // [MutableVariable]s are bound either as parameters to
  -    // [FunctionDefinition]s, by [LetMutable].
  -    if (node.parent is FunctionDefinition) {
  -      // Just like immutable parameters, the values of mutable parameters are
  -      // never constant.
  -      // TODO(karlklose): remove reference to the element model.
  -      Entity source = node.hint;
  -      TypeMask type = (source is ParameterElement)
  -          ? typeSystem.getParameterType(source)
  -          : typeSystem.dynamicType;
  -      setValue(node, nonConstant(type));
  -    } else if (node.parent is LetMutable) {
  -      // Mutable values bound by LetMutable could have known values.
  -    } else {
  -      internalError(node.hint, "Unexpected parent of MutableVariable");
  -    }
     }
   
     void visitParameter(Parameter node) {
  -    Entity source = node.hint;
  -    // TODO(karlklose): remove reference to the element model.
  -    TypeMask type = (source is ParameterElement)
  -        ? typeSystem.getParameterType(source)
  -        : typeSystem.dynamicType;
  -    if (node.parent is FunctionDefinition) {
  -      // Functions may escape and thus their parameters must be non-constant.
  -      setValue(node, nonConstant(type));
  -    } else if (node.parent is Continuation) {
  -      // Continuations on the other hand are local, and parameters can have
  -      // some other abstract value than non-constant.
  -    } else {
  -      internalError(node.hint, "Unexpected parent of Parameter: ${node.parent}");
  -    }
     }
   
     void visitContinuation(Continuation node) {
  
positive.code:   void visit(Node node) { node.accept(this); }
  
    void visitFunctionDefinition(FunctionDefinition node) {
      if (node.thisParameter != null) {
        setValue(node.thisParameter,
                 nonConstant(typeSystem.getReceiverType(node.element)));
      }
      node.parameters.forEach(visit);
      push(node.body);
    }
  
  
negative.code: 
    TypeMaskSystem get typeSystem => lattice.typeSystem;
  
    JavaScriptBackend get backend => typeSystem.backend;
  
    AbstractValue get nothing => lattice.nothing;
  
    AbstractValue nonConstant([TypeMask type]) => lattice.nonConstant(type);
  