anchor.diff:      assert(program.libraries.isEmpty);
       Procedure mainMethod = program.mainMethod;
       Statement statementBlock = mainMethod.function.body;
  -    visitor.exec(statementBlock, env);
  -  }
  -}
  -
  -class InvalidExpressionError {
  -  InvalidExpression expression;
  -
  -  InvalidExpressionError(this.expression);
  -
  -  String toString() =>
  -      'Invalid expression at ${expression.location.toString()}';
  +    Continuation cont = new Continuation(statementBlock, new State.initial());
  +    visitor.trampolinedExecution(cont);
  +  }
   }
   
   class Binding {
  
positive.code:   }
  }
  
  /// Executes statements.
  class StatementExecuter extends StatementVisitor1 {
    Evaluator evaluator = new Evaluator();
  
    exec(Statement statement, env) => statement.accept1(this, env);
    eval(Expression expression, env) => evaluator.eval(expression, env);
  
    defaultStatement(Statement node, env) {
      throw notImplemented(
          m: "Execution is not implemented for statement:\n$node ");
    }
  
    visitInvalidStatement(InvalidStatement node, env) {
      throw "Invalid statement at ${node.location}";
    }
  
    visitExpressionStatement(ExpressionStatement node, env) {
      return eval(node.expression, env);
    }
  
    visitBlock(Block node, env) {
      Environment blockEnv = new Environment(env);
      for (Statement s in node.statements) {
        exec(s, blockEnv);
      }
    }
  
    visitEmptyStatement(EmptyStatement node, env) {}
  
    visitIfStatement(IfStatement node, env) {
      Value condition = eval(node.condition, env).toBoolean();
      if (identical(Value.trueInstance, condition)) {
        exec(node.then, env);
      } else {
        exec(node.otherwise, env);
      }
    }
  
    visitVariableDeclaration(VariableDeclaration node, env) {
      Value value = node.initializer != null
          ? eval(node.initializer, env)
          : Value.nullInstance;
      env.expand(node, value);
    }
  }
  
  typedef Value Getter(Value receiver);
  typedef void Setter(Value receiver, Value value);
  
  // TODO(zhivkag): Change misleading name.
  // This is representation of a class in the interpreter, not a declaration.
  class Class {
    static final Map<Reference, Class> _classes = <Reference, Class>{};
  
  
negative.code: class Interpreter {
    Program program;
    StatementExecuter visitor = new StatementExecuter();
  
    Interpreter(this.program);
  
  