anchor.diff:  /// returned and applied
   /// - it returns with or without value, TBD
   /// - it throws, TBD
  -class StatementExecuter extends StatementVisitor1<Continuation> {
  +class StatementExecuter extends StatementVisitor1<Configuration> {
     Evaluator evaluator = new Evaluator();
   
  -  void trampolinedExecution(Continuation continuation) {
  -    while (continuation != null) {
  -      continuation = exec(continuation.statement, continuation.state);
  -    }
  -  }
  -
  -  Continuation exec(Statement statement, state) =>
  +  void trampolinedExecution(Configuration configuration) {
  +    while (configuration != null) {
  +      configuration = configuration.step(this);
  +    }
  +  }
  +
  +  Configuration exec(Statement statement, State state) =>
         statement.accept1(this, state);
  -  Value eval(Expression expression, env) => evaluator.eval(expression, env);
  -
  -  Continuation defaultStatement(Statement node, state) {
  +  Configuration eval(Expression expression, ExpressionState state) =>
  +      evaluator.eval(expression, state);
  +
  +  Configuration defaultStatement(Statement node, state) {
       throw notImplemented(
           m: "Execution is not implemented for statement:\n$node ");
     }
   
  -  Continuation visitInvalidStatement(InvalidStatement node, state) {
  +  Configuration visitInvalidStatement(InvalidStatement node, state) {
       throw "Invalid statement at ${node.location}";
     }
   
  -  Continuation visitExpressionStatement(ExpressionStatement node, state) {
  -    eval(node.expression, state.environment);
  -    return state.continuation;
  -  }
  -
  -  Continuation visitBlock(Block node, state) {
  +  Configuration visitExpressionStatement(ExpressionStatement node, state) {
  +    return new ExpressionConfiguration(
  +        node.expression, new ExpressionState.fromStatementState(state));
  +  }
  +
  +  Configuration visitBlock(Block node, state) {
       if (node.statements.isEmpty) {
  -      return state.continuation;
  +      return state.statementConfiguration;
       }
       State blockState =
           state.withEnvironment(new Environment(state.environment));
  -    Continuation cont = state.continuation;
  +    StatementConfiguration configuration = state.statementConfiguration;
       for (Statement s in node.statements.reversed) {
  -      cont = new Continuation(s, blockState.withContinuation(cont));
  -    }
  -    return cont;
  -  }
  -
  -  Continuation visitEmptyStatement(EmptyStatement node, state) {
  -    return state.continuation;
  -  }
  -
  -  Continuation visitIfStatement(IfStatement node, state) {
  -    Value cond = eval(node.condition, state.environment).toBoolean();
  -    if (identical(Value.trueInstance, cond)) {
  -      return new Continuation(node.then, state);
  -    } else if (node.otherwise != null) {
  -      return new Continuation(node.otherwise, state);
  -    }
  -    return state.continuation;
  -  }
  -
  -  Continuation visitLabeledStatement(LabeledStatement node, state) {
  -    return new Continuation(node.body, state.withBreak(node));
  -  }
  -
  -  Continuation visitBreakStatement(BreakStatement node, state) {
  -    return state.lookupLabel(node.target).continuation;
  -  }
  -
  -  Continuation visitWhileStatement(WhileStatement node, state) {
  -    Value cond = eval(node.condition, state.environment).toBoolean();
  -    if (identical(Value.trueInstance, cond)) {
  -      // Add continuation for the While statement to the linked list.
  -      Continuation cont = new Continuation(node, state);
  -      // Continuation for the body of the loop.
  -      return new Continuation(node.body, state.withContinuation(cont));
  -    }
  -    return state.continuation;
  -  }
  -
  -  Continuation visitDoStatement(DoStatement node, state) {
  +      configuration = new StatementConfiguration(
  +          s, blockState.withConfiguration(configuration));
  +    }
  +    return configuration;
  +  }
  +
  +  Configuration visitEmptyStatement(EmptyStatement node, state) {
  +    return state.statementConfiguration;
  +  }
  +
  +  Configuration visitIfStatement(IfStatement node, 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) {
  +    return new StatementConfiguration(node.body, state.withBreak(node));
  +  }
  +
  +  Configuration visitBreakStatement(BreakStatement node, state) {
  +    return state.lookupLabel(node.target).configuration;
  +  }
  +
  +  Configuration visitWhileStatement(WhileStatement node, state) {
  +    var expState = new ExpressionState.fromStatementState(state);
  +    var cont = new WhileConditionContinuation(node, state);
  +
  +    return new ExpressionConfiguration(
  +        node.condition, expState.withContinuation(cont));
  +  }
  +
  +  Configuration visitDoStatement(DoStatement node, state) {
       WhileStatement whileStatement =
           new WhileStatement(node.condition, node.body);
  -    Continuation cont = new Continuation(whileStatement, state);
  -    return new Continuation(node.body, state.withContinuation(cont));
  -  }
  -
  -  Continuation visitVariableDeclaration(VariableDeclaration node, state) {
  -    Value value = node.initializer != null
  -        ? eval(node.initializer, state.environment)
  -        : Value.nullInstance;
  -    state.environment.expand(node, value);
  -    return state.continuation;
  -  }
  -}
  +    StatementConfiguration configuration =
  +        new StatementConfiguration(whileStatement, state);
  +
  +    return new StatementConfiguration(
  +        node.body, state.withConfiguration(configuration));
  +  }
  +
  +  Configuration visitReturnStatement(ReturnStatement node, 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) {
  +    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;
  +  }
  +}
  +
  +// ------------------------------------------------------------------------
  +//                                VALUES
  +// ------------------------------------------------------------------------
   
   typedef Value Getter(Value receiver);
   typedef void Setter(Value receiver, Value value);
  
positive.code:   }
  }
  
  /// Represent the continuation for execution of statement.
  class Continuation {
    final Statement statement;
    final State state;
  
    Continuation(this.statement, this.state);
  }
  
  /// Represents a labeled statement, the corresponding continuation and the
  /// enclosing label.
  class Label {
    final LabeledStatement statement;
    final Continuation continuation;
    final Label enclosingLabel;
  
    Label(this.statement, this.continuation, this.enclosingLabel);
  
    Label lookupLabel(LabeledStatement s) {
      if (identical(s, statement)) return this;
      assert(enclosingLabel != null);
      return enclosingLabel.lookupLabel(s);
    }
  }
  
  
negative.code: }
  
  /// Evaluate expressions.
  class Evaluator extends ExpressionVisitor1<Configuration> {
    Configuration eval(Expression expr, ExpressionState state) =>
        expr.accept1(this, state);
  
    Configuration defaultExpression(Expression node, state) {
      throw new NotImplemented('Evaluation for expressions of type '
          '${node.runtimeType} is not implemented.');
    }
  
    Configuration visitInvalidExpression1(InvalidExpression node, state) {
      throw 'Invalid expression at ${node.location.toString()}';
    }
  
    Configuration visitVariableGet(VariableGet node, state) {
      Value value = state.environment.lookup(node.variable);
      return new ContinuationConfiguration(state.continuation, value);
    }
  
    Configuration visitVariableSet(VariableSet node, state) {
      var cont = new VariableSetContinuation(state, node.variable);
      return new ExpressionConfiguration(
          node.value, state.withContinuation(cont));
    }
  
    Configuration visitPropertyGet(PropertyGet node, state) {
      var cont = new PropertyGetContinuation(node.name, state);
      return new ExpressionConfiguration(
          node.receiver, state.withContinuation(cont));
    }
  
    Configuration visitPropertySet(PropertySet node, state) {
      var cont = new PropertySetContinuation(node.value, node.name, state);
      return new ExpressionConfiguration(
          node.receiver, state.withContinuation(cont));
    }
  
    Configuration visitStaticGet(StaticGet node, state) =>
        defaultExpression(node, state);
    Configuration visitStaticSet(StaticSet node, state) =>
        defaultExpression(node, state);
  
    Configuration visitStaticInvocation(StaticInvocation node, state) {
      if ('print' == node.name.toString()) {
        return new ExpressionConfiguration(node.arguments.positional.first,
            state.withContinuation(new PrintContinuation(state)));
      } else {
        // Currently supports only static invocations with no arguments.
        if (node.arguments.positional.isEmpty && node.arguments.named.isEmpty) {
          State statementState = new State.initial()
              .withExpressionContinuation(state.continuation)
              .withConfiguration(new ExitConfiguration(state.continuation));
  
          return new StatementConfiguration(
              node.target.function.body, statementState);
        }
        throw new NotImplemented(
            'Support for static invocation with arguments is not implemented');
      }
    }
  
    Configuration visitMethodInvocation(MethodInvocation node, state) {
      // 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, state);
  
      return new ExpressionConfiguration(
          node.receiver, state.withContinuation(cont));
    }
  
    Configuration visitConstructorInvocation(ConstructorInvocation node, state) {
      Class class_ = new Class(node.target.enclosingClass.reference);
  
      // Currently we don't support initializers.
      // TODO: Modify to respect dart semantics for initialization.
      //  1. Init fields and eval initializers, repeat the same with super.
      //  2. Eval the Function body of the constructor.
      List<Value> fields = <Value>[];
  
      return new ContinuationConfiguration(
          state.continuation, new ObjectValue(class_, fields));
    }
  
    Configuration visitNot(Not node, state) {
      return new ExpressionConfiguration(
          node.operand, state.withContinuation(new NotContinuation(state)));
    }
  
    Configuration visitLogicalExpression(LogicalExpression node, state) {
      if ('||' == node.operator) {
        var cont = new OrContinuation(node.right, state);
        return new ExpressionConfiguration(
            node.left, state.withContinuation(cont));
      } else {
        assert('&&' == node.operator);
        var cont = new AndContinuation(node.right, state);
        return new ExpressionConfiguration(
            node.left, state.withContinuation(cont));
      }
    }
  
    Configuration visitConditionalExpression(ConditionalExpression node, state) {
      var cont = new ConditionalContinuation(node.then, node.otherwise, state);
      return new ExpressionConfiguration(
          node.condition, state.withContinuation(cont));
    }
  
    Configuration visitStringConcatenation(StringConcatenation node, state) {
      var cont = new StringConcatenationContinuation(node.expressions, state);
      return new ExpressionConfiguration(
          node.expressions.first, state.withContinuation(cont));
    }
  
    // Evaluation of BasicLiterals.
    Configuration visitStringLiteral(StringLiteral node, state) {
      return new ContinuationConfiguration(
          state.continuation, new StringValue(node.value));
    }
  
    Configuration visitIntLiteral(IntLiteral node, state) {
      return new ContinuationConfiguration(
          state.continuation, new IntValue(node.value));
    }
  
    Configuration visitDoubleLiteral(DoubleLiteral node, state) {
      return new ContinuationConfiguration(
          state.continuation, new DoubleValue(node.value));
    }
  
    Configuration visitBoolLiteral(BoolLiteral node, state) {
      Value value = node.value ? Value.trueInstance : Value.falseInstance;
      return new ContinuationConfiguration(state.continuation, value);
    }
  
    Configuration visitNullLiteral(NullLiteral node, state) {
      return new ContinuationConfiguration(
          state.continuation, Value.nullInstance);
    }
  
    Configuration visitLet(Let node, state) {
      var letCont = new LetContinuation(node.variable, node.body, state);
      return new ExpressionConfiguration(
          node.variable.initializer, state.withContinuation(letCont));
    }
  }
  
  /// Represents a state for statement execution.
  class State {
    final Environment environment;
    final Label labels;
    final StatementConfiguration statementConfiguration;
  
    final ExpressionContinuation returnContinuation;
  
    State(this.environment, this.labels, this.statementConfiguration,
        this.returnContinuation);
  
    State.initial() : this(new Environment.empty(), null, null, null);
  
    State withEnvironment(Environment env) {
      return new State(env, labels, statementConfiguration, returnContinuation);
    }
  
    State withBreak(Statement stmt) {
      Label breakLabels = new Label(stmt, statementConfiguration, labels);
      return new State(
          environment, breakLabels, statementConfiguration, returnContinuation);
    }
  
    State withConfiguration(Configuration config) {
      return new State(environment, labels, config, returnContinuation);
    }
  
    State withExpressionContinuation(ExpressionContinuation cont) {
      return new State(environment, labels, statementConfiguration, cont);
    }
  
    Label lookupLabel(LabeledStatement s) {
  