Move summary references into UnlinkedUnit and PrelinkedUnit.

pkg/analyzer/tool/summary/idl.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.
 
 /**
  * This file is an "idl" style description of the summary format.  It is not
  * executed directly; instead it is parsed and transformed into code that
  * implements the summary format.
  *
  * The code generation process introduces the following non-typical semantics:
@@ skipping 92 matching lines @@
   List<PrelinkedDependency> dependencies;
 
   /**
    * For each import in [UnlinkedLibrary.imports], an index into [dependencies]
    * of the library being imported.
    *
    * TODO(paulberry): if [dependencies] is removed, this can be removed as
    * well, since there will effectively be a one-to-one mapping.
    */
   List<int> importDependencies;
-
-  /**
-   * For each reference in [UnlinkedLibrary.references], information about how
-   * that reference is resolved.
-   */
-  List<PrelinkedReference> references;
 }
 
 /**
  * Information about the resolution of an [UnlinkedReference].
  */
 class PrelinkedReference {
   /**
    * Index into [UnlinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
@@ skipping 41 matching lines @@
 }
 
 /**
  * Pre-linked summary of a compilation unit.
  */
 class PrelinkedUnit {
   /**
    * The unlinked summary of the compilation unit
    */
   UnlinkedUnit unlinked;
+
+  /**
+   * For each reference in [UnlinkedUnit.references], information about how
+   * that reference is resolved.
+   */
+  List<PrelinkedReference> references;
 }
 
 /**
  * Unlinked summary information about a class declaration.
  */
 class UnlinkedClass {
   /**
    * Name of the class.
    */
   String name;
@@ skipping 241 matching lines @@
    * Indicates whether the import declaration is implicit.
    */
   bool isImplicit;
 }
 
 /**
  * Unlinked summary of an entire library.
  */
 class UnlinkedLibrary {
   /**
-   * Top level and prefixed names referred to by this library.
-   */
-  List<UnlinkedReference> references;
-
-  /**
    * Prefixes introduced by import declarations.  The first element in this
    * array is a pseudo-prefix used by references made with no prefix.
    */
   List<UnlinkedPrefix> prefixes;
 }
 
 /**
  * Unlinked summary information about a function parameter.
  */
 class UnlinkedParam {
@@ skipping 134 matching lines @@
    * null.
    */
   UnlinkedTypeRef bound;
 }
 
 /**
  * Unlinked summary information about a reference to a type.
  */
 class UnlinkedTypeRef {
   /**
-   * Index into [UnlinkedLibrary.references] for the type being referred to, or
+   * Index into [UnlinkedUnit.references] for the type being referred to, or
    * zero if this is a reference to a type parameter.
    *
    * Note that since zero is also a valid index into
-   * [UnlinkedLibrary.references], we cannot distinguish between references to
+   * [UnlinkedUnit.references], we cannot distinguish between references to
    * type parameters and references to types by checking [reference] against
    * zero.  To distinguish between references to type parameters and references
    * to types, check whether [paramReference] is zero.
    */
   int reference;
 
   /**
    * If this is a reference to a type parameter, one-based index into the list
    * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
    * Bruijn index conventions; that is, innermost parameters come first, and
@@ skipping 15 matching lines @@
   int paramReference;
 
   /**
    * If this is an instantiation of a generic type, the type arguments used to
    * instantiate it.  Trailing type arguments of type `dynamic` are omitted.
    */
   List<UnlinkedTypeRef> typeArguments;
 }
 
 /**
- * Unlinked summary information about a compilation unit ("part file").  Note
- * that since a declaration can be moved from one part file to another without
- * changing semantics, the declarations themselves aren't stored here; they are
- * stored in [UnlinkedLibrary] and they refer to [UnlinkedUnit]s via an index
- * into [UnlinkedLibrary.units].
+ * Unlinked summary information about a compilation unit ("part file").
  */
 class UnlinkedUnit {
   /**
    * Name of the library (from a "library" declaration, if present).
    */
   String libraryName;
 
   /**
+   * Top level and prefixed names referred to by this compilation unit.
+   */
+  List<UnlinkedReference> references;
+
+  /**
    * Classes declared in the compilation unit.
    */
   List<UnlinkedClass> classes;
 
   /**
    * Enums declared in the compilation unit.
    */
   List<UnlinkedEnum> enums;
 
   /**
@@ skipping 61 matching lines @@
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   bool isConst;
 
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   bool hasImplicitType;
 }