Downplay the distinction between linked and prelinked summaries.

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/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Serialize all the elements in [lib] to a summary using [ctx] as the context
  * for building the summary, and using [typeProvider] to find built-in types.
  */
 LibrarySerializationResult serializeLibrary(
     LibraryElement lib, TypeProvider typeProvider) {
   var serializer = new _LibrarySerializer(lib, typeProvider);
-  PrelinkedLibraryBuilder prelinked = serializer.serializeLibrary();
+  LinkedLibraryBuilder linked = serializer.serializeLibrary();
   return new LibrarySerializationResult(
-      prelinked, serializer.unlinkedUnits, serializer.unitUris);
+      linked, serializer.unlinkedUnits, serializer.unitUris);
 }
 
 /**
  * Data structure holding the result of serializing a [LibraryElement].
  */
 class LibrarySerializationResult {
   /**
-   * Pre-linked information the given library.
+   * Linked information the given library.
    */
-  final PrelinkedLibraryBuilder prelinked;
+  final LinkedLibraryBuilder linked;
 
   /**
    * Unlinked information for the compilation units constituting the library.
    * The zeroth entry in the list is the defining compilation unit; the
    * remaining entries are the parts, in the order listed in the defining
    * compilation unit's part declarations.
    */
   final List<UnlinkedUnitBuilder> unlinkedUnits;
 
   /**
    * Absolute URI of each compilation unit appearing in the library.
    */
   final List<String> unitUris;
 
-  LibrarySerializationResult(this.prelinked, this.unlinkedUnits, this.unitUris);
+  LibrarySerializationResult(this.linked, this.unlinkedUnits, this.unitUris);
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single library.`
  */
 class _LibrarySerializer {
   /**
    * 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 [PrelinkedLibrary.units].
+   * List of objects which should be written to [LinkedLibrary.units].
    */
-  final List<PrelinkedUnitBuilder> prelinkedUnits = <PrelinkedUnitBuilder>[];
+  final List<LinkedUnitBuilder> linkedUnits = <LinkedUnitBuilder>[];
 
   /**
-   * List of unlinked units corresponding to the pre-linked units in
-   * [prelinkedUnits],
+   * List of unlinked units corresponding to the linked units in
+   * [linkedUnits],
    */
   final List<UnlinkedUnitBuilder> unlinkedUnits = <UnlinkedUnitBuilder>[];
 
   /**
    * List of absolute URIs of the compilation units in the library.
    */
   final List<String> unitUris = <String>[];
 
   /**
    * 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].
+   * written to [LinkedLibrary.dependencies].
    */
-  final List<PrelinkedDependencyBuilder> dependencies =
-      <PrelinkedDependencyBuilder>[];
+  final List<LinkedDependencyBuilder> dependencies =
+      <LinkedDependencyBuilder>[];
 
   /**
-   * The prelinked portion of the "imports table".  This is the list of ints
-   * which should be written to [PrelinkedLibrary.imports].
+   * The linked portion of the "imports table".  This is the list of ints
+   * which should be written to [LinkedLibrary.imports].
    */
-  final List<int> prelinkedImports = <int>[];
+  final List<int> linkedImports = <int>[];
 
   /**
    * Map from [Element] to the index of the entry in the "references table"
    * that refers to it.
    */
   final Map<Element, int> referenceMap = <Element, int>{};
 
   /**
    * The unlinked portion of the "references table".  This is the list of
    * objects which should be written to [UnlinkedUnit.references].
    */
   List<UnlinkedReferenceBuilder> unlinkedReferences;
 
   /**
-   * The prelinked portion of the "references table".  This is the list of
-   * objects which should be written to [PrelinkedUnit.references].
+   * The linked portion of the "references table".  This is the list of
+   * objects which should be written to [LinkedUnit.references].
    */
-  List<PrelinkedReferenceBuilder> prelinkedReferences;
+  List<LinkedReferenceBuilder> linkedReferences;
 
   //final Map<String, int> prefixIndices = <String, int>{};
 
   /**
    * Index into the "references table" representing an unresolved reference, if
    * such an index exists.  `null` if no such entry has been made in the
    * references table yet.
    */
   int unresolvedReferenceIndex = null;
 
   /**
    * Set of libraries which have been seen so far while visiting the transitive
    * closure of exports.
    */
   final Set<LibraryElement> librariesAddedToTransitiveExportClosure =
       new Set<LibraryElement>();
 
   /**
    * Map from imported element to the prefix which may be used to refer to that
    * element; elements for which no prefix is needed are absent from this map.
    */
   final Map<Element, PrefixElement> prefixMap = <Element, PrefixElement>{};
 
   _LibrarySerializer(this.libraryElement, this.typeProvider) {
-    dependencies.add(new PrelinkedDependencyBuilder());
+    dependencies.add(new LinkedDependencyBuilder());
     dependencyMap[libraryElement] = 0;
   }
 
   /**
    * Retrieve the library element for `dart:core`.
    */
   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();
     referenceMap.clear();
     unlinkedReferences = <UnlinkedReferenceBuilder>[
       new UnlinkedReferenceBuilder()
     ];
-    prelinkedReferences = <PrelinkedReferenceBuilder>[
-      new PrelinkedReferenceBuilder(kind: PrelinkedReferenceKind.classOrEnum)
+    linkedReferences = <LinkedReferenceBuilder>[
+      new LinkedReferenceBuilder(kind: ReferenceKind.classOrEnum)
     ];
     List<UnlinkedPublicNameBuilder> names = <UnlinkedPublicNameBuilder>[];
     for (PropertyAccessorElement accessor in element.accessors) {
       if (accessor.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
-            kind: PrelinkedReferenceKind.topLevelPropertyAccessor,
+            kind: ReferenceKind.topLevelPropertyAccessor,
             name: accessor.name,
             numTypeParameters: accessor.typeParameters.length));
       }
     }
     for (ClassElement cls in element.types) {
       if (cls.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
-            kind: PrelinkedReferenceKind.classOrEnum,
+            kind: ReferenceKind.classOrEnum,
             name: cls.name,
             numTypeParameters: cls.typeParameters.length));
       }
     }
     for (ClassElement enm in element.enums) {
       if (enm.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
-            kind: PrelinkedReferenceKind.classOrEnum, name: enm.name));
+            kind: ReferenceKind.classOrEnum, name: enm.name));
       }
     }
     for (FunctionElement function in element.functions) {
       if (function.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
-            kind: PrelinkedReferenceKind.topLevelFunction,
+            kind: ReferenceKind.topLevelFunction,
             name: function.name,
             numTypeParameters: function.typeParameters.length));
       }
     }
     for (FunctionTypeAliasElement typedef in element.functionTypeAliases) {
       if (typedef.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
-            kind: PrelinkedReferenceKind.typedef,
+            kind: ReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
         b.libraryNameOffset = libraryElement.nameOffset;
         b.libraryNameLength = libraryElement.nameLength;
         b.libraryDocumentationComment = serializeDocumentation(libraryElement);
@@ skipping 36 matching lines @@
         PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           assert(!variable.isSynthetic);
           variables.add(serializeVariable(variable));
         }
       }
     }
     b.variables = variables;
     b.references = unlinkedReferences;
     unlinkedUnits.add(b);
-    prelinkedUnits
-        .add(new PrelinkedUnitBuilder(references: prelinkedReferences));
+    linkedUnits.add(new LinkedUnitBuilder(references: linkedReferences));
     unitUris.add(element.source.uri.toString());
     unlinkedReferences = null;
-    prelinkedReferences = null;
+    linkedReferences = null;
   }
 
   /**
    * Add [exportedLibrary] (and the transitive closure of all libraries it
-   * exports) to the dependency table ([PrelinkedLibrary.dependencies]).
+   * exports) to the dependency table ([LinkedLibrary.dependencies]).
    */
   void addTransitiveExportClosure(LibraryElement exportedLibrary) {
     if (librariesAddedToTransitiveExportClosure.add(exportedLibrary)) {
       serializeDependency(exportedLibrary);
       for (LibraryElement transitiveExport
           in exportedLibrary.exportedLibraries) {
         addTransitiveExportClosure(transitiveExport);
       }
     }
   }
@@ skipping 102 matching lines @@
     if (combinator is ShowElementCombinator) {
       b.shows = combinator.shownNames;
     } else if (combinator is HideElementCombinator) {
       b.hides = combinator.hiddenNames;
     }
     return b;
   }
 
   /**
    * Return the index of the entry in the dependency table
-   * ([PrelinkedLibrary.dependencies]) for the given [dependentLibrary].  A new
+   * ([LinkedLibrary.dependencies]) for the given [dependentLibrary].  A new
    * entry is added to the table if necessary to satisfy the request.
    */
   int serializeDependency(LibraryElement dependentLibrary) {
     return dependencyMap.putIfAbsent(dependentLibrary, () {
       int index = dependencies.length;
       List<String> parts = dependentLibrary.parts
           .map((CompilationUnitElement e) => e.source.uri.toString())
           .toList();
-      dependencies.add(new PrelinkedDependencyBuilder(
+      dependencies.add(new LinkedDependencyBuilder(
           uri: dependentLibrary.source.uri.toString(), parts: parts));
       return index;
     });
   }
 
   /**
    * Serialize documentation from the given [element], creating an
    * [UnlinkedDocumentationComment].
    *
    * If [element] has no documentation, `null` is returned.
    */
   UnlinkedDocumentationCommentBuilder serializeDocumentation(Element element) {
     if (element.documentationComment == null) {
       return null;
     }
     return new UnlinkedDocumentationCommentBuilder(
         text: element.documentationComment,
         offset: element.docRange.offset,
         length: element.docRange.length);
   }
 
   /**
    * Return the index of the entry in the references table
-   * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references])
+   * ([UnlinkedLibrary.references] and [LinkedLibrary.references])
    * representing the pseudo-type `dynamic`.
    */
   int serializeDynamicReference() => 0;
 
   /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
     b.name = enumElement.name;
@@ skipping 70 matching lines @@
       ExportElement exportElement) {
     addTransitiveExportClosure(exportElement.exportedLibrary);
     UnlinkedExportPublicBuilder b = new UnlinkedExportPublicBuilder();
     b.uri = exportElement.uri;
     b.combinators = exportElement.combinators.map(serializeCombinator).toList();
     return b;
   }
 
   /**
    * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
-   * Also, add pre-linked information about it to the [prelinkedImports] list.
+   * Also, add linked information about it to the [linkedImports] list.
    */
   UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder();
     b.isDeferred = importElement.isDeferred;
     b.offset = importElement.nameOffset;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
       b.prefixReference = serializePrefix(importElement.prefix);
       b.prefixOffset = importElement.prefix.nameOffset;
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       b.uri = importElement.uri;
       b.uriOffset = importElement.uriOffset;
       b.uriEnd = importElement.uriEnd;
     }
     addTransitiveExportClosure(importElement.importedLibrary);
-    prelinkedImports.add(serializeDependency(importElement.importedLibrary));
+    linkedImports.add(serializeDependency(importElement.importedLibrary));
     return b;
   }
 
   /**
-   * Serialize the whole library element into a [PrelinkedLibrary].  Should be
+   * Serialize the whole library element into a [LinkedLibrary].  Should be
    * called exactly once for each instance of [_LibrarySerializer].
    *
    * The unlinked compilation units are stored in [unlinkedUnits], and their
    * absolute URIs are stored in [unitUris].
    */
-  PrelinkedLibraryBuilder serializeLibrary() {
+  LinkedLibraryBuilder serializeLibrary() {
     computePrefixMap();
-    PrelinkedLibraryBuilder pb = new PrelinkedLibraryBuilder();
+    LinkedLibraryBuilder pb = new LinkedLibraryBuilder();
     addCompilationUnitElements(libraryElement.definingCompilationUnit, 0);
     for (int i = 0; i < libraryElement.parts.length; i++) {
       addCompilationUnitElements(libraryElement.parts[i], i + 1);
     }
-    pb.units = prelinkedUnits;
+    pb.units = linkedUnits;
     pb.dependencies = dependencies;
-    pb.importDependencies = prelinkedImports;
+    pb.importDependencies = linkedImports;
     List<String> exportedNames =
         libraryElement.exportNamespace.definedNames.keys.toList();
     exportedNames.sort();
-    List<PrelinkedExportNameBuilder> exportNames =
-        <PrelinkedExportNameBuilder>[];
+    List<LinkedExportNameBuilder> exportNames = <LinkedExportNameBuilder>[];
     for (String name in exportedNames) {
       if (libraryElement.publicNamespace.definedNames.containsKey(name)) {
         continue;
       }
       Element element = libraryElement.exportNamespace.get(name);
       LibraryElement dependentLibrary = element.library;
       CompilationUnitElement unitElement =
           element.getAncestor((Element e) => e is CompilationUnitElement);
       int unit = dependentLibrary.units.indexOf(unitElement);
       assert(unit != -1);
-      PrelinkedReferenceKind kind;
+      ReferenceKind kind;
       if (element is PropertyAccessorElement) {
-        kind = PrelinkedReferenceKind.topLevelPropertyAccessor;
+        kind = ReferenceKind.topLevelPropertyAccessor;
       } else if (element is FunctionTypeAliasElement) {
-        kind = PrelinkedReferenceKind.typedef;
+        kind = ReferenceKind.typedef;
       } else if (element is ClassElement) {
-        kind = PrelinkedReferenceKind.classOrEnum;
+        kind = ReferenceKind.classOrEnum;
       } else if (element is FunctionElement) {
-        kind = PrelinkedReferenceKind.topLevelFunction;
+        kind = ReferenceKind.topLevelFunction;
       } else {
         throw new Exception('Unexpected element kind: ${element.runtimeType}');
       }
-      exportNames.add(new PrelinkedExportNameBuilder(
+      exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 
   /**
@@ skipping 31 matching lines @@
       b.hasImplicitType = parameter.hasImplicitType;
     }
     return b;
   }
 
   /**
    * Serialize the given [prefix] into an index into the references table.
    */
   int serializePrefix(PrefixElement element) {
     return referenceMap.putIfAbsent(element, () {
-      assert(unlinkedReferences.length == prelinkedReferences.length);
+      assert(unlinkedReferences.length == linkedReferences.length);
       int index = unlinkedReferences.length;
       unlinkedReferences.add(new UnlinkedReferenceBuilder(name: element.name));
-      prelinkedReferences.add(
-          new PrelinkedReferenceBuilder(kind: PrelinkedReferenceKind.prefix));
+      linkedReferences
+          .add(new LinkedReferenceBuilder(kind: ReferenceKind.prefix));
       return index;
     });
   }
 
   /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
@@ skipping 36 matching lines @@
       LibraryElement dependentLibrary = element.library;
       if (dependentLibrary == null) {
         assert(type.isDynamic);
         if (type is UndefinedTypeImpl) {
           b.reference = serializeUnresolvedReference();
         } else {
           b.reference = serializeDynamicReference();
         }
       } else {
         b.reference = referenceMap.putIfAbsent(element, () {
-          assert(unlinkedReferences.length == prelinkedReferences.length);
+          assert(unlinkedReferences.length == linkedReferences.length);
           CompilationUnitElement unitElement =
               element.getAncestor((Element e) => e is CompilationUnitElement);
           int unit = dependentLibrary.units.indexOf(unitElement);
           assert(unit != -1);
           int numTypeParameters = 0;
           if (element is TypeParameterizedElement) {
             numTypeParameters = element.typeParameters.length;
           }
           // Figure out a prefix that may be used to refer to the given type.
           // TODO(paulberry): to avoid subtle relinking inconsistencies we
           // should use the actual prefix from the AST (a given type may be
           // reachable via multiple prefixes), but sadly, this information is
           // not recorded in the element model.
           int prefixReference = 0;
           PrefixElement prefix = prefixMap[element];
           if (prefix != null) {
             prefixReference = serializePrefix(prefix);
           }
           int index = unlinkedReferences.length;
           unlinkedReferences.add(new UnlinkedReferenceBuilder(
               name: element.name, prefixReference: prefixReference));
-          prelinkedReferences.add(new PrelinkedReferenceBuilder(
+          linkedReferences.add(new LinkedReferenceBuilder(
               dependency: serializeDependency(dependentLibrary),
               kind: element is FunctionTypeAliasElement
-                  ? PrelinkedReferenceKind.typedef
-                  : PrelinkedReferenceKind.classOrEnum,
+                  ? ReferenceKind.typedef
+                  : ReferenceKind.classOrEnum,
               unit: unit,
               numTypeParameters: numTypeParameters));
           return index;
         });
       }
       List<DartType> typeArguments;
       if (type is InterfaceType) {
         typeArguments = type.typeArguments;
       } else if (type is FunctionType) {
         typeArguments = type.typeArguments;
       }
       if (typeArguments != null &&
           typeArguments.any((DartType argument) => !argument.isDynamic)) {
         b.typeArguments = typeArguments
             .map((DartType t) => serializeTypeRef(t, context))
             .toList();
       }
     }
     return b;
   }
 
   /**
    * Return the index of the entry in the references table
-   * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references]) used for
+   * ([UnlinkedLibrary.references] and [LinkedLibrary.references]) used for
    * unresolved references.  A new entry is added to the table if necessary to
    * satisfy the request.
    */
   int serializeUnresolvedReference() {
     // TODO(paulberry): in order for relinking to work, we need to record the
     // name and prefix of the unresolved symbol.  This is not (yet) encoded in
     // the element model.  For the moment we use a name that can't possibly
     // ever exist.
     if (unresolvedReferenceIndex == null) {
-      assert(unlinkedReferences.length == prelinkedReferences.length);
+      assert(unlinkedReferences.length == linkedReferences.length);
       unresolvedReferenceIndex = unlinkedReferences.length;
       unlinkedReferences
           .add(new UnlinkedReferenceBuilder(name: '*unresolved*'));
-      prelinkedReferences.add(new PrelinkedReferenceBuilder(
-          kind: PrelinkedReferenceKind.unresolved));
+      linkedReferences
+          .add(new LinkedReferenceBuilder(kind: ReferenceKind.unresolved));
     }
     return unresolvedReferenceIndex;
   }
 
   /**
    * Serialize the given [variable], creating an [UnlinkedVariable].
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.name = variable.name;
     b.nameOffset = variable.nameOffset;
     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;
     b.documentationComment = serializeDocumentation(variable);
     return b;
   }
 }