Rename TypeRef to EntityRef.

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 92 matching lines @@
       new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
   Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
   parser.parseGenericMethods = true;
   CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
   UnlinkedPublicNamespace namespace = new UnlinkedPublicNamespace.fromBuffer(
       public_namespace.computePublicNamespace(unit).toBuffer());
   return namespace;
 }
 
 /**
- * Type of a function that validates an [TypeRef].
+ * Type of a function that validates an [EntityRef].
  */
-typedef void _TypeRefValidator(TypeRef unlinkedTypeRef);
+typedef void _TypeRefValidator(EntityRef unlinkedTypeRef);

[scheglov, 2016/01/21 22:40:42]

Rename the type and parameter?

[Paul Berry, 2016/01/21 22:53:48]

Done.

 
 /**
  * Base class containing most summary tests.  This allows summary tests to be
  * re-used to exercise all the different ways in which summaries can be
  * generated (e.g. direct from the AST, from the element model, from a
  * "relinking" process, etc.)
  */
 abstract class SummaryTest {
   /**
    * A test will set this to `true` if it contains `import`, `export`, or
@@ skipping 102 matching lines @@
     String expectedCommentText =
         text.substring(commentStart, commentEnd).replaceAll('\r\n', '\n');
     expect(documentationComment.text, expectedCommentText);
     expect(documentationComment.offset, commentStart);
     expect(documentationComment.length, commentEnd - commentStart);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
-  void checkDynamicTypeRef(TypeRef typeRef) {
+  void checkDynamicTypeRef(EntityRef typeRef) {
     checkTypeRef(typeRef, null, null, null);
   }
 
   /**
    * Verify that the given [exportName] represents a reference to an entity
    * declared in a file reachable via [absoluteUri] and [relativeUri], having
    * name [expectedName].  [expectedKind] is the kind of object referenced.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [exportName] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.
@@ skipping 67 matching lines @@
    * [expectedName].  If [allowTypeParameters] is true, allow the type
    * reference to supply type parameters.  [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(TypeRef typeRef, String absoluteUri,
+  void checkLinkedTypeRef(EntityRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
       {bool allowTypeParameters: 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');
@@ skipping 51 matching lines @@
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type parameter
    * having the given [deBruijnIndex].
    */
-  void checkParamTypeRef(TypeRef typeRef, int deBruijnIndex) {
-    expect(typeRef, new isInstanceOf<TypeRef>());
+  void checkParamTypeRef(EntityRef typeRef, int deBruijnIndex) {
+    expect(typeRef, new isInstanceOf<EntityRef>());
     expect(typeRef.reference, 0);
     expect(typeRef.typeArguments, isEmpty);
     expect(typeRef.paramReference, deBruijnIndex);
   }
 
   /**
    * Verify that [prefixReference] is a valid reference to a prefix having the
    * given [name].
    */
   void checkPrefix(int prefixReference, String name) {
@@ skipping 12 matching lines @@
    * reached via the given prefix.  If [allowTypeParameters] is true, allow the
    * type reference to supply type parameters.  [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 checkTypeRef(TypeRef typeRef, String absoluteUri, String relativeUri,
+  void checkTypeRef(EntityRef typeRef, String absoluteUri, String relativeUri,
       String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     linkedSourceUnit ??= definingUnit;
-    expect(typeRef, new isInstanceOf<TypeRef>());
+    expect(typeRef, new isInstanceOf<EntityRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     if (!allowTypeParameters) {
       expect(typeRef.typeArguments, isEmpty);
     }
     UnlinkedReference reference = checkTypeRefCommonElements(
         index,
         absoluteUri,
         relativeUri,
         expectedName,
@@ skipping 77 matching lines @@
     expect(referenceResolution.unit, expectedTargetUnit);
     expect(referenceResolution.numTypeParameters, numTypeParameters);
     return reference;
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
   void checkUnresolvedTypeRef(
-      TypeRef typeRef, String expectedPrefix, String expectedName,
+      EntityRef typeRef, String expectedPrefix, String expectedName,
       {LinkedUnit linkedSourceUnit, UnlinkedUnit unlinkedSourceUnit}) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
     checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
         expectedPrefix: expectedPrefix,
         expectedKind: ReferenceKind.unresolved,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit);
   }
 
@@ skipping 123 matching lines @@
     }
     if (result == null && failIfAbsent) {
       fail('Variable $variableName not found in serialized output');
     }
     return result;
   }
 
   /**
    * Find the entry in [linkedSourceUnit.types] matching [slotId].
    */
-  TypeRef getTypeRefForSlot(int slotId, {LinkedUnit linkedSourceUnit}) {
+  EntityRef getTypeRefForSlot(int slotId, {LinkedUnit linkedSourceUnit}) {
     linkedSourceUnit ??= definingUnit;
-    for (TypeRef typeRef in linkedSourceUnit.types) {
+    for (EntityRef typeRef in linkedSourceUnit.types) {
       if (typeRef.slot == slotId) {
         return typeRef;
       }
     }
     return null;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the class
    * with the given [className].
@@ skipping 46 matching lines @@
    * with the given [typedefName].
    */
   UnlinkedTypedef serializeTypedefText(String text,
       [String typedefName = 'F']) {
     serializeLibraryText(text);
     return findTypedef(typedefName, failIfAbsent: true);
   }
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
-   * return a summary of the corresponding [TypeRef].  If the type
+   * return a summary of the corresponding [EntityRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
-  TypeRef serializeTypeText(String text,
+  EntityRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
             allowErrors: allowErrors)
         .type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
@@ skipping 203 matching lines @@
     expect(cls.executables, isEmpty);
   }
 
   test_class_alias_private() {
     serializeClassText('class _C = _D with _E; class _D {} class _E {}',
         className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_alias_reference_generic() {
-    TypeRef typeRef = serializeTypeText('C',
+    EntityRef typeRef = serializeTypeText('C',
         otherDeclarations: 'class C<D, E> = F with G; class F {} class G {}');
     checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
   }
 
   test_class_alias_reference_generic_imported() {
     addNamedSource(
         '/lib.dart', 'class C<D, E> = F with G; class F {} class G {}');
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
         numTypeParameters: 2);
   }
 
   test_class_alias_supertype() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
@@ skipping 115 matching lines @@
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isMixinApplication, false);
   }
 
   test_class_private() {
     serializeClassText('class _C {}', className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_reference_generic() {
-    TypeRef typeRef =
+    EntityRef 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> {}');
-    TypeRef typeRef =
+    EntityRef 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, numTypeParameters: 1);
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
-    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
+    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>> {}');
-    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
+    EntityRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_class_type_param_no_bound() {
     String text = 'class C<T> {}';
     UnlinkedClass cls = serializeClassText(text);
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].nameOffset, text.indexOf('T'));
     expect(cls.typeParameters[0].bound, isNull);
@@ skipping 263 matching lines @@
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
+      (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported() {
     if (checkAstDerivedData) {
       // TODO(scheglov) at the moment we cannot link class member references
       return;
     }
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
           expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'p')
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C(a, b, c, d, {e, f, g});
 }
 const v = const C(11, 22, 3.3, '444', e: 55, g: '777', f: 66);
@@ skipping 21 matching lines @@
     ], doubles: [
       3.3
     ], strings: [
       '444',
       '777',
       'e',
       'g',
       'f',
       ''
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
+      (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_length() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "abc".length;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.length
     ], strings: [
       'abc'
     ]);
   }
 
   test_constExpr_makeList_typed() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <int>[11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.makeList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeList_untyped() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const [11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.makeList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, '',
+      (EntityRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeMap_typed() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum),
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeMap_untyped() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, '',
+      (EntityRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum),
-      (TypeRef r) => checkTypeRef(r, null, null, '',
+      (EntityRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeSymbol() {
     UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeSymbol
     ], strings: [
@@ skipping 126 matching lines @@
   }
 
   test_constExpr_pushReference_class() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
+      (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_class_field() {
     // TODO(scheglov) Not sure for to represent a field reference
     // using TypeRef.
 //    UnlinkedVariable variable = serializeVariableText('''
 //class C {
 //  static const int F = 1;
 //}
 //const v = C.F;
 //''');
 //    _assertUnlinkedConst(variable.constExpr, operators: [
 //      UnlinkedConstOperation.pushReference
 //    ], references: [
 //      (TypeRef r) => checkTypeRef(r, null, null, 'F',
 //          expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'C')
 //    ]);
   }
 
   test_constExpr_pushReference_enum() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
+      (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported_withPrefix() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (TypeRef r) {
+      (EntityRef r) {
         return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
             expectedKind: ReferenceKind.topLevelPropertyAccessor,
             expectedPrefix: 'p');
       }
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_local() {
     // TODO(scheglov) use `a + b`
     UnlinkedVariable variable = serializeVariableText('''
 const int a = 1;
 const v = a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'a',
+      (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushString_adjacent() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "aaa" "b" "ccc";');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushString], strings: ['aaabccc']);
   }
@@ skipping 902 matching lines @@
 
   test_executable_static() {
     UnlinkedExecutable executable =
         serializeClassText('class C { static f() {} }').executables[0];
     expect(executable.isStatic, isTrue);
   }
 
   test_executable_type_param_f_bound_function() {
     UnlinkedExecutable ex =
         serializeExecutableText('void f<T, U extends List<T>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    EntityRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_executable_type_param_f_bound_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<T>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    EntityRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_executable_type_param_f_bound_self_ref_function() {
     UnlinkedExecutable ex =
         serializeExecutableText('void f<T, U extends List<U>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    EntityRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_executable_type_param_f_bound_self_ref_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<U>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    EntityRef 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() {
@@ skipping 277 matching lines @@
       return;
     }
     serializeLibraryText('final x = 0; String y;');
     checkLinkedTypeSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot,
         'dart:core', 'dart:core', 'int');
     checkTypeRef(
         unlinkedUnits[0].variables[1].type, 'dart:core', 'dart:core', 'String');
     // Even though the definition of y follows the definition of x, the linked
     // type reference for x should use a higher numbered reference than the
     // unlinked type reference for y.
-    TypeRef propagatedType =
+    EntityRef propagatedType =
         getTypeRefForSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot);
     expect(unlinkedUnits[0].variables[1].type.reference,
         lessThan(propagatedType.reference));
   }
 
   test_function_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
@@ skipping 460 matching lines @@
   test_slot_reuse() {
     // Different compilation units have independent notions of slot id, so slot
     // ids should be reused.
     addNamedSource('/a.dart', 'part of foo; final v = 0;');
     serializeLibraryText('library foo; part "a.dart"; final w = 0;');
     expect(unlinkedUnits[0].variables[0].propagatedTypeSlot, 1);
     expect(unlinkedUnits[1].variables[0].propagatedTypeSlot, 1);
   }
 
   test_type_arguments_explicit() {
-    TypeRef typeRef = serializeTypeText('List<int>');
+    EntityRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
-    TypeRef typeRef = serializeTypeText('List<dynamic>');
+    EntityRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
-    TypeRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
+    EntityRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     // Trailing type arguments of type `dynamic` are omitted.
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_int() {
-    TypeRef typeRef = serializeTypeText('Map<dynamic, int>');
+    EntityRef typeRef = serializeTypeText('Map<dynamic, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 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() {
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_String_dynamic() {
-    TypeRef typeRef = serializeTypeText('Map<String, dynamic>');
+    EntityRef typeRef = serializeTypeText('Map<String, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     // 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() {
-    TypeRef typeRef = serializeTypeText('Map<String, int>');
+    EntityRef typeRef = serializeTypeText('Map<String, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 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() {
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
-    TypeRef typeRef = serializeTypeText('List');
+    EntityRef typeRef = serializeTypeText('List');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_implicit_typedef() {
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_order() {
-    TypeRef typeRef = serializeTypeText('Map<int, Object>');
+    EntityRef typeRef = serializeTypeText('Map<int, Object>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         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'));
   }
@@ skipping 90 matching lines @@
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
         absUri('/a.dart'), 'a.dart', 'C',
         expectedPrefix: 'a',
         linkedSourceUnit: linked.units[1],
         unlinkedSourceUnit: unlinkedUnits[1]);
   }
 
   test_type_reference_to_class_argument() {
     UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
     {
-      TypeRef typeRef =
+      EntityRef typeRef =
           findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
     {
-      TypeRef typeRef =
+      EntityRef typeRef =
           findVariable('u', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 1);
     }
   }
 
   test_type_reference_to_import_of_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b; class C {}');
     checkTypeRef(serializeTypeText('C', otherDeclarations: 'import "a.dart";'),
         absUri('/b.dart'), 'b.dart', 'C');
@@ skipping 66 matching lines @@
   }
 
   test_type_reference_to_nonexistent_file_via_prefix() {
     if (!checkAstDerivedData) {
       // TODO(paulberry): this test currently fails because there is not enough
       // information in the element model to figure out that the unresolved
       // reference `p.C` uses the prefix `p`.
       return;
     }
     allowMissingFiles = true;
-    TypeRef typeRef = serializeTypeText('p.C',
+    EntityRef typeRef = serializeTypeText('p.C',
         otherDeclarations: 'import "foo.dart" as p;', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, 'p', 'C');
   }
 
   test_type_reference_to_part() {
     addNamedSource('/a.dart', 'part of foo; class C { C(); }');
     serializeLibraryText('library foo; part "a.dart"; C c;');
     checkTypeRef(unlinkedUnits[0].variables.single.type, null, null, 'C',
         expectedKind: ReferenceKind.classOrEnum, expectedTargetUnit: 1);
   }
@@ skipping 32 matching lines @@
   test_type_reference_to_typedef() {
     checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
         null, null, 'F',
         expectedKind: ReferenceKind.typedef);
   }
 
   test_type_unit_counts_unreferenced_units() {
     addNamedSource('/a.dart', 'library a; part "b.dart"; part "c.dart";');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a; class C {}');
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "a.dart";');
     // The referenced unit should be 2, since unit 0 is a.dart and unit 1 is
     // b.dart.  a.dart and b.dart are counted even though nothing is imported
     // from them.
     checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
         expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
-    TypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
+    EntityRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 typedef F();''';
@@ skipping 25 matching lines @@
     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() {
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
     checkTypeRef(typeRef, null, null, 'F',
         numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
   }
 
   test_typedef_reference_generic_imported() {
     addNamedSource('/lib.dart', 'typedef void F<A, B>();');
-    TypeRef typeRef =
+    EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
         numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
   }
 
   test_typedef_return_type_explicit() {
     UnlinkedTypedef type = serializeTypedefText('typedef int F();');
     checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 139 matching lines @@
 
   test_variable_propagated_type_new_reference() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('final v = 0;');
     // Since the propagated type of `v` is `int`, and there are no references
     // to `int` elsewhere in the source file, a new linked reference should
     // have been created for it, with no associated unlinked reference.
     expect(v.propagatedTypeSlot, isNot(0));
-    TypeRef type = getTypeRefForSlot(v.propagatedTypeSlot);
+    EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
     expect(type, isNotNull);
     expect(type.reference,
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
   }
 
   test_variable_propagated_type_omit_dynamic() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('final v = <int, dynamic>{};');
-    TypeRef type = getTypeRefForSlot(v.propagatedTypeSlot);
+    EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: 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;');
@@ skipping 37 matching lines @@
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
 }