clean up generic methods in resolution

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 13045 matching lines @@
         identifier.getAncestor((node) => node is VariableDeclaration);
     expect(declaration.initializer.staticType.name, 'String');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
   void test_genericFunction() {
     _resolveTestUnit(r'/*=T*/ f/*<T>*/(/*=T*/ x) => null;');
     SimpleIdentifier f = _findIdentifier('f');
     FunctionElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.boundTypeParameters.toString(), '[T]');
+    expect(e.type.typeFormals.toString(), '[T]');
     expect(e.type.typeParameters.toString(), '[]');
     expect(e.type.toString(), '<T>(T) → T');
 
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   void test_genericFunction_bounds() {
     _resolveTestUnit(r'/*=T*/ f/*<T extends num>*/(/*=T*/ x) => null;');
     SimpleIdentifier f = _findIdentifier('f');
     FunctionElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T extends num]');
-    expect(e.type.boundTypeParameters.toString(), '[T extends num]');
+    expect(e.type.typeFormals.toString(), '[T extends num]');
     expect(e.type.typeParameters.toString(), '[]');
     expect(e.type.toString(), '<T extends num>(T) → T');
   }
 
   void test_genericFunction_static() {
     _resolveTestUnit(r'''
 class C<E> {
   static /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 ''');
     SimpleIdentifier f = _findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.boundTypeParameters.toString(), '[T]');
+    expect(e.type.typeFormals.toString(), '[T]');
     // TODO(jmesserly): we could get rid of this {E/E} substitution, but it's
     // probably harmless, as E won't be used in the function (error verifier
     // checks this), and {E/E} is a no-op anyway.
     expect(e.type.typeParameters.toString(), '[E]');
     expect(e.type.typeArguments.toString(), '[E]');
     expect(e.type.toString(), '<T>(T) → T');
 
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
@@ skipping 78 matching lines @@
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     SimpleIdentifier f = _findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.boundTypeParameters.toString(), '[T]');
+    expect(e.type.typeFormals.toString(), '[T]');
     expect(e.type.typeParameters.toString(), '[E]');
     expect(e.type.typeArguments.toString(), '[E]');
     expect(e.type.toString(), '<T>(E) → List<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]');
   }
 
   void test_genericMethod_explicitTypeParams() {
     _resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
   var x = cOfString.f/*<int>*/('hi');
 }
 ''');
-    SimpleIdentifier f = _findIdentifier('f/*<int>*/');
-    FunctionType ft = f.staticType;
+    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.substitute4([typeProvider.intType]));
   }
 
   void test_genericMethod_functionTypedParameter() {
     _resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(/*=T*/ f(E e)) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     SimpleIdentifier f = _findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.boundTypeParameters.toString(), '[T]');
+    expect(e.type.typeFormals.toString(), '[T]');
     expect(e.type.typeParameters.toString(), '[E]');
     expect(e.type.typeArguments.toString(), '[E]');
     expect(e.type.toString(), '<T>((E) → T) → List<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>');
   }
 
   void test_genericMethod_implicitDynamic() {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25100#issuecomment-162047588
     // These should not cause any hints or warnings.
     _resolveTestUnit(r'''
 class List<E> {
   /*=T*/ map/*<T>*/(/*=T*/ f(E e)) => null;
 }
 void foo() {
   List list = null;
   list.map((e) => e);
   list.map((e) => 3);
 }''');
 
     SimpleIdentifier map1 = _findIdentifier('map((e) => e);');
-    expect(map1.staticType.toString(), '((dynamic) → dynamic) → dynamic');
+    MethodInvocation m1 = map1.parent;
+    expect(m1.staticInvokeType.toString(), '((dynamic) → dynamic) → dynamic');
+    expect(map1.staticType, isNull);
     expect(map1.propagatedType, isNull);
     SimpleIdentifier map2 = _findIdentifier('map((e) => 3);');
-    expect(map2.staticType.toString(), '((dynamic) → int) → int');
+    MethodInvocation m2 = map2.parent;
+    expect(m2.staticInvokeType.toString(), '((dynamic) → int) → int');
+    expect(map2.staticType, isNull);
     expect(map2.propagatedType, isNull);
   }
 
   void test_genericMethod_nestedCapture() {
     _resolveTestUnit(r'''
 class C<T> {
   /*=T*/ f/*<S>*/(/*=S*/ x) {
     new C<S>().f/*<int>*/(3);
     new C<S>().f; // tear-off
     return null;
   }
 }
 ''');
-    SimpleIdentifier f = _findIdentifier('f/*<int>*/(3);');
-    expect(f.staticType.toString(), '(int) → S');
-    FunctionType ft = f.staticType;
+    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]');
 
-    f = _findIdentifier('f;');
-    expect(f.staticType.toString(), '<S₀>(S₀) → S');
+    SimpleIdentifier f2 = _findIdentifier('f;');
+    expect(f2.staticType.toString(), '<S₀>(S₀) → S');
   }
 
   void test_genericMethod_nestedFunctions() {
     _resolveTestUnit(r'''
 /*=S*/ f/*<S>*/(/*=S*/ x) {
   g/*<S>*/(/*=S*/ x) => f;
   return null;
 }
 ''');
     SimpleIdentifier g = _findIdentifier('f');
     expect(g.staticType.toString(), '<S>(S) → S');
     SimpleIdentifier f = _findIdentifier('g');
     expect(f.staticType.toString(), '<S>(S) → dynamic');
   }
 
   void test_genericMethod_override() {
     _resolveTestUnit(r'''
 class C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null; // from D
 }
 ''');
     SimpleIdentifier f =
         _findIdentifier('f/*<T>*/(/*=T*/ x) => null; // from D');
     MethodElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.boundTypeParameters.toString(), '[T]');
+    expect(e.type.typeFormals.toString(), '[T]');
     expect(e.type.toString(), '<T>(T) → T');
 
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   void test_genericMethod_override_bounds() {
     _resolveTestUnit(r'''
 class A {}
 class B extends A {}
@@ skipping 3052 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }