Encode number of type parameters in prelinked summary.

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 286 matching lines @@
    * 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
    * object referenced.  [prelinkedSourceUnit] 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.
+   * assumed to be the defining compilation unit.  [numTypeParameters] is the
+   * number of type parameters of the thing being referred to.
    */
   void checkTypeRef(UnlinkedTypeRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
       PrelinkedReferenceKind expectedKind: PrelinkedReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       PrelinkedUnit prelinkedSourceUnit,
-      UnlinkedUnit unlinkedSourceUnit}) {
+      UnlinkedUnit unlinkedSourceUnit,
+      int numTypeParameters: 0}) {
     prelinkedSourceUnit ??= definingUnit;
     unlinkedSourceUnit ??= unlinkedUnits[0];
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     UnlinkedReference reference = unlinkedSourceUnit.references[index];
     PrelinkedReference referenceResolution =
         prelinkedSourceUnit.references[index];
     if (index == 0) {
       // Index 0 is reserved for "dynamic".
@@ skipping 15 matching lines @@
     }
     if (checkAstDerivedData) {
       if (expectedPrefix == null) {
         expect(reference.prefixReference, 0);
       } else {
         checkPrefix(reference.prefixReference, expectedPrefix);
       }
     }
     expect(referenceResolution.kind, expectedKind);
     expect(referenceResolution.unit, expectedTargetUnit);
+    expect(referenceResolution.numTypeParameters, numTypeParameters);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
   void checkUnresolvedTypeRef(
       UnlinkedTypeRef typeRef, String expectedPrefix, String expectedName) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
@@ skipping 478 matching lines @@
   test_class_non_alias_flag() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isMixinApplication, false);
   }
 
   test_class_private() {
     serializeClassText('class _C {}', '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
+  test_class_reference_generic() {

[Brian Wilkerson, 2016/01/04 23:20:46]

Does this, or should this, also apply to generic methods?

[Paul Berry, 2016/01/04 23:34:04]

Not at the moment, because all this CL deals with is the number of type
parameters in the thing being referred *to*.  Right now the only things that can
be referred to by summaries are types.  Once we include information about
constants in summaries, that will change, because summaries will also be able to
refer to top level and static methods, which could be generic.

+    UnlinkedTypeRef typeRef =
+        serializeTypeText('C', otherDeclarations: 'class C<D, E> {}');
+    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
+  }
+
+  test_class_reference_generic_imported() {
+    addNamedSource('/lib.dart', 'class C<D, E> {}');
+    UnlinkedTypeRef typeRef =
+        serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
+    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
+        numTypeParameters: 2);
+  }
+
   test_class_superclass() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_superclass_explicit() {
     UnlinkedClass cls = serializeClassText('class C extends D {} class D {}');
     expect(cls.supertype, isNotNull);
     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);
+        allowTypeParameters: true, numTypeParameters: 1);
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
     UnlinkedTypeRef 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 213 matching lines @@
   test_constructor_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     checkTypeRef(executable.returnType, null, null, 'C');
   }
 
   test_constructor_return_type_parameterized() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C<T, U> { C(); }').executables);
     checkTypeRef(executable.returnType, null, null, 'C',
-        allowTypeParameters: true);
+        allowTypeParameters: true, numTypeParameters: 2);
     expect(executable.returnType.typeArguments, hasLength(2));
     {
       UnlinkedTypeRef typeRef = executable.returnType.typeArguments[0];
       checkParamTypeRef(typeRef, 2);
     }
     {
       UnlinkedTypeRef typeRef = executable.returnType.typeArguments[1];
       checkParamTypeRef(typeRef, 1);
     }
   }
@@ skipping 757 matching lines @@
     serializeLibraryText('import "dart:async" as a; a.Future v;');
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'v');
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'v=');
   }
 
   test_import_prefix_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async" as a; a.Future v;');
     checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a');
+        expectedPrefix: 'a', numTypeParameters: 1);
   }
 
   test_import_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async"; Future v;');
-    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future');
+    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
+        numTypeParameters: 1);
   }
 
   test_import_reference_merged_no_prefix() {
     serializeLibraryText('''
 import "dart:async" show Future;
 import "dart:async" show Stream;
 
 Future f;
 Stream s;
 ''');
-    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future');
-    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream');
+    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
+        numTypeParameters: 1);
+    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
+        numTypeParameters: 1);
   }
 
   test_import_reference_merged_prefixed() {
     serializeLibraryText('''
 import "dart:async" as a show Future;
 import "dart:async" as a show Stream;
 
 a.Future f;
 a.Stream s;
 ''');
     checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a');
+        expectedPrefix: 'a', numTypeParameters: 1);
     checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
-        expectedPrefix: 'a');
+        expectedPrefix: 'a', numTypeParameters: 1);
   }
 
   test_import_show_order() {
     String libraryText =
         'import "dart:async" show Future, Stream; Future x; Stream y;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].imports[0].combinators[0].shows, hasLength(2));
@@ skipping 42 matching lines @@
     addNamedSource('/a.dart', 'part of foo; class C {}');
     serializeLibraryText('library foo; part "a.dart";');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
     expect(unlinkedUnits[1].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[1].publicNamespace.names[0].name, 'C');
   }
 
   test_type_arguments_explicit() {
     UnlinkedTypeRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true);
+        allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
     UnlinkedTypeRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true);
+        allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_typedef() {
     UnlinkedTypeRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
-        expectedKind: PrelinkedReferenceKind.typedef);
+        expectedKind: PrelinkedReferenceKind.typedef,
+        numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_typedef() {
     UnlinkedTypeRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
-        expectedKind: PrelinkedReferenceKind.typedef);
+        expectedKind: PrelinkedReferenceKind.typedef,
+        numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
     UnlinkedTypeRef typeRef = serializeTypeText('List');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true);
+        allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_implicit_typedef() {
     UnlinkedTypeRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
-        expectedKind: PrelinkedReferenceKind.typedef);
+        expectedKind: PrelinkedReferenceKind.typedef,
+        numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_order() {
     UnlinkedTypeRef typeRef = serializeTypeText('Map<int, Object>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true);
+        allowTypeParameters: true, numTypeParameters: 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_reference_from_part() {
@@ skipping 153 matching lines @@
     expect(type.parameters, hasLength(2));
     expect(type.parameters[0].name, 'x');
     expect(type.parameters[1].name, 'y');
   }
 
   test_typedef_private() {
     serializeTypedefText('typedef _F();', '_F');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
+  test_typedef_reference_generic() {
+    UnlinkedTypeRef typeRef =
+        serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
+    checkTypeRef(typeRef, null, null, 'F',
+        numTypeParameters: 2, expectedKind: PrelinkedReferenceKind.typedef);
+  }
+
+  test_typedef_reference_generic_imported() {
+    addNamedSource('/lib.dart', 'typedef void F<A, B>();');
+    UnlinkedTypeRef typeRef =
+        serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
+    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
+        numTypeParameters: 2, expectedKind: PrelinkedReferenceKind.typedef);
+  }
+
   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);
   }
 
@@ skipping 100 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);
   }
 }