fixes #28236, generic methods should not cause warnings in Dart 1

pkg/analyzer/test/generated/resolver_test_case.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.resolver_test_case;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 734 matching lines @@
 class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
   String testCode;
   Source testSource;
   CompilationUnit testUnit;
 
   /**
    * Looks up the identifier with [name] and validates that its type type
    * stringifies to [type] and that its generics match the given stringified
    * output.
    */
-  expectFunctionType(String name, String type,
+  FunctionTypeImpl expectFunctionType(String name, String type,
       {String elementTypeParams: '[]',
       String typeParams: '[]',
       String typeArgs: '[]',
-      String typeFormals: '[]'}) {
+      String typeFormals: '[]',
+      String identifierType}) {
+    identifierType ??= type;
+
     typeParameters(Element element) {
       if (element is ExecutableElement) {
         return element.typeParameters;
       } else if (element is ParameterElement) {
         return element.typeParameters;
       }
       fail('Wrong element type: ${element.runtimeType}');
     }
 
     SimpleIdentifier identifier = findIdentifier(name);
     // Element is either ExecutableElement or ParameterElement.
-    Element element = identifier.staticElement;
-    FunctionTypeImpl functionType = identifier.staticType;
+    var element = identifier.staticElement;
+    FunctionTypeImpl functionType = (element as dynamic).type;
     expect(functionType.toString(), type);
+    expect(identifier.staticType.toString(), identifierType);
     expect(typeParameters(element).toString(), elementTypeParams);
     expect(functionType.typeParameters.toString(), typeParams);
     expect(functionType.typeArguments.toString(), typeArgs);
     expect(functionType.typeFormals.toString(), typeFormals);
+    return functionType;
   }
 
   /**
    * Looks up the identifier with [name] and validates its static [type].
    *
    * If [type] is a string, validates that the identifier's static type
    * stringifies to that text. Otherwise, [type] is used directly a [Matcher]
    * to match the type.
    *
    * If [propagatedType] is given, also validate's the identifier's propagated
@@ skipping 51 matching lines @@
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }