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: /// Creates a list of all argument expressions to be evaluated for the
  /// invocation of the provided [FunctionNode] containing the actual arguments
  /// and the optional argument initializers.
  List<ArgumentExpression> _createArgumentExpressionList(
      Arguments providedArgs, FunctionNode fun) {
    List<ArgumentExpression> args = <ArgumentExpression>[];
    // Add positional arguments expressions.
    args.addAll(providedArgs.positional
        .map((Expression e) => new PositionalArgumentExpression(e)));
  
negative.code:       executer.eval(expression, this);
  }
  
  /// Represents the configuration for evaluating a list of expressions.
  class ExpressionListConfiguration extends Configuration {
    final List<InterpreterExpression> expressions;
    final Environment environment;
    final Continuation continuation;
  
    ExpressionListConfiguration(
        this.expressions, this.environment, this.continuation);
  
    Configuration step(StatementExecuter executer) =>
        executer.evalList(expressions, environment, continuation);
  }
  
  abstract class InterpreterExpression {
    Expression get expression;
  
    InterpreterValue assignValue(Value v);
  }
  
  class PositionalArgumentExpression extends InterpreterExpression {
    final Expression expression;
  
    PositionalArgumentExpression(this.expression);
  
    InterpreterValue assignValue(Value v) => new PositionalArgumentValue(v);
  }
  
  class NamedArgumentExpression extends InterpreterExpression {
    final String name;
    final Expression expression;
  
    NamedArgumentExpression(this.name, this.expression);
    InterpreterValue assignValue(Value v) => new NamedArgumentValue(name, v);
  }
  
  class LocalInitializerExpression extends InterpreterExpression {
    final VariableDeclaration variable;
  
    Expression get expression => variable.initializer;
  
    LocalInitializerExpression(this.variable);
  
    InterpreterValue assignValue(Value v) =>
        new LocalInitializerValue(variable, v);
  }
  
  class FieldInitializerExpression extends InterpreterExpression {
    final Field field;
    final Expression expression;
  
    FieldInitializerExpression(this.field, this.expression);
  
    InterpreterValue assignValue(Value v) => new FieldInitializerValue(field, v);
  }
  
  abstract class InterpreterValue {
    Value get value;
  }
  
  class PositionalArgumentValue extends InterpreterValue {
    final Value value;
  
    PositionalArgumentValue(this.value);
  }
  
  class NamedArgumentValue extends InterpreterValue {
    final String name;
    final Value value;
  
    NamedArgumentValue(this.name, this.value);
  }
  
  class LocalInitializerValue extends InterpreterValue {
    final VariableDeclaration variable;
    final Value value;
  
    LocalInitializerValue(this.variable, this.value);
  }
  
  class FieldInitializerValue extends InterpreterValue {
    final Field field;
    final Value value;
  
    FieldInitializerValue(this.field, this.value);
  }
  
  abstract class Continuation {}
  