Organize summary declarations by unit rather than by library.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/builder.dart';
@@ skipping 17 matching lines @@
    * The library to be serialized.
    */
   final LibraryElement libraryElement;
 
   /**
    * The type provider.  This is used to locate the library for `dart:core`.
    */
   final TypeProvider typeProvider;
 
   /**
-   * List of objects which should be written to [UnlinkedLibrary.classes].
+   * List of objects which should be written to [PrelinkedLibrary.units].
    */
-  final List<UnlinkedClassBuilder> classes = <UnlinkedClassBuilder>[];
-
-  /**
-   * List of objects which should be written to [UnlinkedLibrary.enums].
-   */
-  final List<UnlinkedEnumBuilder> enums = <UnlinkedEnumBuilder>[];
-
-  /**
-   * List of objects which should be written to [UnlinkedLibrary.executables].
-   */
-  final List<UnlinkedExecutableBuilder> executables =
-      <UnlinkedExecutableBuilder>[];
-
-  /**
-   * List of objects which should be written to [UnlinkedLibrary.typedefs].
-   */
-  final List<UnlinkedTypedefBuilder> typedefs = <UnlinkedTypedefBuilder>[];
-
-  /**
-   * List of objects which should be written to [UnlinkedLibrary.units].
-   */
-  final List<UnlinkedUnitBuilder> units = <UnlinkedUnitBuilder>[];
-
-  /**
-   * List of objects which should be written to [UnlinkedLibrary.variables].
-   */
-  final List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
+  final List<PrelinkedUnitBuilder> units = <PrelinkedUnitBuilder>[];
 
   /**
    * Map from [LibraryElement] to the index of the entry in the "dependency
    * table" that refers to it.
    */
   final Map<LibraryElement, int> dependencyMap = <LibraryElement, int>{};
 
   /**
    * The "dependency table".  This is the list of objects which should be
    * written to [PrelinkedLibrary.dependencies].
    */
   final List<PrelinkedDependencyBuilder> dependencies =
       <PrelinkedDependencyBuilder>[];
 
   /**
-   * The unlinked portion of the "imports table".  This is the list of objects
-   * which should be written to [UnlinkedLibrary.imports].
-   */
-  final List<UnlinkedImportBuilder> unlinkedImports = <UnlinkedImportBuilder>[];
-
-  /**
    * The prelinked portion of the "imports table".  This is the list of ints
    * which should be written to [PrelinkedLibrary.imports].
    */
   final List<int> prelinkedImports = <int>[];
 
   /**
    * Map from prefix [String] to the index of the entry in the "prefix" table
    * that refers to it.  The empty prefix is not included in this map.
    */
   final Map<String, int> prefixMap = <String, int>{};
@@ skipping 64 matching lines @@
   LibraryElement get coreLibrary => typeProvider.objectType.element.library;
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
    * from the given compilation unit [element] to the library summary.
    * [unitNum] indicates the ordinal position of this compilation unit in the
    * library.
    */
   void addCompilationUnitElements(CompilationUnitElement element, int unitNum) {
     UnlinkedUnitBuilder b = new UnlinkedUnitBuilder(ctx);
-    if (element.uri != null) {
-      b.uri = element.uri;
+    if (unitNum == 0) {
+      // TODO(paulberry): we need to figure out a way to record library, part,

[Brian Wilkerson, 2015/12/14 23:44:35]

We might have discussed this already, but if not it might be worth asking
(off-line) whether we should do that, or whether we should only create summaries
for valid compilation units?

[Paul Berry, 2015/12/15 00:29:56]

Agreed, that would be a good discussion to have.  My instinct is that for now,
that's a totally reasonable restriction (since our initial use of summaries will
be for things like published packages and the SDK, where we can rely on the
compilation units being well-formed).  If, at some later date, we are
contemplating using summaries to speed up on-the-fly analysis of files that are
being actively edited, we may need to be more careful about the semantics of
summarizing invalid code.

(Incidentally, in our planning meeting today, I made a task for "Element model
enhancements (to support re-linking)").  It would probably be good to have this
discussion in the context of that task.

+      // import, and export declarations that appear in non-defining
+      // compilation units (even though such declarations are prohibited by the
+      // language), so that if the user makes code changes that cause a
+      // non-defining compilation unit to become a defining compilation unit,
+      // we can create a correct summary by simply re-linking.
+      if (libraryElement.name.isNotEmpty) {
+        b.libraryName = libraryElement.name;
+      }
+      b.exports = libraryElement.exports.map(serializeExport).toList();
+      b.imports = libraryElement.imports.map(serializeImport).toList();
+      b.parts = libraryElement.parts
+          .map(
+              (CompilationUnitElement e) => encodeUnlinkedPart(ctx, uri: e.uri))
+          .toList();
     }
-    units.add(b);
-    for (ClassElement cls in element.types) {
-      classes.add(serializeClass(cls, unitNum));
-    }
-    for (ClassElement e in element.enums) {
-      enums.add(serializeEnum(e, unitNum));
-    }
-    for (FunctionTypeAliasElement type in element.functionTypeAliases) {
-      typedefs.add(serializeTypedef(type, unitNum));
-    }
-    for (FunctionElement executable in element.functions) {
-      executables.add(serializeExecutable(executable, unitNum));
-    }
+    b.classes = element.types.map(serializeClass).toList();
+    b.enums = element.enums.map(serializeEnum).toList();
+    b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
+    List<UnlinkedExecutableBuilder> executables =
+        element.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in element.accessors) {
       if (!accessor.isSynthetic) {
-        executables.add(serializeExecutable(accessor, unitNum));
-      } else if (accessor.isGetter) {
+        executables.add(serializeExecutable(accessor));
+      }
+    }
+    b.executables = executables;
+    List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
+    for (PropertyAccessorElement accessor in element.accessors) {
+      if (accessor.isSynthetic && accessor.isGetter) {
         PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           assert(!variable.isSynthetic);
-          variables.add(serializeVariable(variable, unitNum));
+          variables.add(serializeVariable(variable));
         }
       }
     }
+    b.variables = variables;
+    units.add(encodePrelinkedUnit(ctx, unlinked: b));
   }
 
   /**
    * Add [exportedLibrary] (and the transitive closure of all libraries it
    * exports) to the dependency table ([PrelinkedLibrary.dependencies]).
    */
   void addTransitiveExportClosure(LibraryElement exportedLibrary) {
     if (librariesAddedToTransitiveExportClosure.add(exportedLibrary)) {
       serializeDependency(exportedLibrary);
       for (LibraryElement transitiveExport
@@ skipping 26 matching lines @@
           }
         }
         index += typeParameters.length;
       }
       context = context.enclosingElement;
     }
     throw new StateError('Unbound type parameter $type');
   }
 
   /**
-   * Serialize the given [classElement], which exists in the unit numbered
-   * [unitNum], creating an [UnlinkedClass].
+   * Serialize the given [classElement], creating an [UnlinkedClass].
    */
-  UnlinkedClassBuilder serializeClass(ClassElement classElement, int unitNum) {
+  UnlinkedClassBuilder serializeClass(ClassElement classElement) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder(ctx);
     b.name = classElement.name;
-    b.unit = unitNum;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype != null && !classElement.supertype.isObject) {
       b.supertype = serializeTypeRef(classElement.supertype, classElement);
     }
     b.mixins = classElement.mixins
         .map((InterfaceType t) => serializeTypeRef(t, classElement))
         .toList();
     b.interfaces = classElement.interfaces
         .map((InterfaceType t) => serializeTypeRef(t, classElement))
         .toList();
     List<UnlinkedVariableBuilder> fields = <UnlinkedVariableBuilder>[];
     List<UnlinkedExecutableBuilder> executables = <UnlinkedExecutableBuilder>[];
     for (ConstructorElement executable in classElement.constructors) {
       if (!executable.isSynthetic) {
-        executables.add(serializeExecutable(executable, 0));
+        executables.add(serializeExecutable(executable));
       }
     }
     for (MethodElement executable in classElement.methods) {
-      executables.add(serializeExecutable(executable, 0));
+      executables.add(serializeExecutable(executable));
     }
     for (PropertyAccessorElement accessor in classElement.accessors) {
       if (!accessor.isSynthetic) {
-        executables.add(serializeExecutable(accessor, 0));
+        executables.add(serializeExecutable(accessor));
       } else if (accessor.isGetter) {
         PropertyInducingElement field = accessor.variable;
         if (field != null && !field.isSynthetic) {
-          fields.add(serializeVariable(field, 0));
+          fields.add(serializeVariable(field));
         }
       }
     }
     b.fields = fields;
     b.executables = executables;
     b.isAbstract = classElement.isAbstract;
     b.isMixinApplication = classElement.isMixinApplication;
     return b;
   }
 
@@ skipping 43 matching lines @@
       assert(unlinkedReferences.length == prelinkedReferences.length);
       dynamicReferenceIndex = unlinkedReferences.length;
       unlinkedReferences.add(encodeUnlinkedReference(ctx));
       prelinkedReferences.add(encodePrelinkedReference(ctx,
           kind: PrelinkedReferenceKind.classOrEnum));
     }
     return dynamicReferenceIndex;
   }
 
   /**
-   * Serialize the given [enumElement], which exists in the unit numbered
-   * [unitNum], creating an [UnlinkedEnum].
+   * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
-  UnlinkedEnumBuilder serializeEnum(ClassElement enumElement, int unitNum) {
+  UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder(ctx);
     b.name = enumElement.name;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
         values.add(encodeUnlinkedEnumValue(ctx, name: field.name));
       }
     }
     b.values = values;
-    b.unit = unitNum;
     return b;
   }
 
   /**
-   * Serialize the given [executableElement], which exists in the unit numbered
-   * [unitNum], creating an [UnlinkedExecutable].  For elements declared inside
-   * a class, [unitNum] should be zero.
+   * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
-      ExecutableElement executableElement, int unitNum) {
-    if (executableElement.enclosingElement is ClassElement) {
-      assert(unitNum == 0);
-    }
+      ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder(ctx);
     b.name = executableElement.name;
-    b.unit = unitNum;
     if (!executableElement.type.returnType.isVoid) {
       b.returnType = serializeTypeRef(
           executableElement.type.returnType, executableElement);
     }
     b.typeParameters =
         executableElement.typeParameters.map(serializeTypeParam).toList();
     b.parameters =
         executableElement.type.parameters.map(serializeParam).toList();
     if (executableElement is PropertyAccessorElement) {
       if (executableElement.isGetter) {
@@ skipping 19 matching lines @@
    * Serialize the given [exportElement] into an [UnlinkedExport].
    */
   UnlinkedExportBuilder serializeExport(ExportElement exportElement) {
     UnlinkedExportBuilder b = new UnlinkedExportBuilder(ctx);
     b.uri = exportElement.uri;
     b.combinators = exportElement.combinators.map(serializeCombinator).toList();
     return b;
   }
 
   /**
-   * Serialize the given [importElement], adding information about it to
-   * the [unlinkedImports] and [prelinkedImports] lists.
+   * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
+   * Also, add pre-linked information about it to the [prelinkedImports] list.
    */
-  void serializeImport(ImportElement importElement) {
-    assert(unlinkedImports.length == prelinkedImports.length);
+  UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder(ctx);
     b.isDeferred = importElement.isDeferred;
     b.offset = importElement.nameOffset;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
       b.prefix = prefixMap.putIfAbsent(importElement.prefix.name, () {
         int index = prefixes.length;
         prefixes
             .add(encodeUnlinkedPrefix(ctx, name: importElement.prefix.name));
         return index;
       });
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       b.uri = importElement.uri;
     }
     addTransitiveExportClosure(importElement.importedLibrary);
-    unlinkedImports.add(b);
     prelinkedImports.add(serializeDependency(importElement.importedLibrary));
+    return b;
   }
 
   /**
    * Serialize the whole library element into a [PrelinkedLibrary].  Should be
    * called exactly once for each instance of [_LibrarySerializer].
    */
   PrelinkedLibraryBuilder serializeLibrary() {
     UnlinkedLibraryBuilder ub = new UnlinkedLibraryBuilder(ctx);
     PrelinkedLibraryBuilder pb = new PrelinkedLibraryBuilder(ctx);
-    if (libraryElement.name.isNotEmpty) {
-      ub.name = libraryElement.name;
-    }
-    for (ImportElement importElement in libraryElement.imports) {
-      serializeImport(importElement);
-    }
-    ub.exports = libraryElement.exports.map(serializeExport).toList();
     addCompilationUnitElements(libraryElement.definingCompilationUnit, 0);
     for (int i = 0; i < libraryElement.parts.length; i++) {
       addCompilationUnitElements(libraryElement.parts[i], i + 1);
     }
-    ub.classes = classes;
-    ub.enums = enums;
-    ub.executables = executables;
-    ub.imports = unlinkedImports;
     ub.prefixes = prefixes;
     ub.references = unlinkedReferences;
-    ub.typedefs = typedefs;
-    ub.units = units;
-    ub.variables = variables;
+    pb.units = units;
     pb.unlinked = ub;
     pb.dependencies = dependencies;
     pb.importDependencies = prelinkedImports;
     pb.references = prelinkedReferences;
     return pb;
   }
 
   /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
@@ skipping 20 matching lines @@
       }
       b.parameters = type.parameters.map(serializeParam).toList();
     } else {
       b.type = serializeTypeRef(type, parameter);
       b.hasImplicitType = parameter.hasImplicitType;
     }
     return b;
   }
 
   /**
-   * Serialize the given [typedefElement], which exists in the unit numbered
-   * [unitNum], creating an [UnlinkedTypedef].
+   * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
-      FunctionTypeAliasElement typedefElement, int unitNum) {
+      FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder(ctx);
     b.name = typedefElement.name;
-    b.unit = unitNum;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
       b.returnType =
           serializeTypeRef(typedefElement.returnType, typedefElement);
     }
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     return b;
   }
 
@@ skipping 77 matching lines @@
       assert(unlinkedReferences.length == prelinkedReferences.length);
       unresolvedReferenceIndex = unlinkedReferences.length;
       unlinkedReferences.add(encodeUnlinkedReference(ctx));
       prelinkedReferences.add(encodePrelinkedReference(ctx,
           kind: PrelinkedReferenceKind.unresolved));
     }
     return unresolvedReferenceIndex;
   }
 
   /**
-   * Serialize the given [variable], which exists in the unit numbered
-   * [unitNum], creating an [UnlinkedVariable].  For variables declared inside
-   * a class (i.e. fields), [unitNum] should be zero.
+   * Serialize the given [variable], creating an [UnlinkedVariable].
    */
-  UnlinkedVariableBuilder serializeVariable(
-      PropertyInducingElement variable, int unitNum) {
-    if (variable.enclosingElement is ClassElement) {
-      assert(unitNum == 0);
-    }
+  UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
-    b.unit = unitNum;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     return b;
   }
 }