fixes #24507, allow known functions to be treated as strict arrows

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);
       }
     }
 
-    Element element = null;
-    if (expression is PropertyAccess) {
-      element = expression.propertyName.staticElement;
-    } else if (expression is Identifier) {
-      element = expression.staticElement;
-    }
-    // First class functions and static methods, where we know the original
-    // declaration, will have an exact type, so we know a downcast will fail.
-    if (element is FunctionElement ||
-        element is MethodElement && element.isStatic) {
+    if (StaticInfo.isKnownFunction(expression)) {
       return new StaticTypeError(rules, expression, toT);
     }
 
     // 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);
     }
 
@@ skipping 383 matching lines @@
         ? (node as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
         : node.offset;
     int length = node.end - begin;
     var source = (node.root as CompilationUnit).element.source;
     return new AnalysisError(source, begin, length, toErrorCode(), arguments);
   }
 
   // TODO(jmesserly): review the usage of error codes. We probably want our own,
   // as well as some DDC specific [ErrorType]s.
   ErrorCode toErrorCode();
+
+  static bool isKnownFunction(Expression expression) {
+    Element element = null;
+    if (expression is PropertyAccess) {
+      element = expression.propertyName.staticElement;
+    } else if (expression is Identifier) {
+      element = expression.staticElement;
+    }
+    // First class functions and static methods, where we know the original
+    // declaration, will have an exact type, so we know a downcast will fail.
+    return element is FunctionElement ||
+        element is MethodElement && element.isStatic;
+  }
 }
 
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
 
   StaticTypeError(TypeSystem rules, Expression expression, this.expectedType)
       : baseType = expression.staticType ?? DynamicTypeImpl.instance,
         super(expression);
 
   @override
   List<Object> get arguments => [node, baseType, expectedType];
   @override
   String get message => 'Type check failed: {0} ({1}) is not of type {2}';
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }