anchor.diff:    }
   
     Value visitConstructorInvocation(ConstructorInvocation node, env) {
  -    ClassDeclaration classDeclaration =
  -        new ClassDeclaration(node.target.enclosingClass.reference);
  +    Class class_ = new Class(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))
  +    List<Value> fields = class_.instanceFields
  +        .map((Field f) => eval(f.initializer ?? new NullLiteral(), emptyEnv))
           .toList(growable: false);
   
  -    return new ObjectValue(classDeclaration, fields);
  +    return new ObjectValue(class_, fields);
     }
   
     Value visitNot(Not node, env) {
  
positive.code: }
  
  class ObjectValue extends Value {
    ClassDeclaration classDeclaration;
    List<Value> fields;
    Object get value => this;
  
    ObjectValue(this.classDeclaration, this.fields);
  }
  
  abstract class LiteralValue extends Value {
    ClassDeclaration get classDeclaration =>
        notImplemented(m: "Loading class for literal is not implemented.");
    List<Value> get fields =>
        notImplemented(m: "Literal value does not have fields");
  
negative.code:     return notImplemented(obj: member);
    }
  
    /// Populates instance variables and the corresponding implicit getters and
    /// setters for the current class and its superclass recursively.
    _populateInstanceFields(ast.Class class_) {
      if (class_.superclass != null) {
        _populateInstanceFields(class_.superclass);
      }
  
      for (Field f in class_.fields) {
        if (f.isStatic) continue;
        instanceFields.add(f);
        assert(f.hasImplicitGetter);
  
        int currentFieldIndex = instanceFields.length - 1;
  
        // Shadowing an inherited getter with the same name.
        getters[f.name] = (Value receiver) => receiver.fields[currentFieldIndex];
        if (f.hasImplicitSetter) {
          // Shadowing an inherited setter with the same name.
          setters[f.name] = (Value receiver, Value value) =>
              receiver.fields[currentFieldIndex] = value;
        }
      }
    }
  }
  
  abstract class Value {
    Class get class_;
    List<Value> get fields;
    Object get value;
  
  