Clear up confusion between type arguments and type parameters in summary tests

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/generated/engine.dart';
@@ skipping 309 matching lines @@
   void checkInferredTypeSlot(
       int slotId, String absoluteUri, String relativeUri, String expectedName,
       {bool allowTypeParameters: false,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     if (strongMode) {
       checkLinkedTypeSlot(slotId, absoluteUri, relativeUri, expectedName,
-          allowTypeParameters: allowTypeParameters,
+          allowTypeArguments: allowTypeParameters,
           expectedKind: expectedKind,
           expectedTargetUnit: expectedTargetUnit,
           linkedSourceUnit: linkedSourceUnit,
           unlinkedSourceUnit: unlinkedSourceUnit,
           numTypeParameters: numTypeParameters);
     } else {
       // A slot id should have been assigned but it should not be associated
       // with any type.
       expect(slotId, isNot(0));
       expect(getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
@@ skipping 15 matching lines @@
     for (LinkedDependency dep in linked.dependencies) {
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type declared
    * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeParameters] is true, allow the type
-   * reference to supply type parameters.  [expectedKind] is the kind of object
+   * [expectedName].  If [allowTypeArguments] is true, allow the 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.
    */
   void checkLinkedTypeRef(EntityRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
-      {bool allowTypeParameters: false,
+      {bool allowTypeArguments: false,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     linkedSourceUnit ??= definingUnit;
     expect(typeRef, isNotNull,
         reason: 'No entry in linkedSourceUnit.types matching slotId');
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
-    if (!allowTypeParameters) {
+    if (!allowTypeArguments) {
       expect(typeRef.typeArguments, isEmpty);
     }
     checkReferenceIndex(index, absoluteUri, relativeUri, expectedName,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [slotId] represents a reference to a type declared
    * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeParameters] is true, allow the type
-   * reference to supply type parameters.  [expectedKind] is the kind of object
+   * [expectedName].  If [allowTypeArguments] is true, allow the 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.
    */
   void checkLinkedTypeSlot(
       int slotId, String absoluteUri, String relativeUri, String expectedName,
-      {bool allowTypeParameters: false,
+      {bool allowTypeArguments: false,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     // Slot ids should be nonzero, since zero means "no associated slot".
     expect(slotId, isNot(0));
     if (skipFullyLinkedData) {
       return;
     }
     linkedSourceUnit ??= definingUnit;
     checkLinkedTypeRef(
         getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
         absoluteUri,
         relativeUri,
         expectedName,
-        allowTypeParameters: allowTypeParameters,
+        allowTypeArguments: allowTypeArguments,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type parameter
    * having the given [deBruijnIndex].
@@ skipping 4249 matching lines @@
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C<T> extends D<int, T> { var v; }'
         ' abstract class D<U, V> { Map<V, U> get v; }',
         className: 'C');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that v has inferred type Map<T, int>.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        allowTypeArguments: true, numTypeParameters: 2);
     checkParamTypeRef(type.typeArguments[0], 1);
     checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C<T, U> extends D<U, int> { void f(int x, g) {} }'
@@ skipping 1300 matching lines @@
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
   }
 
   test_variable_propagated_type_omit_dynamic() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('final v = <int, dynamic>{};');
     EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
+        allowTypeArguments: true, numTypeParameters: 2);
     expect(type.typeArguments, hasLength(1));
     checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_variable_propagatedTypeSlot_const() {
     // Const variables are propagable so they have a nonzero
     // propagatedTypeSlot.
     UnlinkedVariable variable = serializeVariableText('const v = 0;');
     expect(variable.propagatedTypeSlot, isNot(0));
   }
@@ skipping 91 matching lines @@
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.inLibraryDefiningUnit: false,
       this.absoluteUri,
       this.relativeUri,
       this.numTypeParameters: 0});
 }