fix #28630, instance method tear-offs are treated as strict arrows

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 18 matching lines @@
 /// storage slot that would contain it. For function types, this is necessarily
 /// a "fuzzy arrow" that treats `dynamic` as bottom. However, if we're
 /// interested in the expression's own type, it can often be a "strict arrow"
 /// because we know it evaluates to a specific, concrete function, and we can
 /// treat "dynamic" as top for that case, which is more permissive.
 DartType getDefiniteType(
     Expression expression, TypeSystem typeSystem, TypeProvider typeProvider) {
   DartType type = expression.staticType ?? DynamicTypeImpl.instance;
   if (typeSystem is StrongTypeSystemImpl &&
       type is FunctionType &&
-      _hasStrictArrow(expression)) {
+      hasStrictArrow(expression)) {
     // Remove fuzzy arrow if possible.
     return typeSystem.functionTypeToConcreteType(type);
   }
   return type;
 }
 
-bool isKnownFunction(Expression expression) {
-  var element = _getKnownElement(expression);
-  // 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;
-}
-
 DartType _elementType(Element e) {
   if (e == null) {
     // Malformed code - just return dynamic.
     return DynamicTypeImpl.instance;
   }
   return (e as dynamic).type;
 }
 
 Element _getKnownElement(Expression expression) {
   if (expression is ParenthesizedExpression) {
@@ skipping 34 matching lines @@
   }
   if (field.isSynthetic) return null;
   return field;
 }
 
 /// Looks up the declaration that matches [member] in [type] and returns it's
 /// declared type.
 FunctionType _getMemberType(InterfaceType type, ExecutableElement member) =>
     _memberTypeGetter(member)(type);
 
-bool _hasStrictArrow(Expression expression) {
+bool hasStrictArrow(Expression expression) {
   var element = _getKnownElement(expression);
   return element is FunctionElement || element is MethodElement;
 }
 
 _MemberTypeGetter _memberTypeGetter(ExecutableElement member) {
   String memberName = member.name;
   final isGetter = member is PropertyAccessorElement && member.isGetter;
   final isSetter = member is PropertyAccessorElement && member.isSetter;
 
   FunctionType f(InterfaceType type) {
@@ skipping 876 matching lines @@
   bool _isDynamicCall(InvocationExpression call, FunctionType ft) {
     // 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 (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 (_hasStrictArrow(call.function)) {
+    if (hasStrictArrow(call.function)) {
       return false;
     }
     return rules.anyParameterType(ft, (pt) => pt.isDynamic);
   }
 
   /// Returns true if we need an implicit cast of [expr] from [from] type to
   /// [to] type, otherwise returns false.
   ///
   /// If [from] is omitted, uses the static type of [expr].
   bool _needsImplicitCast(Expression expr, DartType to, {DartType from}) {
@@ skipping 67 matching lines @@
     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.INVALID_CAST_NEW_EXPR, [from, to]);
         return;
       }
     }
 
-    if (isKnownFunction(expr)) {
-      Element e = _getKnownElement(expr);
+    Element e = _getKnownElement(expr);
+    if (e is FunctionElement || e is MethodElement && e.isStatic) {
       _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.
@@ skipping 395 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));
   }
 }