anchor.diff:      return type is KernelNamedTypeBuilder ? type.declaration : null;
     }
   
  -  List<Declaration> merge(
  -      KernelClassBuilder cls,
  -      List<Declaration> localMembers,
  -      List<Declaration> superMembers,
  -      MergeKind mergeKind) {
  -    final List<Declaration> mergedMembers = new List<Declaration>.filled(
  -        localMembers.length + superMembers.length, null,
  +  List<Declaration> merge(KernelClassBuilder cls, List<Declaration> aList,
  +      List<Declaration> bList, MergeKind mergeKind) {
  +    final List<Declaration> result = new List<Declaration>.filled(
  +        aList.length + bList.length, null,
           growable: true);
   
  -    int mergedMemberCount = 0;
  +    int storeIndex = 0;
   
       int i = 0;
       int j = 0;
  -    while (i < localMembers.length && j < superMembers.length) {
  -      final Declaration localMember = localMembers[i];
  -      final Declaration superMember = superMembers[j];
  -      final int compare = compareDeclarations(localMember, superMember);
  +    while (i < aList.length && j < bList.length) {
  +      final Declaration a = aList[i];
  +      final Declaration b = bList[j];
  +      final int compare = compareDeclarations(a, b);
         if (compare == 0) {
  -        mergedMembers[mergedMemberCount++] =
  -            handleOverride(cls, localMember, superMember, mergeKind);
  +        result[storeIndex++] = handleMergeConflict(cls, a, b, mergeKind);
           i++;
           j++;
         } else if (compare < 0) {
  -        handleNewMember(localMember, mergeKind);
  -        mergedMembers[mergedMemberCount++] = localMember;
  +        handleOnlyA(a, mergeKind);
  +        result[storeIndex++] = a;
           i++;
         } else {
  -        handleInheritance(cls, superMember, mergeKind);
  -        mergedMembers[mergedMemberCount++] = superMember;
  +        handleOnlyB(cls, b, mergeKind);
  +        result[storeIndex++] = b;
           j++;
         }
       }
  -    while (i < localMembers.length) {
  -      final Declaration localMember = localMembers[i];
  -      handleNewMember(localMember, mergeKind);
  -      mergedMembers[mergedMemberCount++] = localMember;
  +    while (i < aList.length) {
  +      final Declaration a = aList[i];
  +      handleOnlyA(a, mergeKind);
  +      result[storeIndex++] = a;
         i++;
       }
  -    while (j < superMembers.length) {
  -      final Declaration superMember = superMembers[j];
  -      handleInheritance(cls, superMember, mergeKind);
  -      mergedMembers[mergedMemberCount++] = superMember;
  +    while (j < bList.length) {
  +      final Declaration b = bList[j];
  +      handleOnlyB(cls, b, mergeKind);
  +      result[storeIndex++] = b;
         j++;
       }
  -    return mergedMembers..length = mergedMemberCount;
  +    return result..length = storeIndex;
     }
   }
   
  
positive.code:     return result;
    }
  
    void handleNewMember(Declaration member, MergeKind mergeKind) {
      Member target = member.target;
      if (mergeKind == MergeKind.superclass && target.isAbstract) {
        abstractMemberCount++;
      }
    }
  
    void handleInheritance(
        KernelClassBuilder cls, Declaration member, MergeKind mergeKind) {
      Member target = member.target;
      if (mergeKind == MergeKind.superclass && target.isAbstract) {
  
negative.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> members,
        List<Declaration> setters) {
      List<Declaration> overriddenSetters;
      int i = 0;
      int j = 0;
      while (i < members.length && j < setters.length) {
        Declaration member = members[i];
        Declaration setter = setters[j];
        final int compare = compareDeclarations(member, setter);
        if (compare == 0) {
          if (member.isField) {
  