anchor.diff:      expect(hover.propagatedType, null);
     }
   
  -  Future<void> test_method_declaration() async {
  -    addTestFile('''
  -library my.library;
  -class A {
  -  /// doc aaa
  -  /// doc bbb
  -  List<String> mmm(int a, String b) {
  -  }
  -}
  -''');
  -    var hover = await prepareHover('mmm(int a');
  -    // element
  -    expect(hover.containingLibraryName, 'bin/test.dart');
  -    expect(hover.containingLibraryPath, testFile);
  -    expect(hover.containingClassDescription, 'A');
  -    expect(hover.dartdoc, '''doc aaa\ndoc bbb''');
  -    expect(hover.elementDescription, 'List<String> mmm(int a, String b)');
  -    expect(hover.elementKind, 'method');
  -    // types
  -    expect(hover.staticType, isNull);
  -    expect(hover.propagatedType, isNull);
  -    // no parameter
  -    expect(hover.parameter, isNull);
  -  }
  -
  -  Future<void> test_method_reference() async {
  -    addTestFile('''
  -library my.library;
  -class A {
  -  List<String> mmm(int a, String b) {
  -  }
  -}
  -void f(A a) {
  -  a.mmm(42, 'foo');
  -}
  -''');
  -    var hover = await prepareHover('mm(42, ');
  -    // range
  -    expect(hover.offset, findOffset('mmm(42, '));
  -    expect(hover.length, 'mmm'.length);
  -    // element
  -    expect(hover.containingLibraryName, 'bin/test.dart');
  -    expect(hover.containingLibraryPath, testFile);
  -    expect(hover.elementDescription, 'List<String> mmm(int a, String b)');
  -    expect(hover.elementKind, 'method');
  -    expect(hover.isDeprecated, isFalse);
  -    // types
  -    expect(hover.staticType, 'List<String> Function(int, String)');
  -    expect(hover.propagatedType, isNull);
  -    // no parameter
  -    expect(hover.parameter, isNull);
  -  }
  -
  -  Future<void> test_method_reference_deprecated() async {
  -    addTestFile('''
  -class A {
  -  @deprecated
  -  static void test() {}
  -}
  -void f() {
  -  A.test();
  -}
  -''');
  -    var hover = await prepareHover('test();');
  -    // element
  -    expect(hover.containingLibraryPath, testFile);
  -    expect(hover.elementDescription, 'void test()');
  -    expect(hover.elementKind, 'method');
  -    expect(hover.isDeprecated, isTrue);
  -  }
  -
  -  Future<void> test_method_reference_genericMethod() async {
  -    addTestFile('''
  -library my.library;
  -
  -abstract class Stream<T> {
  -  Stream<S> transform<S>(StreamTransformer<T, S> streamTransformer);
  -}
  -abstract class StreamTransformer<T, S> {}
  -
  -f(Stream<int> s) {
  -  s.transform(null);
  -}
  -''');
  -    var hover = await prepareHover('nsform(n');
  -    // range
  -    expect(hover.offset, findOffset('transform(n'));
  -    expect(hover.length, 'transform'.length);
  -    // element
  -    expect(hover.containingLibraryName, 'bin/test.dart');
  -    expect(hover.containingLibraryPath, testFile);
  -    expect(hover.elementDescription,
  -        'Stream<S> transform<S>(StreamTransformer<int, S> streamTransformer)');
  -    expect(hover.elementKind, 'method');
  -    expect(hover.isDeprecated, isFalse);
  -    // types
  -    expect(hover.staticType,
  -        'Stream<dynamic> Function(StreamTransformer<int, dynamic>)');
  -    expect(hover.propagatedType, isNull);
  -    // no parameter
  -    expect(hover.parameter, isNull);
  -  }
  -
     Future<void> test_mixin_declaration() async {
       addTestFile('''
   mixin A on B, C implements D, E {}
  
positive.code:     expect(hover.parameter, isNull);
    }
  
    Future<void> test_constructor_synthetic() async {
      addTestFile('''
  library my.library;
  class A {
  
negative.code:     expect(hover.propagatedType, isNull);
      // no parameter
      expect(hover.parameter, isNull);
    }
  
    Future<void> test_class_declaration() async {
      addTestFile('''
  class A<E> {}
  class I1<K, V> {}
  class I2<E> {}
  class M1 {}
  class M2<E> {}
  class B<T> extends A<T> with M1, M2<int> implements I1<int, String>, I2 {}
  ''');
      var hover = await prepareHover('B<T>');
      expect(hover.containingClassDescription, null);
      expect(
          hover.elementDescription,
          'class B<T> extends A<T> with M1, M2<int> '
          'implements I1<int, String>, I2<dynamic>');
      expect(hover.staticType, isNull);
      expect(hover.propagatedType, isNull);
    }
  
    Future<void> test_class_declaration_abstract() async {
      addTestFile('''
  class A {}
  abstract class B extends A {}
  ''');
      var hover = await prepareHover('B extends');
      expect(hover.containingClassDescription, null);
      expect(hover.elementDescription, 'abstract class B extends A');
      expect(hover.staticType, isNull);
      expect(hover.propagatedType, isNull);
    }
  
    Future<void> test_class_getter_synthetic() async {
      addTestFile('''
  library my.library;
  class A {
    /// doc aaa
    /// doc bbb
    String fff;
  }
  void f(A a) {
    print(a.fff);
  }
  ''');
      var hover = await prepareHover('fff);');
      // element
      expect(hover.containingLibraryName, 'bin/test.dart');
      expect(hover.containingLibraryPath, testFile);
      expect(hover.containingClassDescription, 'A');
      expect(hover.dartdoc, '''doc aaa\ndoc bbb''');
      expect(hover.elementDescription, 'String fff');
      expect(hover.elementKind, 'field');
      // types
      expect(hover.staticType, 'String');
      expect(hover.propagatedType, isNull);
    }
  
    Future<void> test_class_method_declaration() async {
      addTestFile('''
  library my.library;
  class A {
    /// doc aaa
    /// doc bbb
    List<String> mmm(int a, String b) {
    }
  }
  ''');
      var hover = await prepareHover('mmm(int a');
      // element
      expect(hover.containingLibraryName, 'bin/test.dart');
      expect(hover.containingLibraryPath, testFile);
      expect(hover.containingClassDescription, 'A');
      expect(hover.dartdoc, '''doc aaa\ndoc bbb''');
      expect(hover.elementDescription, 'List<String> mmm(int a, String b)');
      expect(hover.elementKind, 'method');
      // types
      expect(hover.staticType, isNull);
      expect(hover.propagatedType, isNull);
      // no parameter
      expect(hover.parameter, isNull);
    }
  
    Future<void> test_class_method_reference() async {
      addTestFile('''
  library my.library;
  class A {
    List<String> mmm(int a, String b) {
    }
  }
  void f(A a) {
    a.mmm(42, 'foo');
  }
  ''');
      var hover = await prepareHover('mm(42, ');
      // range
      expect(hover.offset, findOffset('mmm(42, '));
      expect(hover.length, 'mmm'.length);
      // element
      expect(hover.containingLibraryName, 'bin/test.dart');
      expect(hover.containingLibraryPath, testFile);
      expect(hover.elementDescription, 'List<String> mmm(int a, String b)');
      expect(hover.elementKind, 'method');
      expect(hover.isDeprecated, isFalse);
      // types
      expect(hover.staticType, 'List<String> Function(int, String)');
      expect(hover.propagatedType, isNull);
      // no parameter
      expect(hover.parameter, isNull);
    }
  
    Future<void> test_class_method_reference_deprecated() async {
      addTestFile('''
  class A {
    @deprecated
    static void test() {}
  }
  void f() {
    A.test();
  }
  ''');
      var hover = await prepareHover('test();');
      // element
      expect(hover.containingLibraryPath, testFile);
      expect(hover.elementDescription, 'void test()');
      expect(hover.elementKind, 'method');
      expect(hover.isDeprecated, isTrue);
    }
  
    Future<void> test_class_method_reference_genericMethod() async {
      addTestFile('''
  library my.library;
  
  abstract class Stream<T> {
    Stream<S> transform<S>(StreamTransformer<T, S> streamTransformer);
  }
  abstract class StreamTransformer<T, S> {}
  
  f(Stream<int> s) {
    s.transform(null);
  }
  ''');
      var hover = await prepareHover('nsform(n');
      // range
      expect(hover.offset, findOffset('transform(n'));
      expect(hover.length, 'transform'.length);
      // element
      expect(hover.containingLibraryName, 'bin/test.dart');
      expect(hover.containingLibraryPath, testFile);
      expect(hover.elementDescription,
          'Stream<S> transform<S>(StreamTransformer<int, S> streamTransformer)');
      expect(hover.elementKind, 'method');
      expect(hover.isDeprecated, isFalse);
      // types
      expect(hover.staticType,
          'Stream<dynamic> Function(StreamTransformer<int, dynamic>)');
      expect(hover.propagatedType, isNull);
      // no parameter
      expect(hover.parameter, isNull);
    }
  
    Future<void> test_class_setter_hasDocumentation() async {
      addTestFile('''
  class A {
    /// getting
    int get foo => 42;
    /// setting
    set foo(int x) {}
  }
  void f(A a) {
    a.foo = 123;
  }
  ''');
      var hover = await prepareHover('foo = ');
      expect(hover.containingClassDescription, 'A');
      expect(hover.dartdoc, '''setting''');
      expect(hover.elementDescription, 'void set foo(int x)');
      expect(hover.elementKind, 'setter');
    }
  
    Future<void> test_class_setter_noDocumentation() async {
      addTestFile('''
  class A {
    /// getting
    int get foo => 42;
    set foo(int x) {}
  }
  void f(A a) {
    a.foo = 123;
  }
  ''');
      var hover = await prepareHover('foo = ');
      expect(hover.containingClassDescription, 'A');
      expect(hover.dartdoc, '''getting''');
      expect(hover.elementDescription, 'void set foo(int x)');
      expect(hover.elementKind, 'setter');
    }
  
    Future<void> test_class_setter_super_hasDocumentation() async {
      addTestFile('''
  class A {
    /// pgetting
    int get foo => 42;
    /// psetting
    set foo(int x) {}
  }
  class B extends A {
    /// getting
    int get foo => 42;
    set foo(int x) {}
  }
  void f(B b) {
    b.foo = 123;
  }
  ''');
      var hover = await prepareHover('foo = ');
      expect(hover.containingClassDescription, 'B');
      expect(hover.dartdoc, '''psetting\n\nCopied from `A`.''');
      expect(hover.elementDescription, 'void set foo(int x)');
      expect(hover.elementKind, 'setter');
    }
  
    Future<void> test_class_setter_super_noDocumentation() async {
      addTestFile('''
  class A {
    /// pgetting
    int get foo => 42;
    set foo(int x) {}
  }
  class B extends A {
    int get foo => 42;
    set foo(int x) {}
  }
  void f(B b) {
    b.foo = 123;
  }
  ''');
      var hover = await prepareHover('foo = ');
      expect(hover.containingClassDescription, 'B');
      expect(hover.dartdoc, '''pgetting\n\nCopied from `A`.''');
      expect(hover.elementDescription, 'void set foo(int x)');
      expect(hover.elementKind, 'setter');
    }
  
    @failingTest
    Future<void> test_class_setter_super_noSetter() async {
      addTestFile('''
  class A {
    /// pgetting
    int get foo => 42;
  }
  class B extends A {
    set foo(int x) {}
  }
  void f(B b) {
    b.foo = 123;
  }
  ''');
      var hover = await prepareHover('foo = ');
      expect(hover.containingClassDescription, 'B');
      expect(hover.dartdoc, '''pgetting''');
      expect(hover.elementDescription, 'void set foo(int x)');
      expect(hover.elementKind, 'setter');
    }
  
    Future<void> test_dartdoc_block() async {
  