anchor.diff:      return _classes[classRef];
     }
   
  -  ClassDeclaration._internal(this.currentClass) {
  +  ClassDeclaration._internal(Class currentClass) {
       if (currentClass.superclass != null) {
  -      superClass = new ClassDeclaration(currentClass.superclass.reference);
  -    }
  -    // TODO: Populate getters, setters and methods.
  +      superclass = new ClassDeclaration(currentClass.superclass.reference);
  +    }
  +
  +    _populateInstanceFields(currentClass);
  +
  +    // Populate implicit setters and getters.
  +    for (int i = 0; i < instanceFields.length; i++) {
  +      Field f = instanceFields[i];
  +      assert(f.hasImplicitGetter);
  +      getters[f.name] = (Value receiver) => receiver.fields[i];
  +      if (f.hasImplicitSetter) {
  +        setters[f.name] =
  +            (Value receiver, Value value) => receiver.fields[i] = value;
  +      }
  +    }
  +    // TODO: Populate methods.
  +  }
  +
  +  Getter lookupGetter(Name name) {
  +    Getter getter = getters[name];
  +    if (getter != null) return getter;
  +    if (superclass != null) return superclass.lookupGetter(name);
  +    return (Value receiver) => notImplemented(obj: name);
  +  }
  +
  +  Setter lookupSetter(Name name) {
  +    Setter setter = setters[name];
  +    if (setter != null) return setter;
  +    if (superclass != null) return lookupSetter(name);
  +    return (Value receiver, Value value) => notImplemented(obj: name);
  +  }
  +
  +  Value getProperty(ObjectValue object, Member member) {
  +    if (member is Field) {
  +      int index = instanceFields.indexOf(member);
  +      // TODO: throw NoSuchMethodError instead.
  +      if (index < 0) return notImplemented(m: 'NoSuchMethod: ${member}');
  +      return object.fields[index];
  +    }
  +    return notImplemented(obj: member);
  +  }
  +
  +  Value setProperty(ObjectValue object, Member member, Value value) {
  +    if (member is Field) {
  +      int index = instanceFields.indexOf(member);
  +      // TODO: throw NoSuchMethodError instead.
  +      if (index < 0) return notImplemented(m: 'NoSuchMethod: ${member}');
  +      object.fields[index] = value;
  +      return Value.nullInstance;
  +    }
  +    return notImplemented(obj: member);
  +  }
  +
  +  // Populates with the instance fields of the current class and all its
  +  // superclasses recursively.
  +  _populateInstanceFields(Class class_) {
  +    for (Field f in class_.fields) {
  +      if (f.isInstanceMember) {
  +        instanceFields.add(f);
  +      }
  +    }
  +
  +    if (class_.superclass != null) {
  +      _populateInstanceFields(class_.superclass);
  +    }
     }
   }
   
   abstract class Value {
  +  ClassDeclaration get classDeclaration;
  +  List<Value> get fields;
     Object get value;
   
     static final NullValue nullInstance = const NullValue();
  
positive.code: 
    StringValue(this.value);
  
    Value invokeMethod(String name, [Value arg]) {
      if (!operators.containsKey(name)) {
        return notImplemented(obj: name);
      }
      return operators[name](this, arg);
    }
  
    // Operators
    Value operator [](Value index) => new StringValue(value[index.value]);
  }
  
  abstract class NumValue extends Value {
    num get value;
  
    NumValue();
  
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();
  