anchor.diff:          new FunctionNode(body, returnType: const VoidType()));
     }
   
  -  Procedure newEmptySetter(String name) {
  +  Procedure newEmptySetter(String name, {bool abstract: false}) {
  +    var body = abstract ? null : new Block([]);
       return new Procedure(
           new Name(name),
           ProcedureKind.Setter,
  -        new FunctionNode(new Block([]),
  +        new FunctionNode(body,
               returnType: const VoidType(),
               positionalParameters: [new VariableDeclaration('_')]));
     }
  
positive.code:     List<String> overrideDescriptions = [];
      hierarchy.forEachOverridePair(class_,
          (Member declaredMember, Member interfaceMember, bool isSetter) {
        var desc = '$declaredMember overrides $interfaceMember';
        overrideDescriptions.add(desc);
      });
      expect(overrideDescriptions, unorderedEquals(expected));
  
negative.code:   method bar() → void {}
  }
  class B extends self::A {
    method foo() → void;
  }
  class C extends self::A implements self::B {}
  class D {}
  class E = self::D with self::A implements self::B {}
  ''');
  
      _assertOverridePairs(c, ['test::A::foo overrides test::B::foo']);
      _assertOverridePairs(e, ['test::A::foo overrides test::B::foo']);
    }
  
    /// 3. A non-abstract member is inherited from a superclass, and it overrides
    /// an abstract member declared in this class.
    /// TODO(scheglov): Implementation does not follow the documentation.
    @failingTest
    void test_forEachOverridePair_supertypeOverridesThisAbstract() {
      var a = addClass(new Class(
          name: 'A',
          supertype: objectSuper,
          procedures: [newEmptyMethod('foo'), newEmptyMethod('bar')]));
      var b = addClass(new Class(
          name: 'B',
          supertype: a.asThisSupertype,
          procedures: [newEmptyMethod('foo', abstract: true)]));
  
      _assertTestLibraryText('''
  class A {
    method foo() → void {}
    method bar() → void {}
  }
  class B extends self::A {
    method foo() → void;
  }
  ''');
  
      _assertOverridePairs(b, ['test::A::foo overrides test::B::foo']);
    }
  
    /// 1. A member declared in the class overrides a member inheritable through
    /// one of the supertypes of the class.
    void test_forEachOverridePair_thisOverridesSupertype() {
      var a = addClass(new Class(
          name: 'A',
          supertype: objectSuper,
          procedures: [newEmptyMethod('foo'), newEmptyMethod('bar')]));
      var b = addClass(new Class(
          name: 'B',
          supertype: a.asThisSupertype,
          procedures: [newEmptyMethod('foo')]));
      var c = addClass(new Class(
          name: 'C',
          supertype: b.asThisSupertype,
          procedures: [newEmptyMethod('bar')]));
  
      _assertTestLibraryText('''
  class A {
    method foo() → void {}
    method bar() → void {}
  }
  class B extends self::A {
    method foo() → void {}
  }
  class C extends self::B {
  