fix #27764, split STATIC_TYPE_ERROR into more detailed ones

pkg/analyzer/lib/src/task/strong/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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1033 matching lines @@
 
   /// Records an implicit cast for the [expr] from [from] to [to].
   ///
   /// This will emit the appropriate error/warning/hint message as well as mark
   /// the AST node.
   void _recordImplicitCast(Expression expr, DartType to,
       {DartType from, bool opAssign: false}) {
     assert(rules.isSubtypeOf(to, from));
 
     // Inference "casts":
-    if (expr is Literal || expr is FunctionExpression) {
+    if (expr is Literal) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      _recordMessage(expr, StrongModeCode.STATIC_TYPE_ERROR, [expr, from, to]);
+      if (expr is ListLiteral) {
+        _recordMessage(
+            expr, StrongModeCode.INVALID_CAST_LITERAL_LIST, [from, to]);
+      } else if (expr is MapLiteral) {
+        _recordMessage(
+            expr, StrongModeCode.INVALID_CAST_LITERAL_MAP, [from, to]);
+      } else {
+        _recordMessage(
+            expr, StrongModeCode.INVALID_CAST_LITERAL, [expr, from, to]);
+      }
       return;
     }
 
+    if (expr is FunctionExpression) {
+      _recordMessage(
+          expr, StrongModeCode.INVALID_CAST_FUNCTION_EXPR, [from, to]);
+      return;
+    }
+
     if (expr is InstanceCreationExpression) {
       ConstructorElement e = expr.staticElement;
       if (e == null || !e.isFactory) {
         // fromT should be an exact type - this will almost certainly fail at
         // runtime.
-
-        _recordMessage(
-            expr, StrongModeCode.STATIC_TYPE_ERROR, [expr, from, to]);
+        _recordMessage(expr, StrongModeCode.INVALID_CAST_NEW_EXPR, [from, to]);
         return;
       }
     }
 
     if (isKnownFunction(expr)) {
-      _recordMessage(expr, StrongModeCode.STATIC_TYPE_ERROR, [expr, from, to]);
+      Element e = _getKnownElement(expr);
+      _recordMessage(
+          expr,
+          e is MethodElement
+              ? StrongModeCode.INVALID_CAST_METHOD
+              : StrongModeCode.INVALID_CAST_FUNCTION,
+          [e.name, from, to]);
       return;
     }
 
     // Composite cast: these are more likely to fail.
     bool downCastComposite = false;
     if (!rules.isGroundType(to)) {
       // This cast is (probably) due to our different treatment of dynamic.
       // It may be more likely to fail at runtime.
       if (from is InterfaceType) {
         // For class types, we'd like to allow non-generic down casts, e.g.,
@@ skipping 392 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }