fixes #25640, errors on function downcasts when we know it's an exact type

pkg/analyzer/lib/src/task/strong/info.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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.info;
 
@@ skipping 120 matching lines @@
     }
     if (expression is InstanceCreationExpression) {
       ConstructorElement e = expression.staticElement;
       if (e == null || !e.isFactory) {
         // fromT should be an exact type - this will almost certainly fail at
         // runtime.
         return new StaticTypeError(rules, expression, toT, reason: reason);
       }
     }
 
+    Element staticElement = null;
+    if (expression is PropertyAccess) {
+      staticElement = expression.propertyName.staticElement;
+    } else if (expression is Identifier) {
+      staticElement = expression.staticElement;
+    }
+    // First class functions, where we know the original declaration, will have
+    // an exact type, so we know a downcast will fail.
+    if (staticElement is FunctionElement) {

[vsm, 2016/02/03 23:51:59]

Does this guarantee a static or top-level function (as opposed to a method)?

[Jennifer Messerly, 2016/02/04 00:41:30]

It includes top-level and local functions (named, lambdas). Does not include
methods (instance or static). Also does not include things that can store
first-class functions, like variables/parameters/fields.

The common base class between MethodElement, FunctionElement, and
PropertyAccessorElement is called ExecutableElement. (There is a further up
interface, called FunctionTypedElement, that includes typedefs as well.)

+      return new StaticTypeError(rules, expression, toT, reason: reason);
+    }
+
     // TODO(vsm): Change this to an assert when we have generic methods and
     // fix TypeRules._coerceTo to disallow implicit sideways casts.
     if (!rules.isSubtypeOf(toT, fromT)) {
       assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
       return new DownCastComposite(rules, expression, cast);
     }
 
     // Composite cast: these are more likely to fail.
     if (!rules.isGroundType(toT)) {
       // This cast is (probably) due to our different treatment of dynamic.
@@ skipping 402 matching lines @@
   @override
   List<Object> get arguments => [node, baseType, expectedType];
   @override
   String get message =>
       'Type check failed: {0} ({1}) is not of type {2}' +
       ((reason == null) ? '' : ' because $reason');
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }