Organize summary declarations by unit rather than by library.

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 61 matching lines @@
    */
   String uri;
 }
 
 /**
  * Pre-linked summary of a library.
  */
 @topLevel
 class PrelinkedLibrary {
   /**
+   * The pre-linked summary of all the compilation units constituting the
+   * library.  The summary of the defining compilation unit is listed first,
+   * followed by the summary of each part, in the order of the `part`
+   * declarations in the defining compilation unit.
+   */
+  List<PrelinkedUnit> units;
+
+  /**
    * The unlinked library summary.
    */
   UnlinkedLibrary unlinked;
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
    * representing the library itself (it is also used for "dynamic").
    *
@@ skipping 63 matching lines @@
    */
   other,
 
   /**
    * The entity being referred to does not exist.
    */
   unresolved
 }
 
 /**
+ * Pre-linked summary of a compilation unit.
+ */
+class PrelinkedUnit {
+  /**
+   * The unlinked summary of the compilation unit
+   */
+  UnlinkedUnit unlinked;
+}
+
+/**
  * Unlinked summary information about a class declaration.
  */
 class UnlinkedClass {
   /**
    * Name of the class.
    */
   String name;
 
   /**
-   * Index into [UnlinkedLibrary.units] indicating which compilation unit the
-   * class is declared in.
-   */
-  @informative
-  int unit;
-
-  /**
    * Type parameters of the class, if any.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
   UnlinkedTypeRef supertype;
@@ skipping 62 matching lines @@
 class UnlinkedEnum {
   /**
    * Name of the enum type.
    */
   String name;
 
   /**
    * Values listed in the enum declaration, in declaration order.
    */
   List<UnlinkedEnumValue> values;
-
-  /**
-   * Index into [UnlinkedLibrary.units] indicating which compilation unit the
-   * enum is declared in.
-   */
-  @informative
-  int unit;
 }
 
 /**
  * Unlinked summary information about a single enumerated value in an enum
  * declaration.
  */
 class UnlinkedEnumValue {
   /**
    * Name of the enumerated value.
    */
   String name;
 }
 
 /**
  * Unlinked summary information about a function, method, getter, or setter
  * declaration.
  */
 class UnlinkedExecutable {
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   String name;
 
   /**
-   * Index into [UnlinkedLibrary.units] indicating which compilation unit the
-   * executable is declared in.  Zero for executables which are nested inside
-   * another declaration (i.e. local functions and method declarations).
-   */
-  @informative
-  int unit;
-
-  /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void`.  Note that when strong mode is enabled, the actual return type may
    * be different due to type inference.
    */
@@ skipping 126 matching lines @@
 /**
  * Unlinked summary of an entire library.
  */
 class UnlinkedLibrary {
   /**
    * Top level and prefixed names referred to by this library.
    */
   List<UnlinkedReference> references;
 
   /**
-   * Information about the units constituting this library.  The first unit
-   * listed is always the defining compilation unit.  The remaining units are
-   * listed in the order of their corresponding `part` declarations.
-   */
-  List<UnlinkedUnit> units;
-
-  /**
-   * Name of the library (from a "library" declaration, if present).
-   */
-  String name;
-
-  /**
-   * Classes declared in the library.
-   */
-  List<UnlinkedClass> classes;
-
-  /**
-   * Enums declared in the library.
-   */
-  List<UnlinkedEnum> enums;
-
-  /**
-   * Top level executable objects (functions, getters, and setters) declared in
-   * the library.
-   */
-  List<UnlinkedExecutable> executables;
-
-  /**
-   * Export declarations in the library.
-   */
-  List<UnlinkedExport> exports;
-
-  /**
-   * Import declarations in the library.
-   */
-  List<UnlinkedImport> imports;
-
-  /**
-   * Typedefs declared in the library.
-   */
-  List<UnlinkedTypedef> typedefs;
-
-  /**
-   * Top level variables declared in the library.
-   */
-  List<UnlinkedVariable> variables;
-
-  /**
    * 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 52 matching lines @@
    * Parameter is positional optional (enclosed in `[]`)
    */
   positional,
 
   /**
    * Parameter is named optional (enclosed in `{}`)
    */
   named
 }
 
+/**
+ * Unlinked summary information about a part declaration.
+ */
+class UnlinkedPart {
+  /**
+   * String used in the compilation unit to refer to the part file.
+   */
+  String uri;
+}
+
 class UnlinkedPrefix {
   /**
    * The name of the prefix, or the empty string in the case of the
    * pseudo-prefix which represents "no prefix".
    */
   String name;
 }
 
 /**
  * Unlinked summary information about a name referred to in one library that
@@ skipping 16 matching lines @@
 /**
  * Unlinked summary information about a typedef declaration.
  */
 class UnlinkedTypedef {
   /**
    * Name of the typedef.
    */
   String name;
 
   /**
-   * Index into [UnlinkedLibrary.units] indicating which compilation unit the
-   * typedef is declared in.
-   */
-  @informative
-  int unit;
-
-  /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
   UnlinkedTypeRef returnType;
 
   /**
@@ skipping 64 matching lines @@
 
 /**
  * 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].
  */
 class UnlinkedUnit {
   /**
-   * String used in the defining compilation unit to reference the part file.
-   * Empty for the defining compilation unit itself.
+   * Name of the library (from a "library" declaration, if present).
    */
-  String uri;
+  String libraryName;
+
+  /**
+   * Classes declared in the compilation unit.
+   */
+  List<UnlinkedClass> classes;
+
+  /**
+   * Enums declared in the compilation unit.
+   */
+  List<UnlinkedEnum> enums;
+
+  /**
+   * Top level executable objects (functions, getters, and setters) declared in
+   * the compilation unit.
+   */
+  List<UnlinkedExecutable> executables;
+
+  /**
+   * Export declarations in the compilation unit.
+   */
+  List<UnlinkedExport> exports;
+
+  /**
+   * Import declarations in the compilation unit.
+   */
+  List<UnlinkedImport> imports;
+
+  /**
+   * Part declarations in the compilation unit.
+   */
+  List<UnlinkedPart> parts;
+
+  /**
+   * Typedefs declared in the compilation unit.
+   */
+  List<UnlinkedTypedef> typedefs;
+
+  /**
+   * Top level variables declared in the compilation unit.
+   */
+  List<UnlinkedVariable> variables;
 }
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 class UnlinkedVariable {
   /**
    * Name of the variable.
    */
   String name;
 
   /**
-   * Index into [UnlinkedLibrary.units] indicating which compilation unit the
-   * variable is declared in.  Zero for variables which are nested inside
-   * another declaration (i.e. local variables and fields).
-   */
-  @informative
-  int unit;
-
-  /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
   UnlinkedTypeRef type;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
    * Note that for top level variables, this flag is false, since they are not
    * declared using the `static` keyword (even though they are considered
    * static for semantic purposes).
    */
   bool isStatic;
 
   /**
    * Indicates whether the variable is declared using the `final` keyword.
    */
   bool isFinal;
 
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   bool isConst;
 
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   bool hasImplicitType;
 }