Add a count of type parameters to UnlinkedPublicName.

pkg/analyzer/test/src/summary/summary_test.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_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 703 matching lines @@
   }
 
   test_class_alias_concrete() {
     UnlinkedClass cls =
         serializeClassText('class C = _D with _E; class _D {} class _E {}');
     expect(cls.isAbstract, false);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_class_alias_flag() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     expect(cls.isMixinApplication, true);
   }
 
+  test_class_alias_generic() {
+    serializeClassText('class C<A, B> = _D with _E; class _D {} class _E {}');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 2);
+  }
+
   test_class_alias_mixin_order() {
     UnlinkedClass cls = serializeClassText('''
 class C = D with E, F;
 class D {}
 class E {}
 class F {}
 ''');
     expect(cls.mixins, hasLength(2));
     checkTypeRef(cls.mixins[0], null, null, 'E');
     checkTypeRef(cls.mixins[1], null, null, 'F');
@@ skipping 38 matching lines @@
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_concrete() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isAbstract, false);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_class_interface() {
     UnlinkedClass cls = serializeClassText('''
 class C implements D {}
 class D {}
 ''');
     expect(cls.interfaces, hasLength(1));
     checkTypeRef(cls.interfaces[0], null, null, 'D');
   }
@@ skipping 112 matching lines @@
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
     UnlinkedTypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_class_type_param_no_bound() {
     UnlinkedClass cls = serializeClassText('class C<T> {}');
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNull);
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_constructor() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
   }
 
@@ skipping 309 matching lines @@
 
   test_enum() {
     UnlinkedEnum e = serializeEnumText('enum E { v1 }');
     expect(e.name, 'E');
     expect(e.values, hasLength(1));
     expect(e.values[0].name, 'v1');
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_enum_order() {
     UnlinkedEnum e = serializeEnumText('enum E { v1, v2 }');
     expect(e.values, hasLength(2));
     expect(e.values[0].name, 'v1');
     expect(e.values[1].name, 'v2');
   }
 
   test_enum_private() {
@@ skipping 16 matching lines @@
   test_executable_function() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
     expect(executable.isExternal, isFalse);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_external() {
@@ skipping 406 matching lines @@
   test_executable_type_param_f_bound_self_ref_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<U>>() {}');
     UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_executable_type_param_in_parameter_function() {
     UnlinkedExecutable ex = serializeExecutableText('void f<T>(T t) {}');
     checkParamTypeRef(ex.parameters[0].type, 1);
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_executable_type_param_in_parameter_method() {
     UnlinkedExecutable ex = serializeMethodText('void f<T>(T t) {}');
     checkParamTypeRef(ex.parameters[0].type, 1);
   }
 
   test_executable_type_param_in_return_type_function() {
     UnlinkedExecutable ex = serializeExecutableText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
@@ skipping 494 matching lines @@
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.name, 'F');
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.typedef);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'F');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_typedef_param_none() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.parameters, isEmpty);
   }
 
   test_typedef_param_order() {
     UnlinkedTypedef type = serializeTypedefText('typedef F(x, y);');
     expect(type.parameters, hasLength(2));
@@ skipping 22 matching lines @@
   }
 
   test_typedef_return_type_explicit() {
     UnlinkedTypedef type = serializeTypedefText('typedef int F();');
     checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
   }
 
   test_typedef_type_param_in_parameter() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T>(T t);');
     checkParamTypeRef(type.parameters[0].type, 1);
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_typedef_type_param_in_return_type() {
     UnlinkedTypedef type = serializeTypedefText('typedef T F<T>();');
     checkParamTypeRef(type.returnType, 1);
   }
 
   test_typedef_type_param_none() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.typeParameters, isEmpty);
   }
 
   test_typedef_type_param_order() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T, U>();');
     expect(type.typeParameters, hasLength(2));
     expect(type.typeParameters[0].name, 'T');
     expect(type.typeParameters[1].name, 'U');
   }
 
   test_variable() {
     serializeVariableText('int i;', variableName: 'i');
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
+    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
     expect(unlinkedUnits[0].publicNamespace.names[1].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
+    expect(unlinkedUnits[0].publicNamespace.names[1].numTypeParameters, 0);
   }
 
   test_variable_const() {
     UnlinkedVariable variable =
         serializeVariableText('const int i = 0;', variableName: 'i');
     expect(variable.isConst, isTrue);
   }
 
   test_variable_explicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('dynamic v;');
@@ skipping 62 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }