anchor.diff:  /// Represents the configuration for evaluating an [Expression].
   class ExpressionConfiguration extends Configuration {
     final Expression expression;
  -  final ExpressionState state;
  -
  -  ExpressionConfiguration(this.expression, this.state);
  +
  +  /// Environment in which the expression is evaluated.
  +  final Environment environment;
  +
  +  /// Next continuation to be applied.
  +  final ExpressionContinuation continuation;
  +
  +  ExpressionConfiguration(this.expression, this.environment, this.continuation);
   
     Configuration step(StatementExecuter executer) =>
  -      executer.eval(expression, state);
  +      executer.eval(expression, this);
   }
   
   /// Represents an expression continuation.
  
positive.code: 
    Configuration visitReturnStatement(ReturnStatement node, State state) {
      assert(state.returnContinuation != null);
      // The new ExpressionState contains the next expression continuation.
      var expState = new ExpressionState.fromStatementState(state)
          .withContinuation(state.returnContinuation);
      return new ExpressionConfiguration(
          node.expression ?? new NullLiteral(), expState);
    }
  
    Configuration visitVariableDeclaration(
        VariableDeclaration node, State state) {
      if (node.initializer != null) {
        var expState = new ExpressionState.fromStatementState(state);
        var cont = new VariableInitializerContinuation(
            node, state.environment, state.statementConfiguration);
        return new ExpressionConfiguration(
            node.initializer, expState.withContinuation(cont));
      }
      state.environment.expand(node, Value.nullInstance);
      return state.statementConfiguration;
  
negative.code:   }
  
    Configuration visitMethodInvocation(
        MethodInvocation node, ExpressionConfiguration config) {
      // Currently supports only method invocation with <2 arguments and is used
      // to evaluate implemented operators for int, double and String values.
      var cont = new MethodInvocationContinuation(
          node.arguments, node.name, config.environment, config.continuation);
  
      return new ExpressionConfiguration(node.receiver, config.environment, cont);
    }
  
    Configuration visitConstructorInvocation(
        ConstructorInvocation node, ExpressionConfiguration config) {
      Class class_ = new Class(node.target.enclosingClass.reference);
  
      // Currently we don't support initializers.
  