anchor.diff:        for (BaseType baseReceiverType in receiverType.baseTypes) {
           if (!baseReceiverType.isClass()) continue;
           ClassBaseType baseReceiverClassType = baseReceiverType;
  -        Element member = baseReceiverClassType.element.lookupMember(source);
  +        Element member = baseReceiverClassType.element.lookupMember(name);
           if (member != null) {
             augmentField(baseReceiverClassType, member);
           }
  
positive.code:   }
  
    ConcreteType analyzeSetNode(Node receiver, ConcreteType argumentType,
                                SourceString source) {
      ConcreteType receiverType = analyze(receiver);
  
      void augmentField(BaseType baseReceiverType, Element fieldOrSetter) {
        if (fieldOrSetter.isField()) {
          inferrer.augmentFieldType(fieldOrSetter, argumentType);
        } else {
          AbstractFieldElement abstractField = fieldOrSetter;
          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.
  
negative.code:       assert(node.receiver != null);
  
        ConcreteType result = new ConcreteType.empty();
        void augmentResult(BaseType baseReceiverType, Element member) {
          if (member.isField()) {
            result = result.union(analyzeFieldRead(member));
          } else if (member.isAbstractField()){
            // call to a getter
            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 (Element member in members) {
            if (!(member.isField() || member.isAbstractField())) continue;
            Element classElement = member.getEnclosingClass();
            ClassBaseType baseReceiverType = new ClassBaseType(classElement);
            augmentResult(baseReceiverType, member);
  