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

pkg/analyzer/test/src/summary/summary_common.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.
 
 library analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 1772 matching lines @@
         operators: [
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.pushLocalFunctionReference,
           UnlinkedConstOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
-          2
+          2,
+          0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_constExpr_functionExpression_asArgument_multiple() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
@@ skipping 10 matching lines @@
           UnlinkedConstOperation.pushLocalFunctionReference,
           UnlinkedConstOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           1,
           0,
-          3
+          3,
+          0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_constExpr_functionExpression_inConstructorInitializers() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
@@ skipping 480 matching lines @@
   test_constExpr_invokeMethodRef_identical() {
     UnlinkedVariable variable =
         serializeVariableText('const v = identical(42, null);');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushNull,
       UnlinkedConstOperation.invokeMethodRef
     ], ints: [
       42,
       0,
-      2
+      2,
+      0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, 'dart:core', 'dart:core', 'identical',
             expectedKind: ReferenceKind.topLevelFunction);
       }
     ]);
   }
 
   test_constExpr_length_classConstField() {
     UnlinkedVariable variable = serializeVariableText('''
@@ skipping 4538 matching lines @@
           // a
           UnlinkedConstOperation.cascadeSectionEnd,
           //   ..m(6)
           UnlinkedConstOperation.cascadeSectionBegin,
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.invokeMethod,
           // a
           UnlinkedConstOperation.cascadeSectionEnd,
         ],
         ints: [
-          5, 0, 1, // m(5)
-          0, 0, // abs()
-          6, 0, 1, // m(5)
+          5, 0, 1, 0, // m(5)
+          0, 0, 0, // abs()
+          6, 0, 1, 0, // m(5)
         ],
         strings: [
           'm',
           'abs',
           'm',
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor),
         ]);
@@ skipping 73 matching lines @@
         operators: [
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.pushLocalFunctionReference,
           UnlinkedConstOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
-          2
+          2,
+          0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_asArgument_multiple() {
     if (skipNonConstInitializers) {
       return;
@@ skipping 10 matching lines @@
           UnlinkedConstOperation.pushLocalFunctionReference,
           UnlinkedConstOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           1,
           0,
-          3
+          3,
+          0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
@@ skipping 89 matching lines @@
         operators: [
           UnlinkedConstOperation.pushParameter,
           UnlinkedConstOperation.invokeMethod
         ],
         strings: [
           'x',
           'f'
         ],
         ints: [
           0,
+          0,
           0
         ]);
   }
 
   test_expr_inClosure_refersToParam_methodCall_prefixed() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var v = (x) => x.y.f();');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedConstOperation.pushParameter,
           UnlinkedConstOperation.extractProperty,
           UnlinkedConstOperation.invokeMethod
         ],
         strings: [
           'x',
           'y',
           'f'
         ],
         ints: [
           0,
+          0,
           0
         ]);
   }
 
   test_expr_inClosure_refersToParam_outOfScope() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var x; var v = (b) => (b ? (x) => x : x);');
@@ skipping 117 matching lines @@
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.invokeMethod,
         ],
         ints: [
           0,
           0,
           1,
           2,
           3,
           2,
-          1
+          1,
+          0
         ],
         strings: [
           'b',
           'c',
           'm'
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
+  test_expr_invokeMethod_withTypeParameters() {
+    if (skipNonConstInitializers) {
+      return;
+    }
+    UnlinkedVariable variable = serializeVariableText('''
+class C {
+  f<T, U>() => null;
+}
+final v = new C().f<int, String>();
+''');
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedConstOperation.invokeMethod
+        ],
+        ints: [
+          0,
+          0,
+          0,
+          0,
+          2
+        ],
+        strings: [
+          'f'
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'C'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String')
+        ]);
+  }
+
   test_expr_invokeMethodRef_instance() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   B b;
 }
 class B {
   C c;
 }
 class C {
   int m(int a, int b) => a + b;
 }
 A a = new A();
 final v = a.b.c.m(10, 20);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.invokeMethodRef,
         ],
         ints: [
           10,
           20,
           0,
-          2
+          2,
+          0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'm',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
                     new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
@@ skipping 16 matching lines @@
 import 'a.dart' as p;
 final v = p.C.m();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedConstOperation.invokeMethodRef,
         ],
         ints: [
           0,
+          0,
           0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'm',
                   expectedKind: ReferenceKind.method,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                         absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                     new _PrefixExpectation(ReferenceKind.prefix, 'p')
@@ skipping 11 matching lines @@
 final v = f(u);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedConstOperation.pushReference,
           UnlinkedConstOperation.invokeMethodRef
         ],
         ints: [
           0,
-          1
+          1,
+          0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'u',
               expectedKind: ReferenceKind.topLevelPropertyAccessor),
           (EntityRef r) => checkTypeRef(r, null, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
+  test_expr_invokeMethodRef_withTypeParameters() {
+    if (skipNonConstInitializers) {
+      return;
+    }
+    UnlinkedVariable variable = serializeVariableText('''
+f<T, U>() => null;
+final v = f<int, String>();
+''');
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          0,
+          0,
+          2
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+              expectedKind: ReferenceKind.topLevelFunction,
+              numTypeParameters: 2),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String')
+        ]);
+  }
+
   test_expr_throwException() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = throw 1 + 2;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
@@ skipping 106 matching lines @@
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedConstOperation.pushInt,
           UnlinkedConstOperation.invokeMethodRef,
           UnlinkedConstOperation.add,
         ],
         ints: [
           1,
           0,
+          0,
           0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'm',
                   expectedKind: ReferenceKind.method,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
                   ])
         ]);
@@ skipping 2917 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }