some fixes for --strong warnings

lib/src/checker/rules.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.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 452 matching lines @@
     return (e as dynamic).type;
   }
 
   /// Returns `true` if the target expression is dynamic.
   // TODO(jmesserly): remove this in favor of utils? Or a static method here?
   bool isDynamicTarget(Expression target) => utils.isDynamicTarget(target);
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
-    var t = getTypeAsCaller(call);
+    var ft = getTypeAsCaller(call);
     // TODO(leafp): This will currently return true if t is Function
     // This is probably the most correct thing to do for now, since
     // this code is also used by the back end.  Maybe revisit at some
     // point?
-    if (t == null) return true;
+    if (ft == null) return true;
     // Dynamic as the parameter type is treated as bottom.  A function with
     // a dynamic parameter type requires a dynamic call in general.
     // However, as an optimization, if we have an original definition, we know
     // dynamic is reified as Object - in this case a regular call is fine.
     if (call is SimpleIdentifier) {
       var element = call.staticElement;
       if (element is FunctionElement || element is MethodElement) {
         // An original declaration.
         return false;
       }
     }
 
-    var ft = t as FunctionType;
     return _anyParameterType(ft, (pt) => pt.isDynamic);
   }
 }
 
 class DownwardsInference {
   final TypeRules rules;
 
   DownwardsInference(this.rules);
 
   /// Called for each list literal which gets inferred
@@ skipping 274 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }