Implement AstBuilder integration for method/function invocations.

pkg/analyzer/lib/src/fasta/resolution_applier.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart';
 
 /// Visitor that applies resolution data from the front end (obtained via
 /// [ResolutionStorer]) to an analyzer AST.
@@ skipping 20 matching lines @@
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
     node.argumentList?.accept(this);
     // TODO(paulberry): store resolution of node.constructorName.
     node.staticType = _getTypeFor(node.constructorName);
   }
 
   @override
   void visitMethodInvocation(MethodInvocation node) {
     node.target?.accept(this);
+    node.methodName.staticType = _getTypeFor(node.methodName);

[scheglov, 2017/07/21 04:03:03]

Could we move this statement after arguments, so avoid deferring types in
storer?

[Paul Berry, 2017/07/21 17:40:11]

Unfortunately, your suggestion would break a different case:

void test(f) {
  f(args);
}

In this case, the analyzer AST treats `f(args)` as a method invocation with no
target and a methodName of `f`, but kernel treats it as a method invocation with
a target of `f` (kernel calles it the "receiver") and a method name of `call`,
i.e. equivalent to `f.call(args);`.  So we would still have to reorder types in
storer, we would just have to reorder these implicit "call" cases instead of
reordering ordinary method calls.

I spent some time working out both cases on pen and paper, and IMHO reordering
ordinary method calls is less work.

[scheglov, 2017/07/21 17:43:58]

OK, thank you for the explanation.

     // TODO(paulberry): store resolution of node.methodName.
     // TODO(paulberry): store resolution of node.typeArguments.
     node.argumentList.accept(this);
-    node.staticType = _getTypeFor(node.methodName);
+    node.staticType = _getTypeFor(node.argumentList);
   }
 
   @override
   void visitParenthesizedExpression(ParenthesizedExpression node) {
     node.visitChildren(this);
     node.staticType = node.expression.staticType;
   }
 
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
@@ skipping 59 matching lines @@
   DartType _getTypeFor(AstNode node) {
     if (_debug) print('Getting type for $node');
     if (node.offset != _typeOffsets[_typeIndex]) {
       throw new StateError(
           'Expected a type for analyzer offset ${node.offset}; got one for '
           'kernel offset ${_typeOffsets[_typeIndex]}');
     }
     return super._getTypeFor(node);
   }
 }