fix #26393, treat tear offs as definite functions

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';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/error.dart' show StrongModeCode;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart';
 
 import 'ast_properties.dart';
 
-bool isKnownFunction(Expression expression, {bool instanceMethods: false}) {
-  Element element = null;
+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;
+}
+
+bool _hasStrictArrow(Expression expression) {
+  var element = _getKnownElement(expression);
+  return element is FunctionElement || element is MethodElement;
+}
+
+Element _getKnownElement(Expression expression) {
   if (expression is ParenthesizedExpression) {
     expression = (expression as ParenthesizedExpression).expression;
   }
   if (expression is FunctionExpression) {
-    return true;
+    return expression.element;
   } else if (expression is PropertyAccess) {
-    element = expression.propertyName.staticElement;
+    return expression.propertyName.staticElement;
   } else if (expression is Identifier) {
-    element = expression.staticElement;
+    return 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 && (instanceMethods || element.isStatic);
+  return null;
 }
 
 DartType _elementType(Element e) {
   if (e == null) {
     // Malformed code - just return dynamic.
     return DynamicTypeImpl.instance;
   }
   return (e as dynamic).type;
 }
 
@@ skipping 54 matching lines @@
         baseMethod = type.getSetter(memberName);
       } else {
         baseMethod = type.getMethod(memberName);
       }
     } catch (e) {
       // TODO(sigmund): remove this try-catch block (see issue #48).
     }
     if (baseMethod == null || baseMethod.isStatic) return null;
     return baseMethod.type;
   }
+
   return f;
 }
 
 typedef FunctionType _MemberTypeGetter(InterfaceType type);
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
   final StrongTypeSystemImpl rules;
   final TypeProvider typeProvider;
   final AnalysisErrorListener reporter;
@@ skipping 832 matching lines @@
     } else {
       // Malformed type - fallback on analyzer error.
       return null;
     }
   }
 
   DartType _getStaticType(Expression expr) {
     DartType t = expr.staticType ?? DynamicTypeImpl.instance;
 
     // Remove fuzzy arrow if possible.
-    if (t is FunctionType && isKnownFunction(expr)) {
+    if (t is FunctionType && _hasStrictArrow(expr)) {
       t = rules.functionTypeToConcreteType(typeProvider, t);
     }
 
     return t;
   }
 
   /// Given an expression, return its type assuming it is
   /// in the caller position of a call (that is, accounting
   /// for the possibility of a call method).  Returns null
   /// if expression is not statically callable.
   FunctionType _getTypeAsCaller(Expression node) {
-    DartType t = node.staticType;
+    DartType t = _getStaticType(node);
     if (node is SimpleIdentifier) {
       Expression parent = node.parent;
       if (parent is MethodInvocation) {
         t = parent.staticInvokeType;
       }
     }
     if (t is InterfaceType) {
       return rules.getCallMethodType(t);
     }
     if (t is FunctionType) {
       return t;
     }
     return null;
   }
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool _isDynamicCall(Expression 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 (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 (isKnownFunction(call, instanceMethods: true)) {
+    if (_hasStrictArrow(call)) {
       return false;
     }
     return rules.anyParameterType(ft, (pt) => pt.isDynamic);
   }
 
   /// Returns `true` if the target expression is dynamic.
   bool _isDynamicTarget(Expression node) {
     if (node == null) return false;
 
     if (_isLibraryPrefix(node)) return false;
@@ skipping 263 matching lines @@
       AstNode errorLocation,
       Set<String> seen,
       bool isSubclass) {
     void checkHelper(ExecutableElement e) {
       if (e.isStatic) return;
       if (seen.contains(e.name)) return;
       if (_checkSingleOverride(e, baseType, null, errorLocation, isSubclass)) {
         seen.add(e.name);
       }
     }
+
     subType.methods.forEach(checkHelper);
     subType.accessors.forEach(checkHelper);
   }
 
   /// Checks that [cls] and its super classes (including mixins) correctly
   /// overrides each interface in [interfaces]. If [includeParents] is false,
   /// then mixins are still checked, but the base type and it's transitive
   /// supertypes are not.
   ///
   /// [cls] can be either a [ClassDeclaration] or a [InterfaceType]. For
@@ skipping 202 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));
   }
 }