Make analyzer more strong mode compliant

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/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 738 matching lines @@
   /**
    * 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,
       {String elementTypeParams: '[]',
       String typeParams: '[]',
       String typeArgs: '[]',
       String typeFormals: '[]'}) {
+    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.
-    var element = identifier.staticElement;
+    Element element = identifier.staticElement;
     FunctionTypeImpl functionType = identifier.staticType;
     expect(functionType.toString(), type);
-    expect(element.typeParameters.toString(), elementTypeParams);
+    expect(typeParameters(element).toString(), elementTypeParams);
     expect(functionType.typeParameters.toString(), typeParams);
     expect(functionType.typeArguments.toString(), typeArgs);
     expect(functionType.typeFormals.toString(), typeFormals);
   }
 
   /**
    * 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]
@@ skipping 54 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);
     }
   }
 }