Organize summary declarations by unit rather than by library.

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/src/generated/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 41 matching lines @@
   }
 
   @override
   void serializeLibraryText(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElement library = resolve2(source);
     if (!allowErrors) {
       assertNoErrors(source);
     }
     serializeLibraryElement(library);
-    expect(unlinked.imports.length, lib.importDependencies.length);
+    expect(definingUnit.unlinked.imports.length, lib.importDependencies.length);
     expect(unlinked.references.length, lib.references.length);
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableGenericMethods = true;
     resetWithOptions(options);
   }
@@ skipping 18 matching lines @@
 
   /**
    * `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];
+
+  /**
    * Get access to the "unlinked" section of the summary.
    */
   UnlinkedLibrary get unlinked => lib.unlinked;
 
   /**
    * Convert [path] to a suitably formatted absolute path URI for the current
    * platform.
    */
   String absUri(String path) {
     return FileUtilities2.createFile(path).toURI().toString();
@@ skipping 143 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(unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports, hasLength(2));
     checkDependency(lib.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
   }
 
   /**
    * Find the class with the given [className] in the summary, and return its
-   * [UnlinkedClass] data structure.
+   * [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}) {
+  UnlinkedClass findClass(String className,
+      {bool failIfAbsent: false, PrelinkedUnit unit}) {
+    unit ??= definingUnit;
     UnlinkedClass result;
-    for (UnlinkedClass cls in unlinked.classes) {
+    for (UnlinkedClass cls in unit.unlinked.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.
+   * [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}) {
+  UnlinkedEnum findEnum(String enumName,
+      {bool failIfAbsent: false, PrelinkedUnit unit}) {
+    unit ??= definingUnit;
     UnlinkedEnum result;
-    for (UnlinkedEnum e in unlinked.enums) {
+    for (UnlinkedEnum e in unit.unlinked.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.
+   * 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,
-      {UnlinkedClass cls, bool failIfAbsent: false}) {
-    List<UnlinkedExecutable> executables;
-    if (cls == null) {
-      executables = unlinked.executables;
-    } else {
-      executables = cls.executables;
-    }
+      {List<UnlinkedExecutable> executables, bool failIfAbsent: false}) {
+    executables ??= definingUnit.unlinked.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.
+   * 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}) {
+  UnlinkedTypedef findTypedef(String typedefName,
+      {bool failIfAbsent: false, PrelinkedUnit unit}) {
+    unit ??= definingUnit;
     UnlinkedTypedef result;
-    for (UnlinkedTypedef type in unlinked.typedefs) {
+    for (UnlinkedTypedef type in unit.unlinked.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.
+   * 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,
-      {UnlinkedClass cls, bool failIfAbsent: false}) {
-    List<UnlinkedVariable> variables;
-    if (cls == null) {
-      variables = unlinked.variables;
-    } else {
-      variables = cls.fields;
-    }
+      {List<UnlinkedVariable> variables, bool failIfAbsent: false}) {
+    variables ??= definingUnit.unlinked.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 37 matching lines @@
   void serializeLibraryText(String text, {bool allowErrors: false});
 
   /**
    * Serialize the given method [text] and return the summary of the executable
    * with the given [executableName].
    */
   UnlinkedExecutable serializeMethodText(String text,
       [String executableName = 'f']) {
     serializeLibraryText('class C { $text }');
     return findExecutable(executableName,
-        cls: findClass('C', failIfAbsent: true), failIfAbsent: true);
+        executables: findClass('C', failIfAbsent: true).executables,
+        failIfAbsent: true);
   }
 
   /**
    * Serialize the given library [text] and return the summary of the typedef
    * with the given [typedefName].
    */
   UnlinkedTypedef serializeTypedefText(String text,
       [String typedefName = 'F']) {
     serializeLibraryText(text);
     return findTypedef(typedefName, failIfAbsent: true);
@@ skipping 244 matching lines @@
 ''');
     expect(cls.mixins, hasLength(2));
     checkTypeRef(cls.mixins[0], null, null, 'D');
     checkTypeRef(cls.mixins[1], null, null, 'E');
   }
 
   test_class_name() {
     var classText = 'class C {}';
     UnlinkedClass cls = serializeClassText(classText);
     expect(cls.name, 'C');
-    expect(cls.unit, 0);
   }
 
   test_class_no_flags() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isAbstract, false);
     expect(cls.isMixinApplication, false);
   }
 
   test_class_no_interface() {
     UnlinkedClass cls = serializeClassText('class C {}');
@@ skipping 48 matching lines @@
   }
 
   test_class_type_param_no_bound() {
     UnlinkedClass cls = serializeClassText('class C<T> {}');
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNull);
   }
 
   test_constructor() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { C(); }').executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_constructor_anonymous() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { C(); }').executables);
     expect(executable.name, isEmpty);
   }
 
   test_constructor_const() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { const C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { const C(); }').executables);
     expect(executable.isConst, isTrue);
   }
 
   test_constructor_factory() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { factory C() => null; }'));
+        executables:
+            serializeClassText('class C { factory C() => null; }').executables);
     expect(executable.isFactory, isTrue);
   }
 
   test_constructor_implicit() {
     // Implicit constructors are not serialized.
     UnlinkedExecutable executable = findExecutable(null,
-        cls: serializeClassText('class C { C(); }'), failIfAbsent: false);
+        executables: serializeClassText('class C { C(); }').executables,
+        failIfAbsent: false);
     expect(executable, isNull);
   }
 
   test_constructor_initializing_formal() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x); final x; }'));
+        executables:
+            serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isInitializingFormal, isTrue);
   }
 
   test_constructor_initializing_formal_explicit_type() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(int this.x); final x; }'));
+        executables: serializeClassText('class C { C(int this.x); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x()); final x; }'));
+        executables: serializeClassText('class C { C(this.x()); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isFunctionTyped, isTrue);
   }
 
   test_constructor_initializing_formal_function_typed_explicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(int this.x()); Function x; }'));
+        executables:
+            serializeClassText('class C { C(int this.x()); Function x; }')
+                .executables);
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed_implicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x()); Function x; }'));
+        executables: serializeClassText('class C { C(this.x()); Function x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     // Since the parameter is function-typed it is considered to have an
     // explicit type, even though that explicit type itself has an implicit
     // return type.
     expect(parameter.hasImplicitType, isFalse);
     checkDynamicTypeRef(parameter.type);
   }
 
   test_constructor_initializing_formal_function_typed_no_prameters() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x()); final x; }'));
+        executables: serializeClassText('class C { C(this.x()); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, isEmpty);
   }
 
   test_constructor_initializing_formal_function_typed_prameter() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x(a)); final x; }'));
+        executables: serializeClassText('class C { C(this.x(a)); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, hasLength(1));
   }
 
   test_constructor_initializing_formal_function_typed_prameter_order() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x(a, b)); final x; }'));
+        executables: serializeClassText('class C { C(this.x(a, b)); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, hasLength(2));
     expect(parameter.parameters[0].name, 'a');
     expect(parameter.parameters[1].name, 'b');
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x); int x; }'));
+        executables:
+            serializeClassText('class C { C(this.x); int x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
     expect(parameter.hasImplicitType, isTrue);
   }
 
   test_constructor_initializing_formal_name() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x); final x; }'));
+        executables:
+            serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.name, 'x');
   }
 
   test_constructor_initializing_formal_named() {
     // TODO(paulberry): also test default value
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C({this.x}); final x; }'));
+        executables: serializeClassText('class C { C({this.x}); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.named);
   }
 
   test_constructor_initializing_formal_non_function_typed() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x); final x; }'));
+        executables:
+            serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isFunctionTyped, isFalse);
   }
 
   test_constructor_initializing_formal_positional() {
     // TODO(paulberry): also test default value
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C([this.x]); final x; }'));
+        executables: serializeClassText('class C { C([this.x]); final x; }')
+            .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.positional);
   }
 
   test_constructor_initializing_formal_required() {
     UnlinkedExecutable executable = findExecutable('',
-        cls: serializeClassText('class C { C(this.x); final x; }'));
+        executables:
+            serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.required);
   }
 
   test_constructor_named() {
-    UnlinkedExecutable executable =
-        findExecutable('foo', cls: serializeClassText('class C { C.foo(); }'));
+    UnlinkedExecutable executable = findExecutable('foo',
+        executables: serializeClassText('class C { C.foo(); }').executables);
     expect(executable.name, 'foo');
   }
 
   test_constructor_non_const() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isConst, isFalse);
   }
 
   test_constructor_non_factory() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isFactory, isFalse);
   }
 
   test_constructor_return_type() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C { C(); }').executables);
     checkTypeRef(executable.returnType, null, null, 'C');
   }
 
   test_constructor_return_type_parameterized() {
-    UnlinkedExecutable executable =
-        findExecutable('', cls: serializeClassText('class C<T, U> { C(); }'));
+    UnlinkedExecutable executable = findExecutable('',
+        executables: serializeClassText('class C<T, U> { C(); }').executables);
     checkTypeRef(executable.returnType, null, null, 'C',
         allowTypeParameters: true);
     expect(executable.returnType.typeArguments, hasLength(2));
     {
       UnlinkedTypeRef typeRef = executable.returnType.typeArguments[0];
       checkParamTypeRef(typeRef, 2);
     }
     {
       UnlinkedTypeRef typeRef = executable.returnType.typeArguments[1];
       checkParamTypeRef(typeRef, 1);
@@ skipping 89 matching lines @@
         '''
 part of my.lib;
 
 class C {}
 enum E { v }
 var v;
 f() {}
 typedef F();
 ''');
     serializeLibraryText('library my.lib; part "part1.dart";');
-    expect(findClass('C', failIfAbsent: true).unit, 1);
-    expect(findEnum('E', failIfAbsent: true).unit, 1);
-    expect(findVariable('v', failIfAbsent: true).unit, 1);
-    expect(findExecutable('f', failIfAbsent: true).unit, 1);
-    expect(findTypedef('F', failIfAbsent: true).unit, 1);
+    PrelinkedUnit unit = lib.units[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(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');
-    expect(e.unit, 0);
   }
 
   test_enum_order() {
     UnlinkedEnum e = serializeEnumText('enum E { v1, v2 }');
     expect(e.values, hasLength(2));
     expect(e.values[0].name, 'v1');
     expect(e.values[1].name, 'v2');
   }
 
   test_executable_abstract() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f(); }').executables[0];
     expect(executable.isAbstract, isTrue);
   }
 
   test_executable_concrete() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.unit, 0);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
@@ skipping 13 matching lines @@
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
     checkDynamicTypeRef(executable.returnType);
     expect(executable.hasImplicitReturnType, isTrue);
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_member_function() {
-    UnlinkedExecutable executable =
-        findExecutable('f', cls: serializeClassText('class C { f() {} }'));
+    UnlinkedExecutable executable = findExecutable('f',
+        executables: serializeClassText('class C { f() {} }').executables);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
   }
 
   test_executable_member_function_explicit_return() {
     UnlinkedExecutable executable = findExecutable('f',
-        cls: serializeClassText('class C { dynamic f() => null; }'));
+        executables:
+            serializeClassText('class C { dynamic f() => null; }').executables);
     expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_executable_member_getter() {
     UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
     UnlinkedExecutable executable =
-        findExecutable('f', cls: cls, failIfAbsent: true);
+        findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
-    expect(findVariable('f', cls: cls), isNull);
-    expect(findExecutable('f=', cls: cls), isNull);
+    expect(findVariable('f', variables: cls.fields), isNull);
+    expect(findExecutable('f=', executables: cls.executables), isNull);
   }
 
   test_executable_member_setter() {
     UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
     UnlinkedExecutable executable =
-        findExecutable('f=', cls: cls, failIfAbsent: true);
+        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.setter);
     // For setters, hasImplicitReturnType is always false.
     expect(executable.hasImplicitReturnType, isFalse);
-    expect(findVariable('f', cls: cls), isNull);
-    expect(findExecutable('f', cls: cls), isNull);
+    expect(findVariable('f', variables: cls.fields), isNull);
+    expect(findExecutable('f', executables: cls.executables), isNull);
   }
 
   test_executable_member_setter_implicit_return() {
     UnlinkedClass cls = serializeClassText('class C { set f(value) {} }');
     UnlinkedExecutable executable =
-        findExecutable('f=', cls: cls, failIfAbsent: true);
+        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_name() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.name, 'f');
   }
 
   test_executable_no_flags() {
@@ skipping 193 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(unlinked.exports, hasLength(1));
-    expect(unlinked.exports[0].combinators, hasLength(1));
-    expect(unlinked.exports[0].combinators[0].shows, isEmpty);
-    expect(unlinked.exports[0].combinators[0].hides, hasLength(2));
-    checkCombinatorName(unlinked.exports[0].combinators[0].hides[0], 'Future');
-    checkCombinatorName(unlinked.exports[0].combinators[0].hides[1], '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));
+    checkCombinatorName(
+        definingUnit.unlinked.exports[0].combinators[0].hides[0], 'Future');
+    checkCombinatorName(
+        definingUnit.unlinked.exports[0].combinators[0].hides[1], 'Stream');
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
-    expect(unlinked.exports, hasLength(1));
-    expect(unlinked.exports[0].combinators, isEmpty);
+    expect(definingUnit.unlinked.exports, hasLength(1));
+    expect(definingUnit.unlinked.exports[0].combinators, isEmpty);
   }
 
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
-    expect(unlinked.exports, hasLength(1));
-    expect(unlinked.exports[0].combinators, hasLength(1));
-    expect(unlinked.exports[0].combinators[0].shows, hasLength(2));
-    expect(unlinked.exports[0].combinators[0].hides, isEmpty);
-    checkCombinatorName(unlinked.exports[0].combinators[0].shows[0], 'Future');
-    checkCombinatorName(unlinked.exports[0].combinators[0].shows[1], '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);
+    checkCombinatorName(
+        definingUnit.unlinked.exports[0].combinators[0].shows[0], 'Future');
+    checkCombinatorName(
+        definingUnit.unlinked.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(unlinked.exports, hasLength(1));
-    expect(unlinked.exports[0].uri, 'a.dart');
+    expect(definingUnit.unlinked.exports, hasLength(1));
+    expect(definingUnit.unlinked.exports[0].uri, 'a.dart');
   }
 
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
-    expect(findVariable('i', cls: cls), isNotNull);
-    expect(findExecutable('i', cls: cls), isNull);
-    expect(findExecutable('i=', cls: cls), isNull);
+    expect(findVariable('i', variables: cls.fields), isNotNull);
+    expect(findExecutable('i', executables: cls.executables), isNull);
+    expect(findExecutable('i=', executables: cls.executables), isNull);
   }
 
   test_field_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { final int i = 0; }').fields[0];
     expect(variable.isFinal, isTrue);
   }
 
   test_field_non_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { int i; }').fields[0];
     expect(variable.isFinal, isFalse);
   }
 
   test_generic_method_in_generic_class() {
     UnlinkedClass cls = serializeClassText(
         'class C<T, U> { void m<V, W>(T t, U u, V v, W w) {} }');
     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(unlinked.imports[0].isDeferred, isTrue);
+    expect(definingUnit.unlinked.imports[0].isDeferred, isTrue);
   }
 
   test_import_dependency() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
-    expect(unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports, hasLength(2));
     checkDependency(lib.importDependencies[0], 'dart:async', 'dart:async');
   }
 
   test_import_explicit() {
     serializeLibraryText('import "dart:core"; int i;');
-    expect(unlinked.imports, hasLength(1));
-    expect(unlinked.imports[0].isImplicit, isFalse);
+    expect(definingUnit.unlinked.imports, hasLength(1));
+    expect(definingUnit.unlinked.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(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].combinators, hasLength(1));
-    expect(unlinked.imports[0].combinators[0].shows, isEmpty);
-    expect(unlinked.imports[0].combinators[0].hides, hasLength(2));
-    checkCombinatorName(unlinked.imports[0].combinators[0].hides[0], 'Future');
-    checkCombinatorName(unlinked.imports[0].combinators[0].hides[1], 'Stream');
+    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));
+    checkCombinatorName(
+        definingUnit.unlinked.imports[0].combinators[0].hides[0], 'Future');
+    checkCombinatorName(
+        definingUnit.unlinked.imports[0].combinators[0].hides[1], 'Stream');
   }
 
   test_import_implicit() {
     // The implicit import of dart:core is represented in the model.
     serializeLibraryText('');
-    expect(unlinked.imports, hasLength(1));
+    expect(definingUnit.unlinked.imports, hasLength(1));
     checkDependency(lib.importDependencies[0], 'dart:core', 'dart:core');
-    expect(unlinked.imports[0].uri, isEmpty);
-    expect(unlinked.imports[0].prefix, 0);
-    expect(unlinked.imports[0].combinators, isEmpty);
-    expect(unlinked.imports[0].isImplicit, isTrue);
+    expect(definingUnit.unlinked.imports[0].uri, isEmpty);
+    expect(definingUnit.unlinked.imports[0].prefix, 0);
+    expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
+    expect(definingUnit.unlinked.imports[0].isImplicit, isTrue);
   }
 
   test_import_no_combinators() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
-    expect(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].combinators, isEmpty);
+    expect(definingUnit.unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
   }
 
   test_import_no_flags() {
     serializeLibraryText('import "dart:async"; Future x;');
-    expect(unlinked.imports[0].isImplicit, isFalse);
-    expect(unlinked.imports[0].isDeferred, isFalse);
+    expect(definingUnit.unlinked.imports[0].isImplicit, isFalse);
+    expect(definingUnit.unlinked.imports[0].isDeferred, isFalse);
   }
 
   test_import_non_deferred() {
     serializeLibraryText(
         'import "dart:async" as a; main() { print(a.Future); }');
-    expect(unlinked.imports[0].isDeferred, isFalse);
+    expect(definingUnit.unlinked.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(unlinked.imports[0].offset, libraryText.indexOf('import'));
+    expect(
+        definingUnit.unlinked.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(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].prefix, isNot(0));
-    expect(unlinked.prefixes[unlinked.imports[0].prefix].name, 'a');
+    expect(definingUnit.unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports[0].prefix, isNot(0));
+    expect(
+        unlinked.prefixes[definingUnit.unlinked.imports[0].prefix].name, 'a');
   }
 
   test_import_prefix_none() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
-    expect(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].prefix, 0);
-    expect(unlinked.prefixes[unlinked.imports[0].prefix].name, isEmpty);
+    expect(definingUnit.unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports[0].prefix, 0);
+    expect(unlinked.prefixes[definingUnit.unlinked.imports[0].prefix].name,
+        isEmpty);
   }
 
   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(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].combinators, hasLength(1));
-    expect(unlinked.imports[0].combinators[0].shows, hasLength(2));
-    expect(unlinked.imports[0].combinators[0].hides, isEmpty);
-    checkCombinatorName(unlinked.imports[0].combinators[0].shows[0], 'Future');
-    checkCombinatorName(unlinked.imports[0].combinators[0].shows[1], 'Stream');
+    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);
+    checkCombinatorName(
+        definingUnit.unlinked.imports[0].combinators[0].shows[0], 'Future');
+    checkCombinatorName(
+        definingUnit.unlinked.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(unlinked.imports, hasLength(2));
-    expect(unlinked.imports[0].uri, 'dart:async');
+    expect(definingUnit.unlinked.imports, hasLength(2));
+    expect(definingUnit.unlinked.imports[0].uri, 'dart:async');
   }
 
   test_library_named() {
     String text = 'library foo.bar;';
     serializeLibraryText(text);
-    expect(unlinked.name, 'foo.bar');
+    expect(definingUnit.unlinked.libraryName, 'foo.bar');
   }
 
   test_library_unnamed() {
     serializeLibraryText('');
-    expect(unlinked.name, isEmpty);
-  }
-
-  test_nested_elements_have_no_part() {
-    addNamedSource(
-        '/part1.dart',
-        '''
-part of my.lib;
-
-class C {
-  var v;
-  f() {}
-}
-''');
-    serializeLibraryText('library my.lib; part "part1.dart";');
-    UnlinkedClass cls = findClass('C');
-    expect(findVariable('v', cls: cls).unit, 0);
-    expect(findExecutable('f', cls: cls).unit, 0);
+    expect(definingUnit.unlinked.libraryName, isEmpty);
   }
 
   test_parts_defining_compilation_unit() {
     serializeLibraryText('');
-    expect(unlinked.units, hasLength(1));
-    expect(unlinked.units[0].uri, isEmpty);
+    expect(lib.units, hasLength(1));
+    expect(definingUnit.unlinked.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(unlinked.units, hasLength(2));
-    expect(unlinked.units[1].uri, 'part1.dart');
+    expect(lib.units, hasLength(2));
+    expect(definingUnit.unlinked.parts, hasLength(1));
+    expect(definingUnit.unlinked.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 49 matching lines @@
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
   test_type_reference_to_class_argument() {
     UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
     {
       UnlinkedTypeRef typeRef =
-          findVariable('t', cls: cls, failIfAbsent: true).type;
+          findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
     {
       UnlinkedTypeRef typeRef =
-          findVariable('u', cls: cls, failIfAbsent: true).type;
+          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 89 matching lines @@
   }
 
   test_type_unresolved() {
     UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.name, 'F');
-    expect(type.unit, 0);
   }
 
   test_typedef_param_none() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.parameters, isEmpty);
   }
 
   test_typedef_param_order() {
     UnlinkedTypedef type = serializeTypedefText('typedef F(x, y);');
     expect(type.parameters, hasLength(2));
@@ skipping 55 matching lines @@
   test_variable_implicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('var v;');
     checkDynamicTypeRef(variable.type);
     expect(variable.hasImplicitType, isTrue);
   }
 
   test_variable_name() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.name, 'i');
-    expect(variable.unit, 0);
   }
 
   test_variable_no_flags() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.isStatic, isFalse);
     expect(variable.isConst, isFalse);
     expect(variable.isFinal, isFalse);
   }
 
@@ skipping 27 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');
   }
 }