change static method types to not have the class type parameters

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/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 10207 matching lines @@
 """;
     _resolveTestUnit(code);
     SimpleIdentifier identifier = _findIdentifier("p()");
     expect(identifier.staticType, DynamicTypeImpl.instance);
     {
       FunctionType type = identifier.propagatedType;
       expect(type, isNotNull);
       expect(type.name, 'Foo');
     }
   }
+
+  void test_staticMethods_classTypeParameters() {
+    String code = r'''
+class C<T> {
+  static void m() => null;
+}
+main() {
+  print(C.m);
+}
+''';
+    _resolveTestUnit(code);
+    SimpleIdentifier identifier = _findIdentifier('m);');
+    FunctionTypeImpl type = identifier.staticType;
+    expect(type.toString(), '() → void');
+    expect(type.typeParameters, isEmpty,
+        reason: 'static methods should not have type parameters');
+    expect(type.typeArguments, isEmpty,
+        reason: 'static methods should not have type arguments');
+    expect(type.typeFormals, isEmpty,
+        reason: 'this tatic method is not generic');

[vsm, 2016/02/11 23:38:27]

s/tatic/static/

+  }
+
+  void test_staticMethods_classTypeParameters_genericMethod() {
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.enableGenericMethods = true;
+    resetWithOptions(options);
+    String code = r'''
+class C<T> {
+  static void m<S>(S s) => null;
+}
+main() {
+  print(C.m);
+}
+''';
+    _resolveTestUnit(code);
+    SimpleIdentifier identifier = _findIdentifier('m);');
+    FunctionTypeImpl type = identifier.staticType;
+    expect(type.toString(), '<S>(S) → void');
+    expect(type.typeParameters, isEmpty,
+        reason: 'static methods should not have type parameters');
+    expect(type.typeArguments, isEmpty,
+        reason: 'static methods should not have type arguments');
+    expect(type.typeFormals.toString(), '[S]');
+
+    type = type.instantiate([DynamicTypeImpl.instance]);
+    expect(type.toString(), '(dynamic) → void');
+    expect(type.typeParameters.toString(), '[S]');
+    expect(type.typeArguments, [DynamicTypeImpl.instance]);
+    expect(type.typeFormals, isEmpty);
+  }
 }
 
 @reflectiveTest
 class StaticTypeAnalyzerTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
@@ skipping 3143 matching lines @@
   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.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.typeParameters.toString(), '[]');
+    expect(e.type.typeArguments.toString(), '[]');
     expect(e.type.toString(), '<T>(T) → T');
 
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
   void test_genericFunction_typedef() {
     String code = r'''
 typedef T F<T>(T x);
 F f0;
@@ skipping 366 matching lines @@
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
     expect(declaration.initializer.staticType.name, 'int');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
+  void test_genericMethod_nestedBound() {
+    String code = r'''
+class Foo<T extends num> {
+  void method/*<U extends T>*/(dynamic/*=U*/ u) {
+    u.abs();
+  }
+}
+''';
+    // Just validate that there is no warning on the call to `.abs()`.
+    _resolveTestUnit(code);
+  }
+
   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;
   }
 }
 ''');
@@ skipping 203 matching lines @@
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
 
     expect(declaration.initializer.staticType.toString(), "Future<String>");
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_genericMethod_nestedBound() {
-    String code = r'''
-class Foo<T extends num> {
-  void method/*<U extends T>*/(dynamic/*=U*/ u) {
-    u.abs();
-  }
-}
-''';
-    // Just validate that there is no warning on the call to `.abs()`.
-    _resolveTestUnit(code);
-  }
-
   void test_genericMethod_then_propagatedType() {
     // Regression test for https://github.com/dart-lang/sdk/issues/25482.
     String code = r'''
 import 'dart:async';
 void main() {
   Future<String> p;
   var foo = p.then((r) => new Future<String>.value(3));
 }
 ''';
     // This should produce no hints or warnings.
@@ skipping 3021 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }