Emit a hint when using generic method comment syntax (issue 30356)

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library analyzer.test.generated.strong_mode_test;
-
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
@@ skipping 456 matching lines @@
     expect(covariantC.toList(), [cAdd.element.parameters[0]]);
 
     var dAdd = AstFinder.getMethodInClass(unit, "D", "add");
     var covariantD = getClassCovariantParameters(AstFinder.getClass(unit, "D"));
     expect(covariantD.toList(), [dAdd.element.parameters[0]]);
 
     var covariantE = getClassCovariantParameters(AstFinder.getClass(unit, "E"));
     expect(covariantE.toList(), []);
   }
 
-  test_covarianceChecks_superclass() async {
-    var source = addSource(r'''
-class C<T> {
-  add(T t) {}
-  forEach(void f(T t)) {}
-}
-class D {
-  add(int t) {}
-  forEach(void f(int t)) {}
-}
-class E extends D implements C<int> {}
-''');
-    var unit = (await computeAnalysisResult(source)).unit;
-    assertNoErrors(source);
-    var cAdd = AstFinder.getMethodInClass(unit, "C", "add");
-    var covariantC = getClassCovariantParameters(AstFinder.getClass(unit, "C"));
-    expect(covariantC.toList(), [cAdd.element.parameters[0]]);
-
-    var dAdd = AstFinder.getMethodInClass(unit, "D", "add");
-    var covariantD = getClassCovariantParameters(AstFinder.getClass(unit, "D"));
-    expect(covariantD, null);
-
-    var classE = AstFinder.getClass(unit, "E");
-    var covariantE = getClassCovariantParameters(classE);
-    var superCovariantE = getSuperclassCovariantParameters(classE);
-    expect(covariantE.toList(), []);
-    expect(superCovariantE.toList(), [dAdd.element.parameters[0]]);
-  }
-
   test_covarianceChecks_returnFunction() async {
     var source = addSource(r'''
 typedef F<T>(T t);
 typedef T R<T>();
 class C<T> {
   F<T> f;
 
   C();
   factory C.fact() => new C<Null>();
 
@@ skipping 185 matching lines @@
       expectCast(s, false);
     }
     for (var s in AstFinder.getStatementsInTopLevelFunction(unit, 'noCasts')) {
       expectCast(s, false);
     }
     for (var s in AstFinder.getStatementsInTopLevelFunction(unit, 'casts')) {
       expectCast(s, true);
     }
   }
 
+  test_covarianceChecks_superclass() async {
+    var source = addSource(r'''
+class C<T> {
+  add(T t) {}
+  forEach(void f(T t)) {}
+}
+class D {
+  add(int t) {}
+  forEach(void f(int t)) {}
+}
+class E extends D implements C<int> {}
+''');
+    var unit = (await computeAnalysisResult(source)).unit;
+    assertNoErrors(source);
+    var cAdd = AstFinder.getMethodInClass(unit, "C", "add");
+    var covariantC = getClassCovariantParameters(AstFinder.getClass(unit, "C"));
+    expect(covariantC.toList(), [cAdd.element.parameters[0]]);
+
+    var dAdd = AstFinder.getMethodInClass(unit, "D", "add");
+    var covariantD = getClassCovariantParameters(AstFinder.getClass(unit, "D"));
+    expect(covariantD, null);
+
+    var classE = AstFinder.getClass(unit, "E");
+    var covariantE = getClassCovariantParameters(classE);
+    var superCovariantE = getSuperclassCovariantParameters(classE);
+    expect(covariantE.toList(), []);
+    expect(superCovariantE.toList(), [dAdd.element.parameters[0]]);
+  }
+
   test_factoryConstructor_propagation() async {
     String code = r'''
       class A<T> {
         factory A() { return new B(); }
       }
       class B<S> extends A<S> {}
    ''';
     CompilationUnit unit = await resolveSource(code);
 
     ConstructorDeclaration constructor =
@@ skipping 1947 matching lines @@
     import "dart:async";
     dynamic test<T extends num>(FutureOr<T> x) => (x is T) &&
                                                   (x.abs() == 0);
    ''';
     await resolveTestUnit(code);
   }
 
   fail_genericMethod_tearoff_instantiated() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(E e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(E e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
-  var methodTearOffInst = c.f/*<int>*/;
-  var staticTearOffInst = C.g/*<int>*/;
-  var staticFieldTearOffInst = C.h/*<int>*/;
-  var topFunTearOffInst = topF/*<int>*/;
-  var topFieldTearOffInst = topG/*<int>*/;
-  var localTearOffInst = lf/*<int>*/;
-  var paramTearOffInst = pf/*<int>*/;
+  T lf<T>(T e) => null;
+  var methodTearOffInst = c.f<int>;
+  var staticTearOffInst = C.g<int>;
+  var staticFieldTearOffInst = C.h<int>;
+  var topFunTearOffInst = topF<int>;
+  var topFieldTearOffInst = topG<int>;
+  var localTearOffInst = lf<int>;
+  var paramTearOffInst = pf<int>;
 }
 ''');
     expectIdentifierType('methodTearOffInst', "(int) → int");
     expectIdentifierType('staticTearOffInst', "(int) → int");
     expectIdentifierType('staticFieldTearOffInst', "(int) → int");
     expectIdentifierType('topFunTearOffInst', "(int) → int");
     expectIdentifierType('topFieldTearOffInst', "(int) → int");
     expectIdentifierType('localTearOffInst', "(int) → int");
     expectIdentifierType('paramTearOffInst', "(int) → int");
   }
@@ skipping 52 matching lines @@
     // parameters T
     String code = r'''
     import "dart:async";
     dynamic test<T extends num>(FutureOr<T> x) => (x is Future<T>) &&
                                                   (x.then((x) => x) == null);
    ''';
     await resolveTestUnit(code);
   }
 
   test_genericFunction() async {
-    await resolveTestUnit(r'/*=T*/ f/*<T>*/(/*=T*/ x) => null;');
+    await resolveTestUnit(r'T f<T>(T x) => null;');
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     FunctionElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   test_genericFunction_bounds() async {
-    await resolveTestUnit(r'/*=T*/ f/*<T extends num>*/(/*=T*/ x) => null;');
+    await resolveTestUnit(r'T f<T extends num>(T x) => null;');
     expectFunctionType('f', '<T extends num>(T) → T',
         elementTypeParams: '[T extends num]', typeFormals: '[T extends num]');
   }
 
   test_genericFunction_parameter() async {
     await resolveTestUnit(r'''
-void g(/*=T*/ f/*<T>*/(/*=T*/ x)) {}
+void g(T f<T>(T x)) {}
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     ParameterElementImpl e = f.staticElement;
     FunctionType type = e.type;
     FunctionType ft = type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   test_genericFunction_static() async {
     await resolveTestUnit(r'''
 class C<E> {
-  static /*=T*/ f/*<T>*/(/*=T*/ x) => null;
+  static T f<T>(T x) => null;
 }
 ''');
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
@@ skipping 62 matching lines @@
     expectInitializerType('aaa', 'List<Object>');
     expectInitializerType('bbb', 'List<Object>');
     expectInitializerType('ccc', 'List<Object>');
     expectInitializerType('ddd', 'List<Object>');
     expectInitializerType('eee', 'List<Object>');
   }
 
   test_genericMethod() async {
     await resolveTestUnit(r'''
 class C<E> {
-  List/*<T>*/ f/*<T>*/(E e) => null;
+  List<T> f<T>(E e) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     expectFunctionType('f', '<T>(E) → List<T>',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
     SimpleIdentifier c = findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '<T>(String) → List<T>');
     ft = ft.instantiate([typeProvider.intType]);
     expect(ft.toString(), '(String) → List<int>');
     expect('${ft.typeArguments}/${ft.typeParameters}', '[String, int]/[E, T]');
   }
 
   test_genericMethod_explicitTypeParams() async {
     await resolveTestUnit(r'''
 class C<E> {
-  List/*<T>*/ f/*<T>*/(E e) => null;
+  List<T> f<T>(E e) => null;
 }
 main() {
   C<String> cOfString;
-  var x = cOfString.f/*<int>*/('hi');
+  var x = cOfString.f<int>('hi');
 }
 ''');
-    MethodInvocation f = findIdentifier('f/*<int>*/').parent;
+    MethodInvocation f = findIdentifier('f<int>').parent;
     FunctionType ft = f.staticInvokeType;
     expect(ft.toString(), '(String) → List<int>');
     expect('${ft.typeArguments}/${ft.typeParameters}', '[String, int]/[E, T]');
 
     SimpleIdentifier x = findIdentifier('x');
     expect(x.staticType,
         typeProvider.listType.instantiate([typeProvider.intType]));
   }
 
   test_genericMethod_functionExpressionInvocation_explicit() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(/*=T*/ e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(T e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
+  T lf<T>(T e) => null;
 
-  var lambdaCall = (/*<E>*/(/*=E*/ e) => e)/*<int>*/(3);
-  var methodCall = (c.f)/*<int>*/(3);
-  var staticCall = (C.g)/*<int>*/(3);
-  var staticFieldCall = (C.h)/*<int>*/(3);
-  var topFunCall = (topF)/*<int>*/(3);
-  var topFieldCall = (topG)/*<int>*/(3);
-  var localCall = (lf)/*<int>*/(3);
-  var paramCall = (pf)/*<int>*/(3);
+  var lambdaCall = (<E>(E e) => e)<int>(3);
+  var methodCall = (c.f)<int>(3);
+  var staticCall = (C.g)<int>(3);
+  var staticFieldCall = (C.h)<int>(3);
+  var topFunCall = (topF)<int>(3);
+  var topFieldCall = (topG)<int>(3);
+  var localCall = (lf)<int>(3);
+  var paramCall = (pf)<int>(3);
 }
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
     expectIdentifierType('lambdaCall', "int");
   }
 
   test_genericMethod_functionExpressionInvocation_inferred() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(/*=T*/ e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(T e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
+  T lf<T>(T e) => null;
 
-  var lambdaCall = (/*<E>*/(/*=E*/ e) => e)(3);
+  var lambdaCall = (<E>(E e) => e)(3);
   var methodCall = (c.f)(3);
   var staticCall = (C.g)(3);
   var staticFieldCall = (C.h)(3);
   var topFunCall = (topF)(3);
   var topFieldCall = (topG)(3);
   var localCall = (lf)(3);
   var paramCall = (pf)(3);
 }
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
     expectIdentifierType('lambdaCall', "int");
   }
 
   test_genericMethod_functionInvocation_explicit() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(/*=T*/ e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(T e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
-  var methodCall = c.f/*<int>*/(3);
-  var staticCall = C.g/*<int>*/(3);
-  var staticFieldCall = C.h/*<int>*/(3);
-  var topFunCall = topF/*<int>*/(3);
-  var topFieldCall = topG/*<int>*/(3);
-  var localCall = lf/*<int>*/(3);
-  var paramCall = pf/*<int>*/(3);
+  T lf<T>(T e) => null;
+  var methodCall = c.f<int>(3);
+  var staticCall = C.g<int>(3);
+  var staticFieldCall = C.h<int>(3);
+  var topFunCall = topF<int>(3);
+  var topFieldCall = topG<int>(3);
+  var localCall = lf<int>(3);
+  var paramCall = pf<int>(3);
 }
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
   }
 
   test_genericMethod_functionInvocation_inferred() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(/*=T*/ e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(T e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
+  T lf<T>(T e) => null;
   var methodCall = c.f(3);
   var staticCall = C.g(3);
   var staticFieldCall = C.h(3);
   var topFunCall = topF(3);
   var topFieldCall = topG(3);
   var localCall = lf(3);
   var paramCall = pf(3);
 }
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
   }
 
   test_genericMethod_functionTypedParameter() async {
     await resolveTestUnit(r'''
 class C<E> {
-  List/*<T>*/ f/*<T>*/(/*=T*/ f(E e)) => null;
+  List<T> f<T>(T f(E e)) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     expectFunctionType('f', '<T>((E) → T) → List<T>',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
 
     SimpleIdentifier c = findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '<T>((String) → T) → List<T>');
     ft = ft.instantiate([typeProvider.intType]);
     expect(ft.toString(), '((String) → int) → List<int>');
   }
 
   test_genericMethod_implicitDynamic() async {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25100#issuecomment-162047588
     // These should not cause any hints or warnings.
     await resolveTestUnit(r'''
 class List<E> {
-  /*=T*/ map/*<T>*/(/*=T*/ f(E e)) => null;
+  T map<T>(T f(E e)) => null;
 }
 void foo() {
   List list = null;
   list.map((e) => e);
   list.map((e) => 3);
 }''');
     expectIdentifierType('map((e) => e);', '<T>((dynamic) → T) → T', isNull);
     expectIdentifierType('map((e) => 3);', '<T>((dynamic) → T) → T', isNull);
 
     MethodInvocation m1 = findIdentifier('map((e) => e);').parent;
@@ skipping 53 matching lines @@
   var foo = max(1, 2);
 }
 ''';
     await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 
   test_genericMethod_nestedBound() async {
     String code = r'''
 class Foo<T extends num> {
-  void method/*<U extends T>*/(dynamic/*=U*/ u) {
+  void method<U extends T>(U u) {
     u.abs();
   }
 }
 ''';
     // Just validate that there is no warning on the call to `.abs()`.
     await resolveTestUnit(code);
   }
 
   test_genericMethod_nestedCapture() async {
     await resolveTestUnit(r'''
 class C<T> {
-  /*=T*/ f/*<S>*/(/*=S*/ x) {
-    new C<S>().f/*<int>*/(3);
+  T f<S>(S x) {
+    new C<S>().f<int>(3);
     new C<S>().f; // tear-off
     return null;
   }
 }
 ''');
-    MethodInvocation f = findIdentifier('f/*<int>*/(3);').parent;
+    MethodInvocation f = findIdentifier('f<int>(3);').parent;
     expect(f.staticInvokeType.toString(), '(int) → S');
     FunctionType ft = f.staticInvokeType;
     expect('${ft.typeArguments}/${ft.typeParameters}', '[S, int]/[T, S]');
 
     expectIdentifierType('f;', '<S₀>(S₀) → S');
   }
 
   test_genericMethod_nestedFunctions() async {
     await resolveTestUnit(r'''
-/*=S*/ f/*<S>*/(/*=S*/ x) {
-  g/*<S>*/(/*=S*/ x) => f;
+S f<S>(S x) {
+  g<S>(S x) => f;
   return null;
 }
 ''');
     expectIdentifierType('f', '<S>(S) → S');
     expectIdentifierType('g', '<S>(S) → <S>(S) → S');
   }
 
   test_genericMethod_override() async {
     await resolveTestUnit(r'''
 class C {
-  /*=T*/ f/*<T>*/(/*=T*/ x) => null;
+  T f<T>(T x) => null;
 }
 class D extends C {
-  /*=T*/ f/*<T>*/(/*=T*/ x) => null; // from D
+  T f<T>(T x) => null; // from D
 }
 ''');
-    expectFunctionType('f/*<T>*/(/*=T*/ x) => null; // from D', '<T>(T) → T',
+    expectFunctionType('f<T>(T x) => null; // from D', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
-    SimpleIdentifier f =
-        findIdentifier('f/*<T>*/(/*=T*/ x) => null; // from D');
+    SimpleIdentifier f = findIdentifier('f<T>(T x) => null; // from D');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   test_genericMethod_override_bounds() async {
     await resolveTestUnit(r'''
 class A {}
 class B extends A {}
 class C {
-  /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
+  T f<T extends B>(T x) => null;
 }
 class D extends C {
-  /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
+  T f<T extends A>(T x) => null;
 }
 ''');
   }
 
   test_genericMethod_override_covariant_field() async {
     Source source = addSource(r'''
 abstract class A {
   num get x;
   set x(covariant num _);
 }
 
 class B extends A {
   int x;
 }
 ''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   test_genericMethod_override_invalidReturnType() async {
     Source source = addSource(r'''
 class C {
-  Iterable/*<T>*/ f/*<T>*/(/*=T*/ x) => null;
+  Iterable<T> f<T>(T x) => null;
 }
 class D extends C {
-  String f/*<S>*/(/*=S*/ x) => null;
+  String f<S>(S x) => null;
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_override_invalidTypeParamBounds() async {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class C {
-  /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
+  T f<T extends A>(T x) => null;
 }
 class D extends C {
-  /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
+  T f<T extends B>(T x) => null;
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_override_invalidTypeParamCount() async {
     Source source = addSource(r'''
 class C {
-  /*=T*/ f/*<T>*/(/*=T*/ x) => null;
+  T f<T>(T x) => null;
 }
 class D extends C {
-  /*=S*/ f/*<T, S>*/(/*=T*/ x) => null;
+  S f<T, S>(T x) => null;
 }''');
     await computeAnalysisResult(source);
     assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_propagatedType_promotion() async {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
 
     // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
     // example won't work, as we now compute a static type and therefore discard
     // the propagated type. So a new test was created that doesn't run under
     // strong mode.
     await resolveTestUnit(r'''
 abstract class Iter {
-  List/*<S>*/ map/*<S>*/(/*=S*/ f(x));
+  List<S> map<S>(S f(x));
 }
 class C {}
 C toSpan(dynamic element) {
   if (element is Iter) {
     var y = element.map(toSpan);
   }
   return null;
 }''');
     expectIdentifierType('y = ', 'List<C>', isNull);
   }
 
   test_genericMethod_tearoff() async {
     await resolveTestUnit(r'''
 class C<E> {
-  /*=T*/ f/*<T>*/(E e) => null;
-  static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
+  T f<T>(E e) => null;
+  static T g<T>(T e) => null;
   static final h = g;
 }
 
-/*=T*/ topF/*<T>*/(/*=T*/ e) => null;
+T topF<T>(T e) => null;
 var topG = topF;
-void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
+void test<S>(T pf<T>(T e)) {
   var c = new C<int>();
-  /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
+  T lf<T>(T e) => null;
   var methodTearOff = c.f;
   var staticTearOff = C.g;
   var staticFieldTearOff = C.h;
   var topFunTearOff = topF;
   var topFieldTearOff = topG;
   var localTearOff = lf;
   var paramTearOff = pf;
 }
 ''', noErrors: false // TODO(paulberry): remove when dartbug.com/28515 fixed.
         );
@@ skipping 844 matching lines @@
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     CompilationUnit unit = await resolveSource(code);
     assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 }