anchor.diff:    }
   }
   
  +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 ClassDeclaration {
     static final Map<Reference, ClassDeclaration> _classes =
         <Reference, ClassDeclaration>{};
   
  -  Class currentClass;
  -  ClassDeclaration superClass;
  +  ClassDeclaration superclass;
  +  List<Field> instanceFields = <Field>[];
  +  List<Field> staticFields = <Field>[];
  +  // Implicit getters and setters for instance Fields.
  +  Map<Name, Getter> getters = <Name, Getter>{};
  +  Map<Name, Setter> setters = <Name, Setter>{};
     // The initializers of static fields are evaluated the first time the field
     // is accessed.
  -  List<Value> staticFields = <Value>[];
  -  List<Procedure> getters = <Procedure>[];
  -  List<Procedure> setters = <Procedure>[];
  +  List<Value> staticFieldValues = <Value>[];
  +
     List<Procedure> methods = <Procedure>[];
   
     factory ClassDeclaration(Reference classRef) {
  
positive.code:     return _classes[classRef];
    }
  
    ClassDeclaration._internal(this.currentClass) {
      if (currentClass.superclass != null) {
        superClass = new ClassDeclaration(currentClass.superclass.reference);
      }
      // TODO: Populate getters, setters and methods.
    }
  }
  
  abstract class Value {
    Object get value;
  
    static final NullValue nullInstance = const NullValue();
  
negative.code:     var receiver = eval(node.receiver, env);
      if (node.arguments.positional.isNotEmpty) {
        var argValue = eval(node.arguments.positional.first, env);
        return receiver.invokeMethod(node.name, argValue);
      } else {
        return receiver.invokeMethod(node.name);
      }
    }
  
    Value visitConstructorInvocation(ConstructorInvocation node, env) {
      ClassDeclaration classDeclaration =
          new ClassDeclaration(node.target.enclosingClass.reference);
  
      Environment emptyEnv = new Environment.empty();
      // 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 = classDeclaration.instanceFields
          .map((Field f) => eval(f.initializer, emptyEnv))
          .toList(growable: false);
  
      return new ObjectValue(classDeclaration, fields);
    }
  
    Value visitNot(Not node, env) {
      Value operand = eval(node.operand, env).toBoolean();
  