clean up generic methods in resolution

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/element/element.dart';
@@ skipping 770 matching lines @@
   }
 
   DartType _getStaticType(Expression expr) {
     return expr.staticType ?? DynamicTypeImpl.instance;
   }
 
   /// 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 applicand) {
-    var t = applicand.staticType ?? DynamicTypeImpl.instance;
+  FunctionType _getTypeAsCaller(Expression node) {
+    DartType t = node.staticType;
+    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;
   }
 
   /// Checks if we can perform downwards inference on [e] tp get type [t].
   /// If it is not possible, this will add a message to [errors].
   bool _inferExpression(Expression e, DartType t, List<String> errors) {
@@ skipping 432 matching lines @@
     } while (!current.isObject && !visited.contains(current));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     _reporter.onError(error);
   }
 }