Downplay the distinction between linked and prelinked summaries.

pkg/analyzer/lib/src/summary/prelink.dart

 // Copyright (c) 2016, 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.
 
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
- * Create a [PrelinkedLibraryBuilder] corresponding to the given
+ * Create a [LinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
  * Compilation units referenced by the defining compilation unit via `part`
  * declarations will be retrieved using [getPart].  Public namespaces for
  * libraries referenced by the defining compilation unit via `import`
  * declarations (and files reachable from them via `part` and `export`
  * declarations) will be retrieved using [getImport].
  */
-PrelinkedLibraryBuilder prelink(UnlinkedUnit definingUnit,
-    GetPartCallback getPart, GetImportCallback getImport) {
+LinkedLibraryBuilder prelink(UnlinkedUnit definingUnit, GetPartCallback getPart,
+    GetImportCallback getImport) {
   return new _Prelinker(definingUnit, getPart, getImport).prelink();
 }
 
 /**
  * Type of the callback used by the prelinker to obtain public namespace
  * information about libraries imported by the library to be prelinked (and
  * the transitive closure of parts and exports reachable from those libraries).
  * [relativeUri] should be interpreted relative to the defining compilation
  * unit of the library being prelinked.
  *
@@ skipping 17 matching lines @@
  */
 class _Meaning {
   /**
    * Which unit in the dependent library contains the declared entity.
    */
   final int unit;
 
   /**
    * The kind of entity being referred to.
    */
-  final PrelinkedReferenceKind kind;
+  final ReferenceKind kind;
 
   /**
    * Which of the dependencies of the library being prelinked contains the
    * declared entity.
    */
   final int dependency;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   final int numTypeParameters;
 
   _Meaning(this.unit, this.kind, this.dependency, this.numTypeParameters);
 
   /**
- * Encode this [_Meaning] as a [PrelinkedExportName], using the given [name].
+ * Encode this [_Meaning] as a [LinkedExportName], using the given [name].
  */
-  PrelinkedExportName encodeExportName(String name) {
-    return new PrelinkedExportNameBuilder(
+  LinkedExportName encodeExportName(String name) {
+    return new LinkedExportNameBuilder(
         name: name, dependency: dependency, unit: unit, kind: kind);
   }
 
 /**
-   * Encode this [_Meaning] as a [PrelinkedReference].
+   * Encode this [_Meaning] as a [LinkedReference].
    */
-  PrelinkedReferenceBuilder encodeReference() {
-    return new PrelinkedReferenceBuilder(
+  LinkedReferenceBuilder encodeReference() {
+    return new LinkedReferenceBuilder(
         unit: unit,
         kind: kind,
         dependency: dependency,
         numTypeParameters: numTypeParameters);
   }
 }
 
 /**
  * A [_Meaning] representing a prefix introduced by an import directive.
  */
 class _PrefixMeaning extends _Meaning {
   final Map<String, _Meaning> namespace = <String, _Meaning>{};
 
-  _PrefixMeaning() : super(0, PrelinkedReferenceKind.prefix, 0, 0);
+  _PrefixMeaning() : super(0, ReferenceKind.prefix, 0, 0);
 }
 
 /**
  * Helper class containing temporary data structures needed to prelink a single
  * library.
  *
  * Note: throughout this class, a `null` value for a relative URI represents
  * the defining compilation unit of the library being prelinked.
  */
 class _Prelinker {
   final UnlinkedUnit definingUnit;
   final GetPartCallback getPart;
   final GetImportCallback getImport;
 
   /**
    * Cache of values returned by [getImport].
    */
   final Map<String, UnlinkedPublicNamespace> importCache =
       <String, UnlinkedPublicNamespace>{};
 
   /**
    * Cache of values returned by [getPart].
    */
   final Map<String, UnlinkedUnit> partCache = <String, UnlinkedUnit>{};
 
   /**
    * Names defined inside the library being prelinked.
    */
   final Map<String, _Meaning> privateNamespace = <String, _Meaning>{
-    '': new _Meaning(0, PrelinkedReferenceKind.classOrEnum, 0, 0)
+    '': new _Meaning(0, ReferenceKind.classOrEnum, 0, 0)
   };
 
   /**
    * List of dependencies of the library being prelinked.  This will be output
-   * to [PrelinkedLibrary.dependencies].
+   * to [LinkedLibrary.dependencies].
    */
-  final List<PrelinkedDependencyBuilder> dependencies =
-      <PrelinkedDependencyBuilder>[new PrelinkedDependencyBuilder()];
+  final List<LinkedDependencyBuilder> dependencies = <LinkedDependencyBuilder>[
+    new LinkedDependencyBuilder()
+  ];
 
   /**
    * Map from the relative URI of a dependent library to the index of the
    * corresponding entry in [dependencies].
    */
   final Map<String, int> uriToDependency = <String, int>{null: 0};
 
   /**
    * List of public namespaces corresponding to each entry in [dependencies].
    */
@@ skipping 11 matching lines @@
    * information from all of its parts.
    */
   Map<String, _Meaning> aggregatePublicNamespace(String relativeUri) {
     if (uriToDependency.containsKey(relativeUri)) {
       return dependencyToPublicNamespace[uriToDependency[relativeUri]];
     }
     assert(dependencies.length == dependencyToPublicNamespace.length);
     int dependency = dependencies.length;
     uriToDependency[relativeUri] = dependency;
     List<String> unitUris = getUnitUris(relativeUri);
-    PrelinkedDependencyBuilder prelinkedDependency =
-        new PrelinkedDependencyBuilder(
-            uri: relativeUri, parts: unitUris.sublist(1));
-    dependencies.add(prelinkedDependency);
+    LinkedDependencyBuilder linkedDependency = new LinkedDependencyBuilder(
+        uri: relativeUri, parts: unitUris.sublist(1));
+    dependencies.add(linkedDependency);
 
     Map<String, _Meaning> aggregated = <String, _Meaning>{};
 
     for (int unitNum = 0; unitNum < unitUris.length; unitNum++) {
       String unitUri = unitUris[unitNum];
       UnlinkedPublicNamespace importedNamespace = getImportCached(unitUri);
       if (importedNamespace == null) {
         continue;
       }
       for (UnlinkedPublicName name in importedNamespace.names) {
@@ skipping 49 matching lines @@
 
   /**
    * Extract all the names defined in [unit] (which is the [unitNum]th unit in
    * the library being prelinked) and store them in [privateNamespace].
    * Excludes names introduced by `import` statements.
    */
   void extractPrivateNames(UnlinkedUnit unit, int unitNum) {
     for (UnlinkedClass cls in unit.classes) {
       privateNamespace.putIfAbsent(
           cls.name,
-          () => new _Meaning(unitNum, PrelinkedReferenceKind.classOrEnum, 0,
+          () => new _Meaning(unitNum, ReferenceKind.classOrEnum, 0,
               cls.typeParameters.length));
     }
     for (UnlinkedEnum enm in unit.enums) {
-      privateNamespace.putIfAbsent(
-          enm.name,
-          () =>
-              new _Meaning(unitNum, PrelinkedReferenceKind.classOrEnum, 0, 0));
+      privateNamespace.putIfAbsent(enm.name,
+          () => new _Meaning(unitNum, ReferenceKind.classOrEnum, 0, 0));
     }
     for (UnlinkedExecutable executable in unit.executables) {
       privateNamespace.putIfAbsent(
           executable.name,
           () => new _Meaning(
               unitNum,
               executable.kind == UnlinkedExecutableKind.functionOrMethod
-                  ? PrelinkedReferenceKind.topLevelFunction
-                  : PrelinkedReferenceKind.topLevelPropertyAccessor,
+                  ? ReferenceKind.topLevelFunction
+                  : ReferenceKind.topLevelPropertyAccessor,
               0,
               executable.typeParameters.length));
     }
     for (UnlinkedTypedef typedef in unit.typedefs) {
       privateNamespace.putIfAbsent(
           typedef.name,
-          () => new _Meaning(unitNum, PrelinkedReferenceKind.typedef, 0,
+          () => new _Meaning(unitNum, ReferenceKind.typedef, 0,
               typedef.typeParameters.length));
     }
     for (UnlinkedVariable variable in unit.variables) {
       privateNamespace.putIfAbsent(
           variable.name,
           () => new _Meaning(
-              unitNum, PrelinkedReferenceKind.topLevelPropertyAccessor, 0, 0));
+              unitNum, ReferenceKind.topLevelPropertyAccessor, 0, 0));
       if (!(variable.isConst || variable.isFinal)) {
         privateNamespace.putIfAbsent(
             variable.name + '=',
-            () => new _Meaning(unitNum,
-                PrelinkedReferenceKind.topLevelPropertyAccessor, 0, 0));
+            () => new _Meaning(
+                unitNum, ReferenceKind.topLevelPropertyAccessor, 0, 0));
       }
     }
   }
 
   /**
    * Filter the export namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], retaining only those names accepted by
    * [combinators], and store the resulting names in [result].  Names that
    * already exist in [result] are not overwritten.
    */
@@ skipping 59 matching lines @@
         targetNamespace = prefixMeaning.namespace;
       }
     } else {
       targetNamespace = privateNamespace;
     }
     filterExportNamespace(uri, import.combinators, targetNamespace);
     return uriToDependency[uri];
   }
 
   /**
-   * Produce a [PrelinkedUnit] for the given [unit], by resolving every one of
+   * Produce a [LinkedUnit] for the given [unit], by resolving every one of
    * its references.
    */
-  PrelinkedUnitBuilder linkUnit(UnlinkedUnit unit) {
+  LinkedUnitBuilder linkUnit(UnlinkedUnit unit) {
     if (unit == null) {
-      return new PrelinkedUnitBuilder();
+      return new LinkedUnitBuilder();
     }
     Map<int, Map<String, _Meaning>> prefixNamespaces =
         <int, Map<String, _Meaning>>{};
-    List<PrelinkedReferenceBuilder> references = <PrelinkedReferenceBuilder>[];
+    List<LinkedReferenceBuilder> references = <LinkedReferenceBuilder>[];
     for (int i = 0; i < unit.references.length; i++) {
       UnlinkedReference reference = unit.references[i];
       Map<String, _Meaning> namespace;
       if (reference.prefixReference != 0) {
         // Prefix references must always point backward.
         assert(reference.prefixReference < i);
         namespace = prefixNamespaces[reference.prefixReference];
         // Prefix references must always point to proper prefixes.
         assert(namespace != null);
       } else {
         namespace = privateNamespace;
       }
       _Meaning meaning = namespace[reference.name];
       if (meaning != null) {
         if (meaning is _PrefixMeaning) {
           prefixNamespaces[i] = meaning.namespace;
         }
         references.add(meaning.encodeReference());
       } else {
-        references.add(new PrelinkedReferenceBuilder(
-            kind: PrelinkedReferenceKind.unresolved));
+        references
+            .add(new LinkedReferenceBuilder(kind: ReferenceKind.unresolved));
       }
     }
-    return new PrelinkedUnitBuilder(references: references);
+    return new LinkedUnitBuilder(references: references);
   }
 
   /**
-   * Form the [PrelinkedLibrary] for the [definingUnit] that was passed to the
+   * Form the [LinkedLibrary] for the [definingUnit] that was passed to the
    * constructor.
    */
-  PrelinkedLibraryBuilder prelink() {
+  LinkedLibraryBuilder prelink() {
     // Gather up the unlinked summaries for all the compilation units in the
     // library.
     List<UnlinkedUnit> units = getUnitUris(null).map(getPartCached).toList();
 
     // Create the private namespace for the library by gathering all the names
     // defined in its compilation units.
     for (int unitNum = 0; unitNum < units.length; unitNum++) {
       UnlinkedUnit unit = units[unitNum];
       if (unit != null) {
         extractPrivateNames(unit, unitNum);
       }
     }
 
     // Fill in exported names.  This must be done before filling in prefixes
     // defined in import declarations, because prefixes shouldn't shadow
     // exports.
-    List<PrelinkedExportNameBuilder> exportNames =
-        <PrelinkedExportNameBuilder>[];
+    List<LinkedExportNameBuilder> exportNames = <LinkedExportNameBuilder>[];
     computeExportNamespace(null).forEach((String name, _Meaning meaning) {
       if (!privateNamespace.containsKey(name)) {
         exportNames.add(meaning.encodeExportName(name));
       }
     });
 
     // Fill in prefixes defined in import declarations.
     for (UnlinkedImport import in units[0].imports) {
       if (import.prefixReference != 0) {
         privateNamespace.putIfAbsent(
             units[0].references[import.prefixReference].name,
             () => new _PrefixMeaning());
       }
     }
 
     // Fill in imported names.
     List<int> importDependencies =
         definingUnit.imports.map(handleImport).toList();
 
     // Link each compilation unit.
-    List<PrelinkedUnitBuilder> linkedUnits = units.map(linkUnit).toList();
+    List<LinkedUnitBuilder> linkedUnits = units.map(linkUnit).toList();
 
-    return new PrelinkedLibraryBuilder(
+    return new LinkedLibraryBuilder(
         units: linkedUnits,
         dependencies: dependencies,
         importDependencies: importDependencies,
         exportNames: exportNames);
   }
 
   /**
    * Resolve [relativeUri] relative to [sourceUri].  Works correctly if
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return Uri.parse(sourceUri).resolve(relativeUri).toString();
     }
   }
 }