anchor.diff:        assert(node.receiver != null);
   
         ConcreteType result = new ConcreteType.empty();
  -      void augmentResult(BaseType baseReceiverType, Element getterOrField) {
  -        if (getterOrField.isField()) {
  -          result = result.union(analyzeFieldRead(getterOrField));
  -        } else {
  +      void augmentResult(BaseType baseReceiverType, Element member) {
  +        if (member.isField()) {
  +          result = result.union(analyzeFieldRead(member));
  +        } else if (member.isAbstractField()){
             // call to a getter
  -          AbstractFieldElement abstractField = getterOrField;
  +          AbstractFieldElement abstractField = member;
             result = result.union(analyzeGetterSend(baseReceiverType,
                                                     abstractField.getter));
           }
  +        // since this is a get we ignore non-fields
         }
   
         ConcreteType receiverType = analyze(node.receiver);
         if (receiverType.isUnkown()) {
           List<Element> members =
               inferrer.getMembersByName(node.selector.asIdentifier().source);
  -        for (final member in members) {
  +        for (Element member in members) {
  +          if (!(member.isField() || member.isAbstractField())) continue;
             Element classElement = member.getEnclosingClass();
             ClassBaseType baseReceiverType = new ClassBaseType(classElement);
             augmentResult(baseReceiverType, member);
  
positive.code:       for (BaseType baseReceiverType in receiverType.baseTypes) {
          if (!baseReceiverType.isClass()) continue;
          ClassBaseType baseReceiverClassType = baseReceiverType;
          Element member = baseReceiverClassType.element.lookupMember(source);
          if (member != null) {
            augmentField(baseReceiverClassType, member);
          }
  
negative.code:   }
  
    ConcreteType analyzeSetNode(Node receiver, ConcreteType argumentType,
                                SourceString name) {
      ConcreteType receiverType = analyze(receiver);
  
      void augmentField(BaseType baseReceiverType, Element member) {
        if (member.isField()) {
          inferrer.augmentFieldType(member, argumentType);
        } else if (member.isAbstractField()){
          AbstractFieldElement abstractField = member;
          FunctionElement setter = abstractField.setter;
          // TODO(polux): A setter always returns void so there's no need to
          // invalidate its callers even if it is called with new arguments.
  