anchor.diff:  
     ClassHierarchyBuilder(this.objectClass);
   
  -  Declaration handleOverride(KernelClassBuilder cls, Declaration member,
  -      Declaration superMember, MergeKind mergeKind) {
  -    if (member.next != null || superMember.next != null) {
  +  /// A merge conflict arises when merging two lists that each have an element
  +  /// with the same name.
  +  ///
  +  /// If [mergeKind] is `MergeKind.superclass`, [a] should override [b].
  +  ///
  +  /// If [mergeKind] is `MergeKind.interfaces`, we need to record them and
  +  /// solve the conflict later.
  +  ///
  +  /// If [mergeKind] is `MergeKind.supertypes`, [a] should implement [b], and
  +  /// [b] is implicitly abstract.
  +  Declaration handleMergeConflict(KernelClassBuilder cls, Declaration a,
  +      Declaration b, MergeKind mergeKind) {
  +    if (a == b) return a;
  +    if (a.next != null || b.next != null) {
         // Don't check overrides involving duplicated members.
  -      return member;
  -    }
  -    Member target = member.target;
  -    Member superTarget = superMember.target;
  -    if ((memberKind(target) ?? ProcedureKind.Getter) !=
  -        (memberKind(superTarget) ?? ProcedureKind.Getter)) {
  -      String name = member.fullNameForErrors;
  +      return a;
  +    }
  +    Member aTarget = a.target;
  +    Member bTarget = b.target;
  +    if ((memberKind(aTarget) ?? ProcedureKind.Getter) !=
  +        (memberKind(bTarget) ?? ProcedureKind.Getter)) {
  +      String name = a.fullNameForErrors;
         if (mergeKind == MergeKind.interfaces) {
           cls.addProblem(messageInheritedMembersConflict, cls.charOffset,
               cls.fullNameForErrors.length,
               context: <LocatedMessage>[
                 messageInheritedMembersConflictCause1.withLocation(
  -                  member.fileUri, member.charOffset, name.length),
  +                  a.fileUri, a.charOffset, name.length),
                 messageInheritedMembersConflictCause2.withLocation(
  -                  superMember.fileUri, superMember.charOffset, name.length),
  +                  b.fileUri, b.charOffset, name.length),
               ]);
         } else {
           cls.addProblem(messageDeclaredMemberConflictsWithInheritedMember,
  -            member.charOffset, name.length,
  +            a.charOffset, name.length,
               context: <LocatedMessage>[
                 messageDeclaredMemberConflictsWithInheritedMemberCause
  -                  .withLocation(
  -                      superMember.fileUri, superMember.charOffset, name.length)
  +                  .withLocation(b.fileUri, b.charOffset, name.length)
               ]);
         }
       }
  -    if (target.name == noSuchMethodName && !target.isAbstract) {
  +    if (aTarget.name == noSuchMethodName && !aTarget.isAbstract) {
         hasNoSuchMethod = true;
       }
  -    Declaration result = member;
  +    Declaration result = a;
       if (mergeKind == MergeKind.interfaces) {
  -      // TODO(ahe): Combine the signatures of member and superMember.
  -    } else if (target.isAbstract) {
  -      if (!superTarget.isAbstract) {
  +      // TODO(ahe): Combine the signatures of a and b.
  +    } else if (aTarget.isAbstract) {
  +      if (!bTarget.isAbstract) {
           // An abstract method doesn't override an implemention inherited from a
           // superclass.
  -        result = superMember;
  +        result = b;
         } else {
           abstractMemberCount++;
         }
  
positive.code: 
    /// Merge [and check] accessors. This entails removing setters corresponding
    /// to fields, and checking that setters don't override regular methods.
    void mergeAccessors(KernelClassBuilder cls, List<Declaration> allMembers,
        List<Declaration> allSetters) {
      List<Declaration> overriddenSetters;
      int i = 0;
      int j = 0;
      while (i < allMembers.length && j < allSetters.length) {
        Declaration member = allMembers[i];
        Declaration setter = allSetters[j];
        final int compare = compareDeclarations(member, setter);
        if (compare == 0) {
          if (member.isField) {
  
negative.code:     return result;
    }
  
    /// If [mergeKind] is `MergeKind.superclass` [member] is declared in current
    /// class, and isn't overriding a method from the superclass.
    ///
    /// If [mergeKind] is `MergeKind.interfaces`, [member] is ignored for now.
    ///
    /// If [mergeKind] is `MergeKind.supertypes`, [member] isn't
    /// implementing/overriding anything.
    void handleOnlyA(Declaration member, MergeKind mergeKind) {
      Member target = member.target;
      if (mergeKind == MergeKind.superclass && target.isAbstract) {
        abstractMemberCount++;
      }
    }
  
    /// If [mergeKind] is `MergeKind.superclass` [member] is being inherited from
    /// a superclass.
    ///
    /// If [mergeKind] is `MergeKind.interfaces`, [member] is ignored for now.
    ///
    /// If [mergeKind] is `MergeKind.supertypes`, [member] is implicitly
    /// abstract, and not implemented.
    void handleOnlyB(
        KernelClassBuilder cls, Declaration member, MergeKind mergeKind) {
      Member target = member.target;
      if (mergeKind == MergeKind.superclass && target.isAbstract) {
  