anchor.diff:    void computeForClass(Declaration node, Id id) {
       super.computeForClass(node, id);
       if (node is ClassDeclaration) {
  -      var cls = node.declaredElement;
  -
  -      var getterNames = <Name>{};
  -      var setterNames = <Name>{};
  -      var methodNames = <Name>{};
  -
  -      void collectMembers(InterfaceType type) {
  -        for (var element in type.accessors) {
  -          if (element.isGetter) {
  -            getterNames.add(Name(element));
  -          }
  -          if (element.isSetter) {
  -            setterNames.add(Name(element, isSetter: true));
  -          }
  -          var getter = element.declaration.correspondingGetter != null
  -              ? element.correspondingGetter
  -              : null;
  -          if (getter != null) {
  -            getterNames.add(Name(getter));
  -          }
  -          var setter = element.declaration.correspondingSetter != null
  -              ? element.correspondingSetter
  -              : null;
  -          if (setter != null) {
  -            setterNames.add(Name(setter, isSetter: true));
  -          }
  -        }
  -        for (var method in type.methods) {
  -          methodNames.add(Name(method));
  -        }
  -      }
  -
  -      collectMembers(cls.thisType);
  -      for (var supertype in cls.allSupertypes) {
  -        collectMembers(supertype);
  -      }
  +      var element = node.declaredElement;
   
         void registerMember(
             MemberId id, int offset, Object object, DartType type) {
  
positive.code:   }
    return sb.toString();
  }
  
  class Name {
    final String text;
    final bool isPrivate;
    final LibraryElement library;
  
    Name.internal(this.text, this.isPrivate, this.library);
  
    factory Name(Element element, {bool isSetter = false}) {
      String name = element.name;
      if (isSetter) {
        if (!name.endsWith('=')) {
          throw UnsupportedError("Unexpected setter name '$name'");
        }
        name = name.substring(0, name.length - 1);
      }
      return Name.internal(name, element.isPrivate, element.library);
    }
  
    @override
    int get hashCode => isPrivate
        ? text.hashCode * 13 + library.hashCode * 17
        : text.hashCode * 13;
  
    @override
    bool operator ==(Object other) {
      if (identical(this, other)) return true;
      return other is Name &&
          text == other.text &&
          isPrivate == other.isPrivate &&
          (!isPrivate || library == other.library);
    }
  
    @override
    String toString() => isPrivate ? '${library.name}::$text' : text;
  }
  
negative.code:             type.getDisplayString(withNullability: true), object);
        }
  
        var interface = inheritance.getInterface(element.thisType);
        for (var name in interface.map.keys) {
          var executable = interface.map[name];
  
          ClassElement enclosingClass = executable.enclosingElement;
          if (enclosingClass.isDartCoreObject) continue;
  
          var id = MemberId.internal(
            name.name,
            className: element.name,
          );
  
          var offset = enclosingClass == element
              ? executable.nameOffset
              : element.nameOffset;
  
          DartType type;
          if (executable is MethodElement) {
            type = executable.type;
          } else if (executable is PropertyAccessorElement) {
            if (executable.isGetter) {
              type = executable.returnType;
            } else {
              type = executable.parameters.first.type;
            }
          }
  
          registerMember(id, offset, executable, type);
        }
      }
    }
  