anchor.diff:  
       _assertOverridePairs(b, ['test::B::foo overrides test::A::foo']);
       _assertOverridePairs(c, ['test::C::bar overrides test::A::bar']);
  +  }
  +
  +  /// 1. A member declared in the class overrides a member inheritable through
  +  /// one of the supertypes of the class.
  +  void test_forEachOverridePair_thisOverridesSupertype_setter() {
  +    var a = addClass(new Class(
  +        name: 'A',
  +        supertype: objectSuper,
  +        procedures: [newEmptySetter('foo'), newEmptySetter('bar')]));
  +    var b = addClass(new Class(
  +        name: 'B',
  +        supertype: a.asThisSupertype,
  +        procedures: [newEmptySetter('foo')]));
  +    var c = addClass(new Class(
  +        name: 'C',
  +        supertype: b.asThisSupertype,
  +        procedures: [newEmptySetter('bar')]));
  +
  +    _assertTestLibraryText('''
  +class A {
  +  set foo(dynamic _) → void {}
  +  set bar(dynamic _) → void {}
  +}
  +class B extends self::A {
  +  set foo(dynamic _) → void {}
  +}
  +class C extends self::B {
  +  set bar(dynamic _) → void {}
  +}
  +''');
  +
  +    _assertOverridePairs(b, ['test::B::foo= overrides test::A::foo=']);
  +    _assertOverridePairs(c, ['test::C::bar= overrides test::A::bar=']);
     }
   
     void test_getClassAsInstanceOf_generic_extends() {
  
positive.code:     program.libraries.add(library);
    }
  
    void test_forEachOverridePair_overrideSupertype() {
      var aFoo = newEmptyMethod('foo');
      var aBar = newEmptyMethod('bar');
      var bFoo = newEmptyMethod('foo');
      var cBar = newEmptyMethod('bar');
      var a = addClass(
          new Class(name: 'A', supertype: objectSuper, procedures: [aFoo, aBar]));
      var b = addClass(
          new Class(name: 'B', supertype: a.asThisSupertype, procedures: [bFoo]));
      var c = addClass(
          new Class(name: 'C', supertype: b.asThisSupertype, procedures: [cBar]));
  
      _assertTestLibraryText('''
  class A {
  
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 {
  