anchor.diff:  }
   
   class PrintContinuation extends ExpressionContinuation {
  -  final ExpressionState state;
  -
  -  PrintContinuation(this.state);
  +  final ExpressionContinuation continuation;
  +
  +  PrintContinuation(this.continuation);
   
     Configuration call(Value v) {
       print(v.value);
  -    return new ContinuationConfiguration(
  -        state.continuation, Value.nullInstance);
  +    return new ContinuationConfiguration(continuation, Value.nullInstance);
     }
   }
   
   class PropertyGetContinuation extends ExpressionContinuation {
     final Name name;
  -  final ExpressionState state;
  -
  -  PropertyGetContinuation(this.name, this.state);
  +  final ExpressionContinuation continuation;
  +
  +  PropertyGetContinuation(this.name, this.continuation);
   
     Configuration call(Value receiver) {
       // TODO: CPS the invocation of the getter.
       Value propertyValue = receiver.class_.lookupGetter(name)(receiver);
  -    return new ContinuationConfiguration(state.continuation, propertyValue);
  +    return new ContinuationConfiguration(continuation, propertyValue);
     }
   }
   
   class PropertySetContinuation extends ExpressionContinuation {
     final Expression value;
     final Name setterName;
  -  final ExpressionState state;
  -
  -  PropertySetContinuation(this.value, this.setterName, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  PropertySetContinuation(
  +      this.value, this.setterName, this.environment, this.continuation);
   
     Configuration call(Value receiver) {
  -    var cont = new SetterContinuation(receiver, setterName, state);
  -    return new ExpressionConfiguration(value, state.withContinuation(cont));
  +    var cont = new SetterContinuation(receiver, setterName, continuation);
  +    return new ExpressionConfiguration(value, environment, cont);
     }
   }
   
   class SetterContinuation extends ExpressionContinuation {
     final Value receiver;
     final Name name;
  -  final ExpressionState state;
  -
  -  SetterContinuation(this.receiver, this.name, this.state);
  +  final ExpressionContinuation continuation;
  +
  +  SetterContinuation(this.receiver, this.name, this.continuation);
   
     Configuration call(Value v) {
       Setter setter = receiver.class_.lookupSetter(name);
       setter(receiver, v);
  -    return new ContinuationConfiguration(state.continuation, v);
  +    return new ContinuationConfiguration(continuation, v);
     }
   }
   
   class StaticInvocationContinuation extends ExpressionContinuation {
  -  final ExpressionState state;
  -
  -  StaticInvocationContinuation(this.state);
  +  final ExpressionContinuation continuation;
  +
  +  StaticInvocationContinuation(this.continuation);
   
     Configuration call(Value v) {
  -    return new ContinuationConfiguration(state.continuation, v);
  +    return new ContinuationConfiguration(continuation, v);
     }
   }
   
   class MethodInvocationContinuation extends ExpressionContinuation {
     final Arguments arguments;
     final Name methodName;
  -  final ExpressionState state;
  -
  -  MethodInvocationContinuation(this.arguments, this.methodName, this.state);
  +  final Environment environment;
  +  final ExpressionContinuation continuation;
  +
  +  MethodInvocationContinuation(
  +      this.arguments, this.methodName, this.environment, this.continuation);
   
     Configuration call(Value receiver) {
       if (arguments.positional.isEmpty) {
         Value returnValue = receiver.invokeMethod(methodName);
  -      return new ContinuationConfiguration(state.continuation, returnValue);
  -    }
  -    var cont =
  -        new ArgumentsContinuation(receiver, methodName, arguments, state);
  +      return new ContinuationConfiguration(continuation, returnValue);
  +    }
  +    var cont = new ArgumentsContinuation(
  +        receiver, methodName, arguments, environment, continuation);
   
       return new ExpressionConfiguration(
  -        arguments.positional.first, state.withContinuation(cont));
  +        arguments.positional.first, environment, cont);
     }
   }
   
  
positive.code:   }
  
    Configuration visitIfStatement(IfStatement node, State state) {
      var expState = new ExpressionState.fromStatementState(state);
      var cont = new IfConditionContinuation(node.then, node.otherwise, state);
      return new ExpressionConfiguration(
          node.condition, expState.withContinuation(cont));
    }
  
    Configuration visitLabeledStatement(LabeledStatement node, State state) {
  
negative.code: 
    Configuration exec(Statement statement, State state) =>
        statement.accept1(this, state);
    Configuration eval(Expression expression, ExpressionConfiguration config) =>
        evaluator.eval(expression, config);
  
    Configuration defaultStatement(Statement node, State state) {
      throw notImplemented(
  