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}) {
+bool isKnownFunction(Expression expression) {
   Element element = null;
   if (expression is ParenthesizedExpression) {
     expression = (expression as ParenthesizedExpression).expression;
   }
   if (expression is FunctionExpression) {
     return true;
   } else 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 && (instanceMethods || element.isStatic);
+      element is MethodElement;
 }
 
 DartType _elementType(Element e) {
   if (e == null) {
     // Malformed code - just return dynamic.
     return DynamicTypeImpl.instance;
   }
   return (e as dynamic).type;
 }
 
@@ skipping 947 matching lines @@
     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 (isKnownFunction(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 485 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));
   }
 }