Downplay the distinction between linked and prelinked summaries.

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 158 matching lines @@
       if (namespace == null) {
         namespace = uriToPublicNamespace[absoluteUri];
       }
       if (namespace == null && !allowMissingFiles) {
         fail('Prelinker unexpectedly requested namespace for "$relativeUri"'
             ' (resolves to "$absoluteUri").'
             '  Namespaces available: ${uriToPublicNamespace.keys}');
       }
       return namespace;
     }
-    prelinked = new PrelinkedLibrary.fromBuffer(
+    linked = new LinkedLibrary.fromBuffer(
         prelink(unlinkedUnits[0], getPart, getImport).toBuffer());
   }
 }
 
 /**
  * Override of [SummaryTest] which creates summaries from the element model.
  */
 @reflectiveTest
 class SummarizeElementsTest extends ResolverTestCase with SummaryTest {
   /**
@@ skipping 25 matching lines @@
    * Serialize the library containing the given class [element], then
    * deserialize it and return the summary of the class.
    */
   UnlinkedClass serializeClassElement(ClassElement element) {
     serializeLibraryElement(element.library);
     return findClass(element.name, failIfAbsent: true);
   }
 
   /**
    * Serialize the given [library] element, then deserialize it and store the
-   * resulting summary in [prelinked] and [unlinkedUnits].
+   * resulting summary in [linked] and [unlinkedUnits].
    */
   void serializeLibraryElement(LibraryElement library) {
     summarize_elements.LibrarySerializationResult serializedLib =
         summarize_elements.serializeLibrary(library, typeProvider);
     {
-      List<int> buffer = serializedLib.prelinked.toBuffer();
-      prelinked = new PrelinkedLibrary.fromBuffer(buffer);
+      List<int> buffer = serializedLib.linked.toBuffer();
+      linked = new LinkedLibrary.fromBuffer(buffer);
     }
     unlinkedUnits = serializedLib.unlinkedUnits.map((UnlinkedUnitBuilder b) {
       List<int> buffer = b.toBuffer();
       return new UnlinkedUnit.fromBuffer(buffer);
     }).toList();
     unitUris = serializedLib.unitUris;
   }
 
   @override
   void serializeLibraryText(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     _fileContents[source] = text;
     LibraryElement library = resolve2(source);
     if (!allowErrors) {
       assertNoErrors(source);
     }
     serializeLibraryElement(library);
-    expect(
-        unlinkedUnits[0].imports.length, prelinked.importDependencies.length);
-    expect(prelinked.units.length, unlinkedUnits.length);
-    for (int i = 0; i < prelinked.units.length; i++) {
+    expect(unlinkedUnits[0].imports.length, linked.importDependencies.length);
+    expect(linked.units.length, unlinkedUnits.length);
+    for (int i = 0; i < linked.units.length; i++) {
       expect(unlinkedUnits[i].references.length,
-          prelinked.units[i].references.length);
+          linked.units[i].references.length);
     }
     verifyPublicNamespace();
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableGenericMethods = true;
     resetWithOptions(options);
@@ skipping 30 matching lines @@
 }
 
 /**
  * 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 {
   /**
-   * Prelinked summary that results from serializing and then deserializing the
+   * Linked summary that results from serializing and then deserializing the
    * library under test.
    */
-  PrelinkedLibrary prelinked;
+  LinkedLibrary linked;
 
   /**
    * Unlinked compilation unit summaries that result from serializing and
    * deserializing the library under test.
    */
   List<UnlinkedUnit> unlinkedUnits;
 
   /**
    * A test will set this to `true` if it contains `import`, `export`, or
    * `part` declarations that deliberately refer to non-existent files.
    */
   bool allowMissingFiles = false;
 
   /**
    * `true` if the summary was created directly from the AST (and hence
    * contains information that is not obtainable from the element model alone).
    * TODO(paulberry): modify the element model so that it contains all the data
    * that summaries need, so that this flag is no longer needed.
    */
   bool get checkAstDerivedData;
 
   /**
-   * Get access to the prelinked defining compilation unit.
+   * Get access to the linked defining compilation unit.
    */
-  PrelinkedUnit get definingUnit => prelinked.units[0];
+  LinkedUnit get definingUnit => linked.units[0];
 
   /**
-   * `true` if the prelinked portion of the summary is expected to contain
+   * `true` if the linked portion of the summary is expected to contain
    * absolute URIs.  This happens because the element model doesn't (yet) store
    * enough information to recover relative URIs, TODO(paulberry): fix this.
    */
   bool get expectAbsoluteUrisInDependencies;
 
   /**
    * Convert [path] to a suitably formatted absolute path URI for the current
    * platform.
    */
   String absUri(String path) {
@@ skipping 11 matching lines @@
    * a file reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkDependency(int dependency, String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
       // TODO(paulberry): fix this.
       relativeUri = absoluteUri;
     }
     expect(dependency, new isInstanceOf<int>());
-    expect(prelinked.dependencies[dependency].uri, relativeUri);
+    expect(linked.dependencies[dependency].uri, relativeUri);
   }
 
   /**
    * Verify that the given [dependency] lists the given [absoluteUris] or
    * [relativeUris] as its parts.
    */
-  void checkDependencyParts(PrelinkedDependency dependency,
+  void checkDependencyParts(LinkedDependency dependency,
       List<String> absoluteUris, List<String> relativeUris) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
       // TODO(paulberry): fix this.
       relativeUris = absoluteUris;
     }
     expect(dependency.parts, relativeUris);
   }
 
@@ skipping 28 matching lines @@
   }
 
   /**
    * 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.
    */
-  void checkExportName(
-      PrelinkedExportName exportName,
-      String absoluteUri,
-      String relativeUri,
-      String expectedName,
-      PrelinkedReferenceKind expectedKind,
+  void checkExportName(LinkedExportName exportName, String absoluteUri,
+      String relativeUri, String expectedName, ReferenceKind expectedKind,
       {int expectedTargetUnit: 0}) {
-    expect(exportName, new isInstanceOf<PrelinkedExportName>());
+    expect(exportName, new isInstanceOf<LinkedExportName>());
     // Exported names must come from other libraries.
     expect(exportName.dependency, isNot(0));
     checkDependency(exportName.dependency, absoluteUri, relativeUri);
     expect(exportName.name, expectedName);
     expect(exportName.kind, expectedKind);
     expect(exportName.unit, expectedTargetUnit);
   }
 
   /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [absoluteUri] and [relativeUri].
    *
-   * The [PrelinkedDependency] is returned.
+   * The [LinkedDependency] is returned.
    */
-  PrelinkedDependency checkHasDependency(
-      String absoluteUri, String relativeUri) {
+  LinkedDependency checkHasDependency(String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
       // TODO(paulberry): fix this.
       relativeUri = absoluteUri;
     }
     List<String> found = <String>[];
-    for (PrelinkedDependency dep in prelinked.dependencies) {
+    for (LinkedDependency dep in linked.dependencies) {
       if (dep.uri == relativeUri) {
         return dep;
       }
       found.add(dep.uri);
     }
     fail('Did not find dependency $relativeUri.  Found: $found');
     return null;
   }
 
   /**
    * Verify that the dependency table *does not* contain any entries for a file
    * reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkLacksDependency(String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
       // TODO(paulberry): fix this.
       relativeUri = absoluteUri;
     }
-    for (PrelinkedDependency dep in prelinked.dependencies) {
+    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 parameter
    * having the given [deBruijnIndex].
    */
   void checkParamTypeRef(UnlinkedTypeRef typeRef, int deBruijnIndex) {
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     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) {
     expect(prefixReference, isNot(0));
     expect(unlinkedUnits[0].references[prefixReference].prefixReference, 0);
     expect(unlinkedUnits[0].references[prefixReference].name, name);
     expect(definingUnit.references[prefixReference].dependency, 0);
-    expect(definingUnit.references[prefixReference].kind,
-        PrelinkedReferenceKind.prefix);
+    expect(definingUnit.references[prefixReference].kind, ReferenceKind.prefix);
     expect(definingUnit.references[prefixReference].unit, 0);
   }
 
   /**
    * 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
+   * 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(UnlinkedTypeRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
-      PrelinkedReferenceKind expectedKind: PrelinkedReferenceKind.classOrEnum,
+      ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
-      PrelinkedUnit prelinkedSourceUnit,
+      LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
-    prelinkedSourceUnit ??= definingUnit;
+    linkedSourceUnit ??= 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];
+    LinkedReference referenceResolution = linkedSourceUnit.references[index];
     if (index == 0) {
       // Index 0 is reserved for "dynamic".
       expect(reference.name, isEmpty);
       expect(reference.prefixReference, 0);
     }
     if (absoluteUri == null) {
       expect(referenceResolution.dependency, 0);
     } else {
       checkDependency(referenceResolution.dependency, absoluteUri, relativeUri);
     }
     if (!allowTypeParameters) {
       expect(typeRef.typeArguments, isEmpty);
     }
-    if (expectedKind == PrelinkedReferenceKind.unresolved) {
+    if (expectedKind == ReferenceKind.unresolved) {
       // summarize_elements.dart isn't yet able to record the name of
       // unresolved references.  TODO(paulberry): fix this.
       expect(reference.name, '*unresolved*');
     } else if (expectedName == null) {
       expect(reference.name, isEmpty);
     } else {
       expect(reference.name, expectedName);
     }
     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.
     checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
-        expectedPrefix: expectedPrefix,
-        expectedKind: PrelinkedReferenceKind.unresolved);
-  }
-
-  test_dependencies_export_to_export_unused() {
-    // TODO(paulberry): fix this test.
-    addNamedSource('/a.dart', 'export "b.dart";');
-    addNamedSource('/b.dart', '');
-    serializeLibraryText('export "a.dart";');
-    // The main test library depends on b.dart, even though it doesn't
-    // re-export any names defined in b.dart, because a change to b.dart might
-    // cause it to start exporting a name that the main test library *does*
-    // use.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_export_unused() {
-    // TODO(paulberry): fix this test.
-    addNamedSource('/a.dart', '');
-    serializeLibraryText('export "a.dart";');
-    // The main test library depends on a.dart, even though it doesn't
-    // re-export any names defined in a.dart, because a change to a.dart might
-    // cause it to start exporting a name that the main test library *will*
-    // re-export.
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
+        expectedPrefix: expectedPrefix, expectedKind: ReferenceKind.unresolved);
   }
 
   fail_enum_value_documented() {
     // TODO(paulberry): currently broken because of dartbug.com/25385
     String text = '''
 enum E {
   /**
    * Docs
    */
   v
 }''';
     UnlinkedEnumValue value = serializeEnumText(text).values[0];
     expect(value.documentationComment, isNotNull);
     checkDocumentationComment(value.documentationComment, text);
   }
 
   fail_test_import_missing() {
     // TODO(paulberry): At the moment unresolved imports are not included in
     // the element model, so we can't pass this test.
     // Unresolved imports are included since this is necessary for proper
     // dependency tracking.
     allowMissingFiles = true;
     serializeLibraryText('import "foo.dart";', allowErrors: true);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     checkDependency(
-        prelinked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
+        linked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
   }
 
   fail_type_reference_to_nonexistent_file_via_prefix() {
     // 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`.
     allowMissingFiles = true;
     UnlinkedTypeRef typeRef = serializeTypeText('p.C',
         otherDeclarations: 'import "foo.dart" as p;', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, 'p', 'C');
@@ skipping 359 matching lines @@
         'abstract class C = D with E; class D {} class E {}');
     expect(cls.isAbstract, true);
   }
 
   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);
+        ReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_class_alias_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
@@ skipping 66 matching lines @@
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     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);
+        ReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_class_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
@@ skipping 385 matching lines @@
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.returnType, isNull);
   }
 
   test_constructor_return_type_parameterized() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C<T, U> { C(); }').executables);
     expect(executable.returnType, isNull);
   }
 
+  test_dependencies_export_to_export_unused() {
+    // TODO(paulberry): fix this test.
+    addNamedSource('/a.dart', 'export "b.dart";');
+    addNamedSource('/b.dart', '');
+    serializeLibraryText('export "a.dart";');
+    // The main test library depends on b.dart, even though it doesn't
+    // re-export any names defined in b.dart, because a change to b.dart might
+    // cause it to start exporting a name that the main test library *does*
+    // use.
+    checkHasDependency(absUri('/b.dart'), 'b.dart');
+  }
+
+  test_dependencies_export_unused() {
+    // TODO(paulberry): fix this test.
+    addNamedSource('/a.dart', '');
+    serializeLibraryText('export "a.dart";');
+    // The main test library depends on a.dart, even though it doesn't
+    // re-export any names defined in a.dart, because a change to a.dart might
+    // cause it to start exporting a name that the main test library *will*
+    // re-export.
+    checkHasDependency(absUri('/a.dart'), 'a.dart');
+  }
+
   test_dependencies_import_to_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('import "a.dart"; A a;');
     checkHasDependency(absUri('/a.dart'), 'a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
     checkHasDependency(absUri('/b.dart'), 'b.dart');
   }
 
@@ skipping 78 matching lines @@
     // start exporting a name that the main test library *does* use.
     checkHasDependency(absUri('/a.dart'), 'a.dart');
   }
 
   test_dependencies_parts() {
     addNamedSource(
         '/a.dart', 'library a; part "b.dart"; part "c.dart"; class A {}');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a;');
     serializeLibraryText('import "a.dart"; A a;');
-    PrelinkedDependency dep = checkHasDependency(absUri('/a.dart'), 'a.dart');
+    LinkedDependency dep = checkHasDependency(absUri('/a.dart'), 'a.dart');
     checkDependencyParts(
         dep, [absUri('/b.dart'), absUri('/c.dart')], ['b.dart', 'c.dart']);
   }
 
   test_dependencies_parts_relative_to_importing_library() {
     addNamedSource('/a/b.dart', 'export "c/d.dart";');
     addNamedSource('/a/c/d.dart',
         'library d; part "e/f.dart"; part "g/h.dart"; class D {}');
     addNamedSource('/a/c/e/f.dart', 'part of d;');
     addNamedSource('/a/c/g/h.dart', 'part of d;');
     serializeLibraryText('import "a/b.dart"; D d;');
-    PrelinkedDependency dep =
+    LinkedDependency dep =
         checkHasDependency(absUri('/a/c/d.dart'), 'a/c/d.dart');
     checkDependencyParts(
         dep,
         [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')],
         ['a/c/e/f.dart', 'a/c/g/h.dart']);
   }
 
   test_elements_in_part() {
     addNamedSource(
         '/part1.dart',
@@ skipping 18 matching lines @@
   test_enum() {
     String text = 'enum E { v1 }';
     UnlinkedEnum e = serializeEnumText(text);
     expect(e.name, 'E');
     expect(e.nameOffset, text.indexOf('E'));
     expect(e.values, hasLength(1));
     expect(e.values[0].name, 'v1');
     expect(e.values[0].nameOffset, text.indexOf('v1'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.classOrEnum);
+        ReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_enum_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
@@ skipping 30 matching lines @@
   test_executable_function() {
     String text = '  f() {}';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.topLevelFunction);
+        ReferenceKind.topLevelFunction);
     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);
   }
@@ skipping 12 matching lines @@
     String text = 'int get f => 1;';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+        ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
   }
 
   test_executable_getter_external() {
     UnlinkedExecutable executable =
         serializeExecutableText('external int get f;');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_getter_private() {
@@ skipping 309 matching lines @@
     String text = 'void set f(value) {}';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+        ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f=');
   }
 
   test_executable_setter_external() {
     UnlinkedExecutable executable =
         serializeExecutableText('external void set f(value);', 'f=');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_setter_implicit_return() {
@@ skipping 69 matching lines @@
   }
 
   test_executable_type_param_in_return_type_method() {
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_export_class() {
     addNamedSource('/a.dart', 'class C {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
-        PrelinkedReferenceKind.classOrEnum);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+        ReferenceKind.classOrEnum);
   }
 
   test_export_class_alias() {
     addNamedSource(
         '/a.dart', 'class C extends _D with _E {} class _D {} class _E {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
-        PrelinkedReferenceKind.classOrEnum);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+        ReferenceKind.classOrEnum);
   }
 
   test_export_enum() {
     addNamedSource('/a.dart', 'enum E { v }');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'E',
-        PrelinkedReferenceKind.classOrEnum);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'E',
+        ReferenceKind.classOrEnum);
   }
 
   test_export_from_part() {
     addNamedSource('/a.dart', 'library foo; part "b.dart";');
     addNamedSource('/b.dart', 'part of foo; f() {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelFunction,
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelFunction,
         expectedTargetUnit: 1);
   }
 
   test_export_function() {
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelFunction);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelFunction);
   }
 
   test_export_getter() {
     addNamedSource('/a.dart', 'get f => null');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_hide() {
     addNamedSource('/a.dart', 'f() {} g() {}');
     serializeLibraryText('export "a.dart" hide g;');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelFunction);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelFunction);
   }
 
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         isEmpty);
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[0],
         'Future');
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[1],
         'Stream');
-    expect(prelinked.exportNames, isNotEmpty);
+    expect(linked.exportNames, isNotEmpty);
   }
 
   test_export_names_excludes_names_from_library() {
     addNamedSource('/a.dart', 'part of my.lib; int y; int _y;');
     serializeLibraryText('library my.lib; part "a.dart"; int x; int _x;');
-    expect(prelinked.exportNames, isEmpty);
+    expect(linked.exportNames, isEmpty);
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
   }
 
   test_export_not_shadowed_by_prefix() {
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart"; import "dart:core" as f; f.int _x;');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelFunction);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelFunction);
   }
 
   test_export_offset() {
     String libraryText = '    export "dart:async";';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].exports[0].uriOffset,
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].exports[0].uriEnd, libraryText.indexOf(';'));
     expect(unlinkedUnits[0].exports[0].offset, libraryText.indexOf('export'));
   }
 
   test_export_private() {
     // Private names should not be exported.
     addNamedSource('/a.dart', '_f() {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, isEmpty);
+    expect(linked.exportNames, isEmpty);
   }
 
   test_export_setter() {
     addNamedSource('/a.dart', 'void set f(value) {}');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f=',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f=',
+        ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_shadowed() {
     // f() is not shown in exportNames because it is already defined at top
     // level in the library.
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart"; f() {}');
-    expect(prelinked.exportNames, isEmpty);
+    expect(linked.exportNames, isEmpty);
   }
 
   test_export_shadowed_variable() {
     // Neither `v` nor `v=` is shown in exportNames because both are defined at
     // top level in the library by the declaration `var v;`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; var v;');
-    expect(prelinked.exportNames, isEmpty);
+    expect(linked.exportNames, isEmpty);
   }
 
   test_export_shadowed_variable_const() {
     // `v=` is shown in exportNames because the top level declaration
     // `const v = 0;` only shadows `v`, not `v=`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; const v = 0;');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+        ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_shadowed_variable_final() {
     // `v=` is shown in exportNames because the top level declaration
     // `final v = 0;` only shadows `v`, not `v=`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; final v = 0;');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+        ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_show() {
     addNamedSource('/a.dart', 'f() {} g() {}');
     serializeLibraryText('export "a.dart" show f;');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        PrelinkedReferenceKind.topLevelFunction);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        ReferenceKind.topLevelFunction);
   }
 
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
         isEmpty);
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[0],
         'Future');
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[1],
         'Stream');
   }
 
   test_export_typedef() {
     addNamedSource('/a.dart', 'typedef F();');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(1));
-    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'F',
-        PrelinkedReferenceKind.typedef);
+    expect(linked.exportNames, hasLength(1));
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'F',
+        ReferenceKind.typedef);
   }
 
   test_export_uri() {
     addNamedSource('/a.dart', 'library my.lib;');
     String uriString = '"a.dart"';
     String libraryText = 'export $uriString;';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].uri, 'a.dart');
   }
 
   test_export_variable() {
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart";');
-    expect(prelinked.exportNames, hasLength(2));
-    PrelinkedExportName getter =
-        prelinked.exportNames.firstWhere((e) => e.name == 'v');
+    expect(linked.exportNames, hasLength(2));
+    LinkedExportName getter =
+        linked.exportNames.firstWhere((e) => e.name == 'v');
     expect(getter, isNotNull);
     checkExportName(getter, absUri('/a.dart'), 'a.dart', 'v',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
-    PrelinkedExportName setter =
-        prelinked.exportNames.firstWhere((e) => e.name == 'v=');
+        ReferenceKind.topLevelPropertyAccessor);
+    LinkedExportName setter =
+        linked.exportNames.firstWhere((e) => e.name == 'v=');
     expect(setter, isNotNull);
     checkExportName(setter, absUri('/a.dart'), 'a.dart', 'v=',
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+        ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
     UnlinkedVariable variable = findVariable('i', variables: cls.fields);
     expect(variable, isNotNull);
     expect(variable.isConst, isFalse);
     expect(variable.isStatic, isFalse);
     expect(variable.isFinal, isFalse);
     expect(findExecutable('i', executables: cls.executables), isNull);
@@ skipping 68 matching lines @@
   test_import_deferred() {
     serializeLibraryText(
         'import "dart:async" deferred as a; main() { print(a.Future); }');
     expect(unlinkedUnits[0].imports[0].isDeferred, isTrue);
   }
 
   test_import_dependency() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
-    checkDependency(
-        prelinked.importDependencies[0], 'dart:async', 'dart:async');
+    checkDependency(linked.importDependencies[0], 'dart:async', 'dart:async');
   }
 
   test_import_explicit() {
     serializeLibraryText('import "dart:core"; int i;');
     expect(unlinkedUnits[0].imports, hasLength(1));
     expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
   }
 
   test_import_hide_order() {
     serializeLibraryText(
         'import "dart:async" hide Future, Stream; Completer c;');
     // 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, isEmpty);
     expect(unlinkedUnits[0].imports[0].combinators[0].hides, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators[0].hides[0], 'Future');
     expect(unlinkedUnits[0].imports[0].combinators[0].hides[1], 'Stream');
   }
 
   test_import_implicit() {
     // The implicit import of dart:core is represented in the model.
     serializeLibraryText('');
     expect(unlinkedUnits[0].imports, hasLength(1));
-    checkDependency(prelinked.importDependencies[0], 'dart:core', 'dart:core');
+    checkDependency(linked.importDependencies[0], 'dart:core', 'dart:core');
     expect(unlinkedUnits[0].imports[0].uri, isEmpty);
     expect(unlinkedUnits[0].imports[0].uriOffset, 0);
     expect(unlinkedUnits[0].imports[0].uriEnd, 0);
     expect(unlinkedUnits[0].imports[0].prefixReference, 0);
     expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
     expect(unlinkedUnits[0].imports[0].isImplicit, isTrue);
   }
 
   test_import_no_combinators() {
     serializeLibraryText('import "dart:async"; Future x;');
@@ skipping 244 matching lines @@
     serializeLibraryText(text);
     expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts[0], 'a.dart');
     expect(unlinkedUnits[0].parts, hasLength(1));
     expect(unlinkedUnits[0].parts[0].uriOffset, text.indexOf('"a.dart"'));
     expect(unlinkedUnits[0].parts[0].uriEnd, text.indexOf('; // <-part'));
   }
 
   test_parts_defining_compilation_unit() {
     serializeLibraryText('');
-    expect(prelinked.units, hasLength(1));
+    expect(linked.units, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts, isEmpty);
   }
 
   test_parts_included() {
     addNamedSource('/part1.dart', 'part of my.lib;');
     String partString = '"part1.dart"';
     String libraryText = 'library my.lib; part $partString;';
     serializeLibraryText(libraryText);
-    expect(prelinked.units, hasLength(2));
+    expect(linked.units, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts[0], 'part1.dart');
   }
 
   test_public_namespace_of_part() {
     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');
@@ skipping 24 matching lines @@
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         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: ReferenceKind.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: ReferenceKind.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, 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: ReferenceKind.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, 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() {
     addNamedSource('/a.dart', 'part of foo; C v;');
     serializeLibraryText('library foo; part "a.dart"; class C {}');
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
         null, null, 'C',
-        expectedKind: PrelinkedReferenceKind.classOrEnum,
-        prelinkedSourceUnit: prelinked.units[1],
+        expectedKind: ReferenceKind.classOrEnum,
+        linkedSourceUnit: linked.units[1],
         unlinkedSourceUnit: unlinkedUnits[1]);
   }
 
   test_type_reference_from_part_withPrefix() {
     addNamedSource('/a.dart', 'class C {}');
     addNamedSource('/p.dart', 'part of foo; a.C v;');
     serializeLibraryText(
         'library foo; import "a.dart"; import "a.dart" as a; part "p.dart";',
         allowErrors: true);
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
         absUri('/a.dart'), 'a.dart', 'C',
         expectedPrefix: 'a',
-        prelinkedSourceUnit: prelinked.units[1],
+        linkedSourceUnit: linked.units[1],
         unlinkedSourceUnit: unlinkedUnits[1]);
   }
 
   test_type_reference_to_class_argument() {
     UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
     {
       UnlinkedTypeRef typeRef =
           findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
@@ skipping 74 matching lines @@
         null,
         null,
         'C',
         expectedTargetUnit: 1);
   }
 
   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: PrelinkedReferenceKind.classOrEnum,
-        expectedTargetUnit: 1);
+        expectedKind: ReferenceKind.classOrEnum, expectedTargetUnit: 1);
   }
 
   test_type_reference_to_typedef() {
     checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
         null, null, 'F',
-        expectedKind: PrelinkedReferenceKind.typedef);
+        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 {}');
     UnlinkedTypeRef 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
@@ skipping 18 matching lines @@
     expect(typedef.documentationComment, isNotNull);
     checkDocumentationComment(typedef.documentationComment, text);
   }
 
   test_typedef_name() {
     String text = 'typedef F();';
     UnlinkedTypedef type = serializeTypedefText(text);
     expect(type.name, 'F');
     expect(type.nameOffset, text.indexOf('F'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.typedef);
+    expect(
+        unlinkedUnits[0].publicNamespace.names[0].kind, ReferenceKind.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));
     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);
+        numTypeParameters: 2, expectedKind: ReferenceKind.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);
+        numTypeParameters: 2, expectedKind: ReferenceKind.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 18 matching lines @@
   }
 
   test_variable() {
     String text = 'int i;';
     UnlinkedVariable v = serializeVariableText(text, variableName: 'i');
     expect(v.nameOffset, text.indexOf('i;'));
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+        ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
     expect(unlinkedUnits[0].publicNamespace.names[1].kind,
-        PrelinkedReferenceKind.topLevelPropertyAccessor);
+        ReferenceKind.topLevelPropertyAccessor);
     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);
   }
 
@@ skipping 76 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);
   }
 }