Replace 'allowTypeParameters' with 'numTypeArguments'.

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 555 matching lines @@
     expect(referenceResolution.unit, expectedTargetUnit);
     expect(referenceResolution.numTypeParameters, numTypeParameters);
     expect(referenceResolution.localIndex, localIndex);
     return reference;
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type declared
    * in a file reachable via [absoluteUri] and [relativeUri], having name
    * [expectedName].  If [expectedPrefix] is supplied, verify that the type is
-   * reached via the given prefix.  If [allowTypeParameters] is true, allow the
-   * type reference to supply type parameters.  [expectedKind] is the kind of
+   * reached via the given prefix.  If [allowTypeArguments] is true, allow the

[Paul Berry, 2016/05/05 17:25:01]

This sentence isn't accurate--there's no "allowTypeArguments" parameter.

Maybe you mean something like "Verify that the number of type arguments is equal
to [numTypeArguments]."

+   * type reference to supply type arguments.  [expectedKind] is the kind of
    * object referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer
    * to the compilation unit within which the [typeRef] appears; if not
    * specified they are assumed to refer to the defining compilation unit.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [typeRef] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.  [numTypeParameters] is the
    * number of type parameters of the thing being referred to.
    *
    * TODO(scheglov) remove [checkAstDerivedDataOverride] once elements-based
    * serializer can record unresolved information.
    */
   void checkTypeRef(EntityRef typeRef, String absoluteUri, String relativeUri,
       String expectedName,
       {String expectedPrefix,
       List<_PrefixExpectation> prefixExpectations,
-      bool allowTypeParameters: false,
+      int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
       bool checkAstDerivedDataOverride: false,
       bool unresolvedHasName: false}) {
     linkedSourceUnit ??= definingUnit;
     expect(typeRef, new isInstanceOf<EntityRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
-    if (!allowTypeParameters) {
-      expect(typeRef.typeArguments, isEmpty);
-    }
+    expect(typeRef.typeArguments, hasLength(numTypeArguments));
     UnlinkedReference reference = checkReferenceIndex(
         index, absoluteUri, relativeUri, expectedName,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters,
         checkAstDerivedDataOverride: checkAstDerivedDataOverride,
         unresolvedHasName: unresolvedHasName);
     expect(reference, isNotNull,
@@ skipping 725 matching lines @@
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_type_param_bound() {
     UnlinkedClass cls = serializeClassText('class C<T extends List> {}');
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNotNull);
     checkTypeRef(cls.typeParameters[0].bound, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
+        numTypeParameters: 1);
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
     EntityRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_class_type_param_f_bound_self_ref() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
@@ skipping 394 matching lines @@
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   numTypeParameters: 2)
             ],
-            allowTypeParameters: true);
+            numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported() {
     addNamedSource(
         '/a.dart',
         '''
@@ skipping 13 matching lines @@
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   absoluteUri: absUri('/a.dart'),
                   relativeUri: 'a.dart',
                   numTypeParameters: 2)
             ],
-            allowTypeParameters: true);
+            numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
@@ skipping 14 matching lines @@
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   absoluteUri: absUri('/a.dart'),
                   relativeUri: 'a.dart',
                   numTypeParameters: 2),
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ],
-            allowTypeParameters: true);
+            numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C();
 }
 const v = const C<int, String>();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
-            allowTypeParameters: true);
+            numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
-            allowTypeParameters: true);
+            numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
-            allowTypeParameters: true,
+            numTypeArguments: 2,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ]);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_named() {
@@ skipping 1800 matching lines @@
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
               numTypeParameters: 2)
         ],
-        allowTypeParameters: true);
+        numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_named_imported() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
@@ skipping 42 matching lines @@
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
               numTypeParameters: 2,
               absoluteUri: absUri('/foo.dart'),
               relativeUri: 'foo.dart')
         ],
-        allowTypeParameters: true);
+        numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_named_prefixed() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
@@ skipping 44 matching lines @@
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
               numTypeParameters: 2,
               absoluteUri: absUri('/foo.dart'),
               relativeUri: 'foo.dart'),
           new _PrefixExpectation(ReferenceKind.prefix, 'foo')
         ],
-        allowTypeParameters: true);
+        numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed() {
     String text = '''
 class C {
   factory C() = D;
   C._();
 }
@@ skipping 18 matching lines @@
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(executable.redirectedConstructor, null, null, 'D',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_imported() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
@@ skipping 32 matching lines @@
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(
         executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_prefixed() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
@@ skipping 33 matching lines @@
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
     checkTypeRef(
         executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D',
-        allowTypeParameters: true, numTypeParameters: 2, expectedPrefix: 'foo');
+        numTypeParameters: 2, expectedPrefix: 'foo', numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_thisInvocation_named() {
     String text = '''
 class C {
   C() : this.named();
   C.named();
 }
@@ skipping 4806 matching lines @@
     expect(propagatedType.syntheticParams, hasLength(2));
     checkTypeRef(propagatedType.syntheticParams[0].type, 'dart:core',
         'dart:core', 'int');
     checkTypeRef(propagatedType.syntheticParams[1].type, 'dart:core',
         'dart:core', 'String');
   }
 
   test_type_arguments_explicit() {
     EntityRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
+        numTypeParameters: 1, numTypeArguments: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
     EntityRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
+        numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2);
     // Trailing type arguments of type `dynamic` are omitted.
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_int() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     // Leading type arguments of type `dynamic` are not omitted.
     expect(typeRef.typeArguments.length, 2);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
+        numTypeParameters: 1,
+        numTypeArguments: 0);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_String_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<String, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 1);
     // Trailing type arguments of type `dynamic` are omitted.
     expect(typeRef.typeArguments.length, 1);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
   }
 
   test_type_arguments_explicit_String_int() {
     EntityRef typeRef = serializeTypeText('Map<String, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     expect(typeRef.typeArguments.length, 2);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
+        numTypeParameters: 1,
+        numTypeArguments: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
     EntityRef typeRef = serializeTypeText('List');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
+        numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_implicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
+        numTypeParameters: 1,
+        numTypeArguments: 0);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_order() {
     EntityRef typeRef = serializeTypeText('Map<int, Object>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     expect(typeRef.typeArguments, hasLength(2));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
   test_type_param_codeRange() {
@@ skipping 811 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});
 }