anchor.diff:    final Value receiver;
     final Name methodName;
     final Arguments arguments;
  -  final ExpressionState state;
  -
  -  ArgumentsContinuation(
  -      this.receiver, this.methodName, this.arguments, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  ArgumentsContinuation(this.receiver, this.methodName, this.arguments,
  +      this.environment, this.continuation);
   
     Configuration call(Value value) {
       // Currently evaluates only one argument, for simple method invocations
       // with 1 argument.
       Value returnValue = receiver.invokeMethod(methodName, value);
  -    return new ContinuationConfiguration(state.continuation, returnValue);
  +    return new ContinuationConfiguration(continuation, returnValue);
     }
   }
   
   class VariableSetContinuation extends ExpressionContinuation {
  -  final ExpressionState state;
     final VariableDeclaration variable;
  -
  -  VariableSetContinuation(this.state, this.variable);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  VariableSetContinuation(this.variable, this.environment, this.continuation);
   
     Configuration call(Value value) {
  -    state.environment.assign(variable, value);
  -    return new ContinuationConfiguration(state.continuation, value);
  +    environment.assign(variable, value);
  +    return new ContinuationConfiguration(continuation, value);
     }
   }
   
   class NotContinuation extends ExpressionContinuation {
  -  final ExpressionState state;
  -
  -  NotContinuation(this.state);
  +  final ExpressionContinuation continuation;
  +
  +  NotContinuation(this.continuation);
   
     Configuration call(Value value) {
       Value notValue = identical(Value.trueInstance, value)
           ? Value.falseInstance
           : Value.trueInstance;
  -    return new ContinuationConfiguration(state.continuation, notValue);
  +    return new ContinuationConfiguration(continuation, notValue);
     }
   }
   
   class OrContinuation extends ExpressionContinuation {
     final Expression right;
  -  final ExpressionState state;
  -
  -  OrContinuation(this.right, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  OrContinuation(this.right, this.environment, this.continuation);
   
     Configuration call(Value left) {
       return identical(Value.trueInstance, left)
  -        ? new ContinuationConfiguration(state.continuation, Value.trueInstance)
  -        : new ExpressionConfiguration(right, state);
  +        ? new ContinuationConfiguration(continuation, Value.trueInstance)
  +        : new ExpressionConfiguration(right, environment, continuation);
     }
   }
   
   class AndContinuation extends ExpressionContinuation {
     final Expression right;
  -  final ExpressionState state;
  -
  -  AndContinuation(this.right, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  AndContinuation(this.right, this.environment, this.continuation);
   
     Configuration call(Value left) {
       return identical(Value.falseInstance, left)
  -        ? new ContinuationConfiguration(state.continuation, Value.falseInstance)
  -        : new ExpressionConfiguration(right, state);
  +        ? new ContinuationConfiguration(continuation, Value.falseInstance)
  +        : new ExpressionConfiguration(right, environment, continuation);
     }
   }
   
   class ConditionalContinuation extends ExpressionContinuation {
     final Expression then;
     final Expression otherwise;
  -  final ExpressionState state;
  -
  -  ConditionalContinuation(this.then, this.otherwise, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  ConditionalContinuation(
  +      this.then, this.otherwise, this.environment, this.continuation);
   
     Configuration call(Value value) {
       return identical(Value.trueInstance, value)
  -        ? new ExpressionConfiguration(then, state)
  -        : new ExpressionConfiguration(otherwise, state);
  +        ? new ExpressionConfiguration(then, environment, continuation)
  +        : new ExpressionConfiguration(otherwise, environment, continuation);
     }
   }
   
   class StringConcatenationContinuation extends ExpressionContinuation {
     final List<Expression> expressions;
  -  final ExpressionState state;
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
   
     int _currentPosition = 0;
     final List<Value> _values = <Value>[];
   
  -  StringConcatenationContinuation(this.expressions, this.state);
  +  StringConcatenationContinuation(
  +      this.expressions, this.environment, this.continuation);
   
     Configuration call(Value value) {
       _values.add(value);
  
positive.code: 
    Configuration visitExpressionStatement(
        ExpressionStatement node, State state) {
      return new ExpressionConfiguration(
          node.expression, new ExpressionState.fromStatementState(state));
    }
  
    Configuration visitBlock(Block node, State state) {
  
negative.code:   }
  
    Configuration visitIfStatement(IfStatement node, State state) {
      var cont = new IfConditionContinuation(node.then, node.otherwise, state);
  
      return new ExpressionConfiguration(node.condition, state.environment, cont);
    }
  
    Configuration visitLabeledStatement(LabeledStatement node, State state) {
  