anchor.diff:    method bar() → void {}
   }
   class B extends self::A {
  -  method foo() → void;
  +  abstract method foo() → void;
   }
   class C extends self::A implements self::B {}
   class D {}
  
positive.code:     var b = addClass(new Class(
          name: 'B',
          supertype: a.asThisSupertype,
          procedures: [newEmptyMethod('foo', abstract: true)]));
      var c = addClass(new Class(
          name: 'C',
          supertype: a.asThisSupertype,
  
negative.code:   }
  
    void test_getDispatchTarget_abstract() {
      var aFoo = newEmptyMethod('foo', isAbstract: true);
      var aBar = newEmptyMethod('bar');
      var bFoo = newEmptyMethod('foo');
      var bBar = newEmptyMethod('bar', isAbstract: true);
      var a = addClass(new Class(
          isAbstract: true,
          name: 'A',
          supertype: objectSuper,
          procedures: [aFoo, aBar]));
      var b = addClass(new Class(
          isAbstract: true,
          name: 'B',
          supertype: a.asThisSupertype,
          procedures: [bFoo, bBar]));
      var c = addClass(new Class(name: 'C', supertype: b.asThisSupertype));
  
      _assertTestLibraryText('''
  abstract class A {
    abstract method foo() → void;
    method bar() → void {}
  }
  abstract class B extends self::A {
    method foo() → void {}
    abstract method bar() → void;
  }
  class C extends self::B {}
  ''');
  
      expect(hierarchy.getDispatchTarget(a, new Name('foo')), isNull);
      expect(hierarchy.getDispatchTarget(b, new Name('foo')), bFoo);
      expect(hierarchy.getDispatchTarget(c, new Name('foo')), bFoo);
  
      expect(hierarchy.getDispatchTarget(a, new Name('bar')), aBar);
      expect(hierarchy.getDispatchTarget(b, new Name('bar')), aBar);
      expect(hierarchy.getDispatchTarget(c, new Name('bar')), aBar);
    }
  
    void test_getInterfaceMember_extends() {
  