Fix AST-based type inference with explicit type parameters for method calls.

pkg/analyzer/lib/src/summary/format.fbs

 // 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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 
 /**
  * Kind of a source in the cache.
@@ skipping 543 matching lines @@
   extractIndex,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
    * [UnlinkedConst.ints]) into a list (filled from the end) and take the next
    * `n` values from [UnlinkedConst.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
    * stack (where `m` is obtained from [UnlinkedConst.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke a method (or a function) with
-   * the reference from [UnlinkedConst.references].  Push the result of
-   * invocation value into the stack.
+   * the reference from [UnlinkedConst.references].  If `l` is nonzero (where
+   * `l` is obtained from [UnlinkedConst.ints]), obtain `l` type arguments from
+   * [UnlinkedConst.references] and use them as generic type arguments for the
+   * aforementioned method or function.  Push the result of the invocation onto
+   * the stack.
    *
    * In general `a.b` cannot not be distinguished between: `a` is a prefix and
    * `b` is a top-level function; or `a` is an object and `b` is the name of a
    * method.  This operation should be used for a sequence of identifiers
    * `a.b.b.c.d.e` ending with an invokable result.
    */
   invokeMethodRef,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
    * [UnlinkedConst.ints]) into a list (filled from the end) and take the next
    * `n` values from [UnlinkedConst.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
    * stack (where `m` is obtained from [UnlinkedConst.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke the method with the name from
-   * [UnlinkedConst.strings] of the target popped from the stack, and push the
-   * resulting value into the stack.
+   * [UnlinkedConst.strings] of the target popped from the stack.  If `l` is
+   * nonzero (where `l` is obtained from [UnlinkedConst.ints]), obtain `l` type
+   * arguments from [UnlinkedConst.references] and use them as generic type
+   * arguments for the aforementioned method.  Push the result of the
+   * invocation onto the stack.
    *
    * This operation should be used for invocation of a method invocation
-   * where `target` is know to be an object instance.
+   * where `target` is known to be an object instance.
    */
   invokeMethod,
 
   /**
    * Begin a new cascade section.  Duplicate the top value of the stack.
    */
   cascadeSectionBegin,
 
   /**
    * End a new cascade section.  Pop the top value from the stack and throw it
@@ skipping 1772 matching lines @@
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   visibleOffset:uint (id: 12);
 }
 
 root_type PackageBundle;
 
 file_identifier "PBdl";