anchor.diff:  
     Configuration visitConstructorInvocation(
         ConstructorInvocation node, ExpressionConfiguration config) {
  -    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(
  -        config.continuation, new ObjectValue(class_, fields));
  +    // Currently, the bodies of the constructors are not executed.
  +    // Currently initializer list is executed only for redirecting
  +    // constructors.
  +    if (node.target.function.body is! EmptyStatement) {
  +      throw 'Execution for body of constructor is not implemented.';
  +    }
  +
  +    var class_ = new Class(node.target.enclosingClass.reference);
  +    var newObject =
  +        new ObjectValue(class_, new List<Value>(class_.instanceSize));
  +    ApplicationContinuation cont = new ConstructorInvocationApplication(
  +        newObject, node.target, config.continuation);
  +
  +    var args =
  +        _createArgumentExpressionList(node.arguments, node.target.function);
  +
  +    return new ExpressionListConfiguration(args, config.environment, cont);
     }
   
     Configuration visitNot(Not node, ExpressionConfiguration config) {
  
positive.code: 
  /// Represents a continuation to be called after the evaluation of an actual
  /// argument for function invocation.
  /// TODO: Add checks for validation of arguments according to spec.
  class ActualArgumentsContinuation extends ExpressionContinuation {
    final ArgumentExpression currentArgument;
    final List<ArgumentExpression> arguments;
    final Environment environment;
    final ApplicationContinuation applicationContinuation;
  
    ActualArgumentsContinuation(this.currentArgument, this.arguments,
        this.environment, this.applicationContinuation);
  
    Configuration call(Value v) {
      ArgumentValue argumentValue;
      if (currentArgument is NamedArgumentExpression) {
        argumentValue = new NamedArgumentValue(
            (currentArgument as NamedArgumentExpression).name, v);
      } else {
        assert(currentArgument is PositionalArgumentExpression);
        argumentValue = new PositionalArgumentValue(v);
      }
  
      return new ArgumentsConfiguration(arguments, environment,
          new ArgumentValueApplication(argumentValue, applicationContinuation));
    }
  }
  
  
negative.code:       statement.accept1(this, state);
    Configuration eval(Expression expression, ExpressionConfiguration config) =>
        evaluator.eval(expression, config);
    Configuration evalList(
            List<InterpreterExpression> es, Environment env, Continuation cont) =>
        evaluator.evalList(es, env, cont);
  
    Configuration defaultStatement(Statement node, State state) {
      throw notImplemented(
  