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

pkg/analyzer/lib/src/summary/summarize_const_expr.dart

 // Copyright (c) 2016, 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.
 
 library serialization.summarize_const_expr;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 119 matching lines @@
   /**
    * Return [EntityRefBuilder] that corresponds to the constructor having name
    * [name] in the class identified by [typeName].  It is expected that [type]
    * corresponds to the given [typeName] and [typeArguments].  The parameter
    * [type] might be `null` if the type is not resolved.
    */
   EntityRefBuilder serializeConstructorRef(DartType type, Identifier typeName,
       TypeArgumentList typeArguments, SimpleIdentifier name);
 
   /**
-   * Return [EntityRefBuilder] that corresponds to the given [identifier].
-   */
-  EntityRefBuilder serializeIdentifier(Identifier identifier);
-
-  /**
    * Return a pair of ints showing how the given [functionExpression] is nested
    * within the constant currently being serialized.  The first int indicates
    * how many levels of function nesting must be popped in order to reach the
    * parent of the [functionExpression].  The second int is the index of the
    * [functionExpression] within its parent element.
    *
    * If the constant being summarized is in a context where local function
    * references are not allowed, return `null`.
    */
   List<int> serializeFunctionExpression(FunctionExpression functionExpression);
 
   /**
+   * Return [EntityRefBuilder] that corresponds to the given [identifier].
+   */
+  EntityRefBuilder serializeIdentifier(Identifier identifier);
+
+  /**
    * Return [EntityRefBuilder] that corresponds to the given [expr], which
    * must be a sequence of identifiers.
    */
   EntityRefBuilder serializeIdentifierSequence(Expression expr);
 
   void serializeInstanceCreation(
       EntityRefBuilder constructor, ArgumentList argumentList) {
     _serializeArguments(argumentList);
     references.add(constructor);
     operations.add(UnlinkedConstOperation.invokeConstructor);
@@ skipping 24 matching lines @@
         isValidConst: isValidConst,
         operations: operations,
         assignmentOperators: assignmentOperators,
         ints: ints,
         doubles: doubles,
         strings: strings,
         references: references);
   }
 
   /**
+   * Return `true` if the given [expr] is a sequence of identifiers.
+   */
+  bool _isIdentifierSequence(Expression expr) {
+    while (expr != null) {
+      if (expr is SimpleIdentifier) {
+        AstNode parent = expr.parent;
+        if (parent is MethodInvocation && parent.methodName == expr) {
+          if (parent.isCascaded) {
+            return false;
+          }
+          return parent.target == null || _isIdentifierSequence(parent.target);
+        }
+        if (isParameterName(expr.name)) {
+          return false;
+        }
+        return true;
+      } else if (expr is PrefixedIdentifier) {
+        expr = (expr as PrefixedIdentifier).prefix;
+      } else if (expr is PropertyAccess) {
+        expr = (expr as PropertyAccess).target;
+      } else {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Push the operation for the given assignable [expr].
    */
   void _pushAssignable(Expression expr) {
     if (_isIdentifierSequence(expr)) {
       EntityRefBuilder ref = serializeIdentifierSequence(expr);
       references.add(ref);
       operations.add(UnlinkedConstOperation.assignToRef);
     } else if (expr is PropertyAccess) {
       if (!expr.isCascaded) {
         _serialize(expr.target);
@@ skipping 56 matching lines @@
       _serializeString(expr);
     } else if (expr is SymbolLiteral) {
       strings.add(expr.components.map((token) => token.lexeme).join('.'));
       operations.add(UnlinkedConstOperation.makeSymbol);
     } else if (expr is NullLiteral) {
       operations.add(UnlinkedConstOperation.pushNull);
     } else if (expr is Identifier) {
       if (expr is SimpleIdentifier && isParameterName(expr.name)) {
         strings.add(expr.name);
         operations.add(UnlinkedConstOperation.pushParameter);
-      } else if (expr is PrefixedIdentifier && isParameterName(expr.prefix.name)) {
+      } else if (expr is PrefixedIdentifier &&
+          isParameterName(expr.prefix.name)) {
         strings.add(expr.prefix.name);
         operations.add(UnlinkedConstOperation.pushParameter);
         strings.add(expr.identifier.name);
         operations.add(UnlinkedConstOperation.extractProperty);
       } else {
         references.add(serializeIdentifier(expr));
         operations.add(UnlinkedConstOperation.pushReference);
       }
     } else if (expr is InstanceCreationExpression) {
       if (!expr.isConst) {
@@ skipping 216 matching lines @@
         invocation.methodName.name != 'identical') {
       isValidConst = false;
     }
     Expression target = invocation.target;
     SimpleIdentifier methodName = invocation.methodName;
     ArgumentList argumentList = invocation.argumentList;
     if (_isIdentifierSequence(methodName)) {
       EntityRefBuilder ref = serializeIdentifierSequence(methodName);
       _serializeArguments(argumentList);
       references.add(ref);
+      _serializeTypeArguments(invocation.typeArguments);
       operations.add(UnlinkedConstOperation.invokeMethodRef);
     } else {
       if (!invocation.isCascaded) {
         _serialize(target);
       }
       _serializeArguments(argumentList);
       strings.add(methodName.name);
+      _serializeTypeArguments(invocation.typeArguments);
       operations.add(UnlinkedConstOperation.invokeMethod);
     }
   }
 
   void _serializePostfixExpression(PostfixExpression expr) {
     TokenType operator = expr.operator.type;
     Expression operand = expr.operand;
     if (operator == TokenType.PLUS_PLUS) {
       _serializePrefixPostfixIncDec(
           operand, UnlinkedExprAssignOperator.postfixIncrement);
@@ skipping 68 matching lines @@
           strings.add(element.value);
         } else {
           _serialize((element as InterpolationExpression).expression);
         }
       }
       operations.add(UnlinkedConstOperation.concatenate);
       ints.add(interpolation.elements.length);
     }
   }
 
-  /**
-   * Return `true` if the given [expr] is a sequence of identifiers.
-   */
-  bool _isIdentifierSequence(Expression expr) {
-    while (expr != null) {
-      if (expr is SimpleIdentifier) {
-        AstNode parent = expr.parent;
-        if (parent is MethodInvocation && parent.methodName == expr) {
-          if (parent.isCascaded) {
-            return false;
-          }
-          return parent.target == null || _isIdentifierSequence(parent.target);
-        }
-        if (isParameterName(expr.name)) {
-          return false;
-        }
-        return true;
-      } else if (expr is PrefixedIdentifier) {
-        expr = (expr as PrefixedIdentifier).prefix;
-      } else if (expr is PropertyAccess) {
-        expr = (expr as PropertyAccess).target;
-      } else {
-        return false;
+  void _serializeTypeArguments(TypeArgumentList typeArguments) {
+    if (typeArguments == null) {
+      ints.add(0);
+    } else {
+      ints.add(typeArguments.arguments.length);
+      for (TypeName typeName in typeArguments.arguments) {
+        references.add(serializeTypeName(typeName));
       }
     }
-    return false;
   }
 }