some fixes for --strong warnings

lib/src/checker/checker.dart

 // Copyright (c) 2015, 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 dev_compiler.src.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 102 matching lines @@
       if (interfaceType == null || interfaceType.isObject) return;
       if (result.contains(interfaceType)) return;
       result.add(interfaceType);
       find(interfaceType.superclass, result);
       interfaceType.mixins.forEach((i) => find(i, result));
       interfaceType.interfaces.forEach((i) => find(i, result));
     }
 
     // Check all interfaces reachable from the `implements` clause in the
     // current class against definitions here and in superclasses.
-    var localInterfaces = new Set();
+    var localInterfaces = new Set<InterfaceType>();
     var type = node.element.type;
     type.interfaces.forEach((i) => find(i, localInterfaces));
     _checkInterfacesOverrides(node, localInterfaces, seen,
         includeParents: true);
 
     // Check also how we override locally the interfaces from parent classes if
     // the parent class is abstract. Otherwise, these will be checked as
     // overrides on the concrete superclass.
-    var superInterfaces = new Set();
+    var superInterfaces = new Set<InterfaceType>();
     var parent = type.superclass;
     // TODO(sigmund): we don't seem to be reporting the analyzer error that a
     // non-abstract class is not implementing an interface. See
     // https://github.com/dart-lang/dart-dev-compiler/issues/25
     while (parent != null && parent.element.isAbstract) {
       parent.interfaces.forEach((i) => find(i, superInterfaces));
       parent = parent.superclass;
     }
     _checkInterfacesOverrides(node, superInterfaces, seen,
         includeParents: false);
@@ skipping 89 matching lines @@
           var setter = element.setter;
           bool found = _checkSingleOverride(getter, baseType, variable, member);
           if (!variable.isFinal &&
               _checkSingleOverride(setter, baseType, variable, member)) {
             found = true;
           }
           if (found) seen.add(name);
         }
       } else {
         if ((member as MethodDeclaration).isStatic) continue;
-        var method = member.element;
+        var method = (member as MethodDeclaration).element;
         if (seen.contains(method.name)) continue;
         if (_checkSingleOverride(method, baseType, member, member)) {
           seen.add(method.name);
         }
       }
     }
   }
 
   /// Checks that [element] correctly overrides its corresponding member in
   /// [type]. Returns `true` if an override was found, that is, if [element] has
@@ skipping 581 matching lines @@
       if (rules.isDynamicTarget(node.leftOperand)) {
         // Dynamic invocation
         // TODO(vsm): Move this logic to the resolver?
         if (op.type != TokenType.EQ_EQ && op.type != TokenType.BANG_EQ) {
           _recordDynamicInvoke(node, node.leftOperand);
         }
       } else {
         var element = node.staticElement;
         // Method invocation.
         if (element is MethodElement) {
-          var type = element.type as FunctionType;
+          var type = element.type;
           // Analyzer should enforce number of parameter types, but check in
           // case we have erroneous input.
           if (type.normalParameterTypes.isNotEmpty) {
             checkArgument(node.rightOperand, type.normalParameterTypes[0]);
           }
         } else {
           // TODO(vsm): Assert that the analyzer found an error here?
         }
       }
     } else {
@@ skipping 20 matching lines @@
   }
 
   @override
   void visitIndexExpression(IndexExpression node) {
     var target = node.realTarget;
     if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
     } else {
       var element = node.staticElement;
       if (element is MethodElement) {
-        var type = element.type as FunctionType;
+        var type = element.type;
         // Analyzer should enforce number of parameter types, but check in
         // case we have erroneous input.
         if (type.normalParameterTypes.isNotEmpty) {
           checkArgument(node.index, type.normalParameterTypes[0]);
         }
       } else {
         // TODO(vsm): Assert that the analyzer found an error here?
       }
     }
     node.visitChildren(this);
@@ skipping 103 matching lines @@
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     reporter.onError(error);
 
     if (info is CoercionInfo) {
       assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }