Separate prelinked and unlinked parts of 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/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 27 matching lines @@
     serializeLibraryElement(element.library);
     return findClass(element.name, failIfAbsent: true);
   }
 
   /**
    * Serialize the given [library] element, then deserialize it and store the
    * resulting summary in [lib].
    */
   void serializeLibraryElement(LibraryElement library) {
     BuilderContext builderContext = new BuilderContext();
-    PrelinkedLibraryBuilder serializedLib = summarize_elements.serializeLibrary(
-        builderContext, library, typeProvider);
-    List<int> encodedLib = serializedLib.toBuffer();
-    lib = new PrelinkedLibrary.fromBuffer(encodedLib);
+    summarize_elements.LibrarySerializationResult serializedLib =
+        summarize_elements.serializeLibrary(
+            builderContext, library, typeProvider);
+    prelinked =
+        new PrelinkedLibrary.fromBuffer(serializedLib.prelinked.toBuffer());
+    unlinkedUnits = serializedLib.unlinkedUnits
+        .map((UnlinkedUnitBuilder b) =>
+            new UnlinkedUnit.fromBuffer(b.toBuffer()))
+        .toList();
   }
 
   @override
   void serializeLibraryText(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElement library = resolve2(source);
     if (!allowErrors) {
       assertNoErrors(source);
     }
     serializeLibraryElement(library);
-    expect(definingUnit.unlinked.imports.length, lib.importDependencies.length);
-    for (PrelinkedUnit unit in lib.units) {
-      expect(unit.unlinked.references.length, unit.references.length);
+    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[i].references.length,
+          prelinked.units[i].references.length);
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableGenericMethods = true;
     resetWithOptions(options);
   }
 
   test_class_no_superclass() {
     UnlinkedClass cls = serializeClassElement(typeProvider.objectType.element);
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isTrue);
   }
 }
 
 /**
  * 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 {
   /**
-   * The result of serializing and then deserializing the library under test.
+   * Prelinked summary that results from serializing and then deserializing the
+   * library under test.
    */
-  PrelinkedLibrary lib;
+  PrelinkedLibrary prelinked;
+
+  /**
+   * Unlinked compilation unit summaries that result from serializing and
+   * deserializing the library under test.
+   */
+  List<UnlinkedUnit> unlinkedUnits;
 
   /**
    * `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.
    */
-  PrelinkedUnit get definingUnit => lib.units[0];
+  PrelinkedUnit get definingUnit => prelinked.units[0];
 
   /**
    * Convert [path] to a suitably formatted absolute path URI for the current
    * platform.
    */
   String absUri(String path) {
     return FileUtilities2.createFile(path).toURI().toString();
   }
 
   /**
@@ skipping 17 matching lines @@
    * a file reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkDependency(int dependency, String absoluteUri, String relativeUri) {
     if (!checkAstDerivedData) {
       // 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(lib.dependencies[dependency].uri, relativeUri);
+    expect(prelinked.dependencies[dependency].uri, relativeUri);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
   void checkDynamicTypeRef(UnlinkedTypeRef typeRef) {
     checkTypeRef(typeRef, null, null, null);
   }
 
   /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [absoluteUri] and [relativeUri].
    */
   void checkHasDependency(String absoluteUri, String relativeUri) {
     if (!checkAstDerivedData) {
       // 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 lib.dependencies) {
+    for (PrelinkedDependency dep in prelinked.dependencies) {
       if (dep.uri == relativeUri) {
         return;
       }
     }
     fail('Did not find dependency $absoluteUri');
   }
 
   /**
    * 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 (!checkAstDerivedData) {
       // 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 lib.dependencies) {
+    for (PrelinkedDependency dep in prelinked.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(
-        definingUnit.unlinked.references[prefixReference].prefixReference, 0);
-    expect(definingUnit.unlinked.references[prefixReference].name, name);
+    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].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.  [sourceUnit] is the compilation unit within which the
-   * [typeRef] appears; if not specified it is assumed to be 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.
+   * 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.
    */
   void checkTypeRef(UnlinkedTypeRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
       PrelinkedReferenceKind expectedKind: PrelinkedReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
-      PrelinkedUnit sourceUnit}) {
-    sourceUnit ??= definingUnit;
+      PrelinkedUnit prelinkedSourceUnit,
+      UnlinkedUnit unlinkedSourceUnit}) {
+    prelinkedSourceUnit ??= definingUnit;
+    unlinkedSourceUnit ??= unlinkedUnits[0];
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
-    UnlinkedReference reference = sourceUnit.unlinked.references[index];
-    PrelinkedReference referenceResolution = sourceUnit.references[index];
+    UnlinkedReference reference = unlinkedSourceUnit.references[index];
+    PrelinkedReference referenceResolution =
+        prelinkedSourceUnit.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);
     }
@@ skipping 29 matching lines @@
         expectedKind: PrelinkedReferenceKind.unresolved);
   }
 
   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.
     serializeLibraryText('import "foo.dart";', allowErrors: true);
     // Second import is the implicit import of dart:core
-    expect(definingUnit.unlinked.imports, hasLength(2));
-    checkDependency(lib.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    checkDependency(
+        prelinked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
   }
 
   /**
    * Find the class with the given [className] in the summary, and return its
    * [UnlinkedClass] data structure.  If [unit] is not given, the class is
    * looked for in the defining compilation unit.
    */
   UnlinkedClass findClass(String className,
-      {bool failIfAbsent: false, PrelinkedUnit unit}) {
-    unit ??= definingUnit;
+      {bool failIfAbsent: false, UnlinkedUnit unit}) {
+    unit ??= unlinkedUnits[0];
     UnlinkedClass result;
-    for (UnlinkedClass cls in unit.unlinked.classes) {
+    for (UnlinkedClass cls in unit.classes) {
       if (cls.name == className) {
         if (result != null) {
           fail('Duplicate class $className');
         }
         result = cls;
       }
     }
     if (result == null && failIfAbsent) {
       fail('Class $className not found in serialized output');
     }
     return result;
   }
 
   /**
    * Find the enum with the given [enumName] in the summary, and return its
    * [UnlinkedEnum] data structure.  If [unit] is not given, the enum is looked
    * for in the defining compilation unit.
    */
   UnlinkedEnum findEnum(String enumName,
-      {bool failIfAbsent: false, PrelinkedUnit unit}) {
-    unit ??= definingUnit;
+      {bool failIfAbsent: false, UnlinkedUnit unit}) {
+    unit ??= unlinkedUnits[0];
     UnlinkedEnum result;
-    for (UnlinkedEnum e in unit.unlinked.enums) {
+    for (UnlinkedEnum e in unit.enums) {
       if (e.name == enumName) {
         if (result != null) {
           fail('Duplicate enum $enumName');
         }
         result = e;
       }
     }
     if (result == null && failIfAbsent) {
       fail('Enum $enumName not found in serialized output');
     }
     return result;
   }
 
   /**
    * Find the executable with the given [executableName] in the summary, and
    * return its [UnlinkedExecutable] data structure.  If [executables] is not
    * given, then the executable is searched for in the defining compilation
    * unit.
    */
   UnlinkedExecutable findExecutable(String executableName,
       {List<UnlinkedExecutable> executables, bool failIfAbsent: false}) {
-    executables ??= definingUnit.unlinked.executables;
+    executables ??= unlinkedUnits[0].executables;
     UnlinkedExecutable result;
     for (UnlinkedExecutable executable in executables) {
       if (executable.name == executableName) {
         if (result != null) {
           fail('Duplicate executable $executableName');
         }
         result = executable;
       }
     }
     if (result == null && failIfAbsent) {
       fail('Executable $executableName not found in serialized output');
     }
     return result;
   }
 
   /**
    * Find the typedef with the given [typedefName] in the summary, and return
    * its [UnlinkedTypedef] data structure.  If [unit] is not given, the typedef
    * is looked for in the defining compilation unit.
    */
   UnlinkedTypedef findTypedef(String typedefName,
-      {bool failIfAbsent: false, PrelinkedUnit unit}) {
-    unit ??= definingUnit;
+      {bool failIfAbsent: false, UnlinkedUnit unit}) {
+    unit ??= unlinkedUnits[0];
     UnlinkedTypedef result;
-    for (UnlinkedTypedef type in unit.unlinked.typedefs) {
+    for (UnlinkedTypedef type in unit.typedefs) {
       if (type.name == typedefName) {
         if (result != null) {
           fail('Duplicate typedef $typedefName');
         }
         result = type;
       }
     }
     if (result == null && failIfAbsent) {
       fail('Typedef $typedefName not found in serialized output');
     }
     return result;
   }
 
   /**
    * Find the top level variable with the given [variableName] in the summary,
    * and return its [UnlinkedVariable] data structure.  If [variables] is not
    * specified, the variable is looked for in the defining compilation unit.
    */
   UnlinkedVariable findVariable(String variableName,
       {List<UnlinkedVariable> variables, bool failIfAbsent: false}) {
-    variables ??= definingUnit.unlinked.variables;
+    variables ??= unlinkedUnits[0].variables;
     UnlinkedVariable result;
     for (UnlinkedVariable variable in variables) {
       if (variable.name == variableName) {
         if (result != null) {
           fail('Duplicate variable $variableName');
         }
         result = variable;
       }
     }
     if (result == null && failIfAbsent) {
@@ skipping 684 matching lines @@
         '''
 part of my.lib;
 
 class C {}
 enum E { v }
 var v;
 f() {}
 typedef F();
 ''');
     serializeLibraryText('library my.lib; part "part1.dart";');
-    PrelinkedUnit unit = lib.units[1];
+    UnlinkedUnit unit = unlinkedUnits[1];
     expect(findClass('C', unit: unit), isNotNull);
     expect(findEnum('E', unit: unit), isNotNull);
-    expect(findVariable('v', variables: unit.unlinked.variables), isNotNull);
-    expect(
-        findExecutable('f', executables: unit.unlinked.executables), isNotNull);
+    expect(findVariable('v', variables: unit.variables), isNotNull);
+    expect(findExecutable('f', executables: unit.executables), isNotNull);
     expect(findTypedef('F', unit: unit), isNotNull);
   }
 
   test_enum() {
     UnlinkedEnum e = serializeEnumText('enum E { v1 }');
     expect(e.name, 'E');
     expect(e.values, hasLength(1));
     expect(e.values[0].name, 'v1');
   }
 
@@ skipping 417 matching lines @@
   }
 
   test_executable_type_param_in_return_type() {
     // TODO(paulberry): also test top level executables.
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
-    expect(definingUnit.unlinked.exports, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].combinators, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].combinators[0].shows, isEmpty);
-    expect(definingUnit.unlinked.exports[0].combinators[0].hides, hasLength(2));
+    expect(unlinkedUnits[0].exports, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].combinators, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].combinators[0].shows, isEmpty);
+    expect(unlinkedUnits[0].exports[0].combinators[0].hides, hasLength(2));
     checkCombinatorName(
-        definingUnit.unlinked.exports[0].combinators[0].hides[0], 'Future');
+        unlinkedUnits[0].exports[0].combinators[0].hides[0], 'Future');
     checkCombinatorName(
-        definingUnit.unlinked.exports[0].combinators[0].hides[1], 'Stream');
+        unlinkedUnits[0].exports[0].combinators[0].hides[1], 'Stream');
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
-    expect(definingUnit.unlinked.exports, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].combinators, isEmpty);
+    expect(unlinkedUnits[0].exports, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].combinators, isEmpty);
   }
 
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
-    expect(definingUnit.unlinked.exports, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].combinators, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].combinators[0].shows, hasLength(2));
-    expect(definingUnit.unlinked.exports[0].combinators[0].hides, isEmpty);
+    expect(unlinkedUnits[0].exports, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].combinators, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].combinators[0].shows, hasLength(2));
+    expect(unlinkedUnits[0].exports[0].combinators[0].hides, isEmpty);
     checkCombinatorName(
-        definingUnit.unlinked.exports[0].combinators[0].shows[0], 'Future');
+        unlinkedUnits[0].exports[0].combinators[0].shows[0], 'Future');
     checkCombinatorName(
-        definingUnit.unlinked.exports[0].combinators[0].shows[1], 'Stream');
+        unlinkedUnits[0].exports[0].combinators[0].shows[1], 'Stream');
   }
 
   test_export_uri() {
     addNamedSource('/a.dart', 'library my.lib;');
     String uriString = '"a.dart"';
     String libraryText = 'export $uriString;';
     serializeLibraryText(libraryText);
-    expect(definingUnit.unlinked.exports, hasLength(1));
-    expect(definingUnit.unlinked.exports[0].uri, 'a.dart');
+    expect(unlinkedUnits[0].exports, hasLength(1));
+    expect(unlinkedUnits[0].exports[0].uri, 'a.dart');
   }
 
   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 24 matching lines @@
     List<UnlinkedParam> params = cls.executables[0].parameters;
     checkParamTypeRef(params[0].type, 4);
     checkParamTypeRef(params[1].type, 3);
     checkParamTypeRef(params[2].type, 2);
     checkParamTypeRef(params[3].type, 1);
   }
 
   test_import_deferred() {
     serializeLibraryText(
         'import "dart:async" deferred as a; main() { print(a.Future); }');
-    expect(definingUnit.unlinked.imports[0].isDeferred, isTrue);
+    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(definingUnit.unlinked.imports, hasLength(2));
-    checkDependency(lib.importDependencies[0], 'dart:async', 'dart:async');
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    checkDependency(
+        prelinked.importDependencies[0], 'dart:async', 'dart:async');
   }
 
   test_import_explicit() {
     serializeLibraryText('import "dart:core"; int i;');
-    expect(definingUnit.unlinked.imports, hasLength(1));
-    expect(definingUnit.unlinked.imports[0].isImplicit, isFalse);
+    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(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].combinators, hasLength(1));
-    expect(definingUnit.unlinked.imports[0].combinators[0].shows, isEmpty);
-    expect(definingUnit.unlinked.imports[0].combinators[0].hides, hasLength(2));
+    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));
     checkCombinatorName(
-        definingUnit.unlinked.imports[0].combinators[0].hides[0], 'Future');
+        unlinkedUnits[0].imports[0].combinators[0].hides[0], 'Future');
     checkCombinatorName(
-        definingUnit.unlinked.imports[0].combinators[0].hides[1], 'Stream');
+        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(definingUnit.unlinked.imports, hasLength(1));
-    checkDependency(lib.importDependencies[0], 'dart:core', 'dart:core');
-    expect(definingUnit.unlinked.imports[0].uri, isEmpty);
-    expect(definingUnit.unlinked.imports[0].prefixReference, 0);
-    expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
-    expect(definingUnit.unlinked.imports[0].isImplicit, isTrue);
+    expect(unlinkedUnits[0].imports, hasLength(1));
+    checkDependency(prelinked.importDependencies[0], 'dart:core', 'dart:core');
+    expect(unlinkedUnits[0].imports[0].uri, isEmpty);
+    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;');
     // Second import is the implicit import of dart:core
-    expect(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
   }
 
   test_import_no_flags() {
     serializeLibraryText('import "dart:async"; Future x;');
-    expect(definingUnit.unlinked.imports[0].isImplicit, isFalse);
-    expect(definingUnit.unlinked.imports[0].isDeferred, isFalse);
+    expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
+    expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
   }
 
   test_import_non_deferred() {
     serializeLibraryText(
         'import "dart:async" as a; main() { print(a.Future); }');
-    expect(definingUnit.unlinked.imports[0].isDeferred, isFalse);
+    expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
   }
 
   test_import_of_file_with_missing_part() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // part declaration for bar.dart refers to a non-existent file.
     addNamedSource('/foo.dart', 'part "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
     checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
   }
 
   test_import_of_missing_export() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // re-export of bar.dart refers to a non-existent file.
     addNamedSource('/foo.dart', 'export "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
     checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
   }
 
   test_import_offset() {
     String libraryText = '    import "dart:async"; Future x;';
     serializeLibraryText(libraryText);
-    expect(
-        definingUnit.unlinked.imports[0].offset, libraryText.indexOf('import'));
+    expect(unlinkedUnits[0].imports[0].offset, libraryText.indexOf('import'));
   }
 
   test_import_prefix_name() {
     String libraryText = 'import "dart:async" as a; a.Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
-    expect(definingUnit.unlinked.imports, hasLength(2));
-    checkPrefix(definingUnit.unlinked.imports[0].prefixReference, 'a');
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    checkPrefix(unlinkedUnits[0].imports[0].prefixReference, 'a');
   }
 
   test_import_prefix_none() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
-    expect(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].prefixReference, 0);
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    expect(unlinkedUnits[0].imports[0].prefixReference, 0);
   }
 
   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');
   }
 
   test_import_reference() {
@@ skipping 26 matching lines @@
         expectedPrefix: 'a');
     checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
         expectedPrefix: 'a');
   }
 
   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(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].combinators, hasLength(1));
-    expect(definingUnit.unlinked.imports[0].combinators[0].shows, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].combinators[0].hides, isEmpty);
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
+    expect(unlinkedUnits[0].imports[0].combinators[0].shows, hasLength(2));
+    expect(unlinkedUnits[0].imports[0].combinators[0].hides, isEmpty);
     checkCombinatorName(
-        definingUnit.unlinked.imports[0].combinators[0].shows[0], 'Future');
+        unlinkedUnits[0].imports[0].combinators[0].shows[0], 'Future');
     checkCombinatorName(
-        definingUnit.unlinked.imports[0].combinators[0].shows[1], 'Stream');
+        unlinkedUnits[0].imports[0].combinators[0].shows[1], 'Stream');
   }
 
   test_import_uri() {
     String uriString = '"dart:async"';
     String libraryText = 'import $uriString; Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
-    expect(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].uri, 'dart:async');
+    expect(unlinkedUnits[0].imports, hasLength(2));
+    expect(unlinkedUnits[0].imports[0].uri, 'dart:async');
   }
 
   test_library_named() {
     String text = 'library foo.bar;';
     serializeLibraryText(text);
-    expect(definingUnit.unlinked.libraryName, 'foo.bar');
+    expect(unlinkedUnits[0].libraryName, 'foo.bar');
   }
 
   test_library_unnamed() {
     serializeLibraryText('');
-    expect(definingUnit.unlinked.libraryName, isEmpty);
+    expect(unlinkedUnits[0].libraryName, isEmpty);
   }
 
   test_parts_defining_compilation_unit() {
     serializeLibraryText('');
-    expect(lib.units, hasLength(1));
-    expect(definingUnit.unlinked.parts, isEmpty);
+    expect(prelinked.units, hasLength(1));
+    expect(unlinkedUnits[0].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(lib.units, hasLength(2));
-    expect(definingUnit.unlinked.parts, hasLength(1));
-    expect(definingUnit.unlinked.parts[0].uri, 'part1.dart');
+    expect(prelinked.units, hasLength(2));
+    expect(unlinkedUnits[0].parts, hasLength(1));
+    expect(unlinkedUnits[0].parts[0].uri, 'part1.dart');
   }
 
   test_type_arguments_explicit() {
     UnlinkedTypeRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 48 matching lines @@
     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: lib.units[1].unlinked.variables).type,
-        null,
-        null,
-        'C',
+    checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
+        null, null, 'C',
         expectedKind: PrelinkedReferenceKind.classOrEnum,
-        sourceUnit: lib.units[1]);
+        prelinkedSourceUnit: prelinked.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 236 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }