Downplay the distinction between linked and prelinked summaries.

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/summary/format.dart';
 
 /**
- * Callback used by [SummaryResynthesizer] to obtain the prelinked summary for
+ * Callback used by [SummaryResynthesizer] to obtain the linked summary for
  * a given URI.
  */
-typedef PrelinkedLibrary GetPrelinkedSummaryCallback(String uri);
+typedef LinkedLibrary GetLinkedSummaryCallback(String uri);
 
 /**
  * Callback used by [SummaryResynthesizer] to obtain the unlinked summary for a
  * given URI.
  */
 typedef UnlinkedUnit GetUnlinkedSummaryCallback(String uri);
 
 /**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 class SummaryResynthesizer extends ElementResynthesizer {
   /**
-   * Callback used to obtain the prelinked summary for a given URI.
+   * Callback used to obtain the linked summary for a given URI.
    */
-  final GetPrelinkedSummaryCallback getPrelinkedSummary;
+  final GetLinkedSummaryCallback getLinkedSummary;
 
   /**
    * Callback used to obtain the unlinked summary for a given URI.
    */
   final GetUnlinkedSummaryCallback getUnlinkedSummary;
 
   /**
    * Source factory used to convert URIs to [Source] objects.
    */
   final SourceFactory sourceFactory;
@@ skipping 18 matching lines @@
       <String, Map<String, Map<String, Element>>>{};
 
   /**
    * Map of libraries which have been resynthesized from summaries.  The map
    * key is the library URI.
    */
   final Map<String, LibraryElement> _resynthesizedLibraries =
       <String, LibraryElement>{};
 
   SummaryResynthesizer(AnalysisContext context, this.typeProvider,
-      this.getPrelinkedSummary, this.getUnlinkedSummary, this.sourceFactory)
+      this.getLinkedSummary, this.getUnlinkedSummary, this.sourceFactory)
       : super(context);
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   @override
   Element getElement(ElementLocation location) {
     if (location.components.length == 1) {
@@ skipping 20 matching lines @@
       throw new UnimplementedError(location.toString());
     }
   }
 
   /**
    * Get the [LibraryElement] for the given [uri], resynthesizing it if it
    * hasn't been resynthesized already.
    */
   LibraryElement getLibraryElement(String uri) {
     return _resynthesizedLibraries.putIfAbsent(uri, () {
-      PrelinkedLibrary serializedLibrary = getPrelinkedSummary(uri);
+      LinkedLibrary serializedLibrary = getLinkedSummary(uri);
       List<UnlinkedUnit> serializedUnits = <UnlinkedUnit>[
         getUnlinkedSummary(uri)
       ];
       Source librarySource = _getSource(uri);
       for (String part in serializedUnits[0].publicNamespace.parts) {
         Source partSource = sourceFactory.resolveUri(librarySource, part);
         String partAbsUri = partSource.uri.toString();
         serializedUnits.add(getUnlinkedSummary(partAbsUri));
       }
       _LibraryResynthesizer libraryResynthesizer = new _LibraryResynthesizer(
@@ skipping 16 matching lines @@
  * An instance of [_LibraryResynthesizer] is responsible for resynthesizing the
  * elements in a single library from that library's summary.
  */
 class _LibraryResynthesizer {
   /**
    * The [SummaryResynthesizer] which is being used to obtain summaries.
    */
   final SummaryResynthesizer summaryResynthesizer;
 
   /**
-   * Prelinked summary of the library to be resynthesized.
+   * Linked summary of the library to be resynthesized.
    */
-  final PrelinkedLibrary prelinkedLibrary;
+  final LinkedLibrary linkedLibrary;
 
   /**
    * Unlinked compilation units constituting the library to be resynthesized.
    */
   final List<UnlinkedUnit> unlinkedUnits;
 
   /**
    * [Source] object for the library to be resynthesized.
    */
   final Source librarySource;
@@ skipping 10 matching lines @@
   List<ClassElementImpl> delayedObjectSubclasses = <ClassElementImpl>[];
 
   /**
    * [ElementHolder] into which resynthesized elements should be placed.  This
    * object is recreated afresh for each unit in the library, and is used to
    * populate the [CompilationUnitElement].
    */
   ElementHolder unitHolder;
 
   /**
-   * The [PrelinkedUnit] from which elements are currently being resynthesized.
+   * The [LinkedUnit] from which elements are currently being resynthesized.
    */
-  PrelinkedUnit prelinkedUnit;
+  LinkedUnit linkedUnit;
 
   /**
    * The [UnlinkedUnit] from which elements are currently being resynthesized.
    */
   UnlinkedUnit unlinkedUnit;
 
   /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
   final Map<String, Map<String, Element>> resummarizedElements =
       <String, Map<String, Element>>{};
 
   /**
    * Type parameters for the generic class, typedef, or executable currently
    * being resynthesized, if any.  If multiple entities with type parameters
    * are nested (e.g. a generic executable inside a generic class), this is the
    * concatenation of all type parameters from all declarations currently in
    * force, with the outermost declaration appearing first.  If there are no
    * type parameters, or we are not currently resynthesizing a class, typedef,
    * or executable, then this is an empty list.
    */
   List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
 
-  _LibraryResynthesizer(this.summaryResynthesizer, this.prelinkedLibrary,
+  _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters].
    */
   List<TypeParameterType> get currentTypeArguments => currentTypeParameters
       ?.map((TypeParameterElement param) => param.type)
       ?.toList();
@@ skipping 295 matching lines @@
         serializedExportPublic.combinators.map(buildCombinator).toList();
     exportElement.uriOffset = serializedExportNonPublic.uriOffset;
     exportElement.uriEnd = serializedExportNonPublic.uriEnd;
     return exportElement;
   }
 
   /**
    * Build an [ElementHandle] referring to the entity referred to by the given
    * [exportName].
    */
-  ElementHandle buildExportName(PrelinkedExportName exportName) {
+  ElementHandle buildExportName(LinkedExportName exportName) {
     String name = exportName.name;
-    if (exportName.kind == PrelinkedReferenceKind.topLevelPropertyAccessor &&
+    if (exportName.kind == ReferenceKind.topLevelPropertyAccessor &&
         !name.endsWith('=')) {
       name += '?';
     }
     ElementLocationImpl location = getReferencedLocation(
-        prelinkedLibrary.dependencies[exportName.dependency],
+        linkedLibrary.dependencies[exportName.dependency],
         exportName.unit,
         name);
     switch (exportName.kind) {
-      case PrelinkedReferenceKind.classOrEnum:
+      case ReferenceKind.classOrEnum:
         return new ClassElementHandle(summaryResynthesizer, location);
-      case PrelinkedReferenceKind.typedef:
+      case ReferenceKind.typedef:
         return new FunctionTypeAliasElementHandle(
             summaryResynthesizer, location);
-      case PrelinkedReferenceKind.topLevelFunction:
+      case ReferenceKind.topLevelFunction:
         return new FunctionElementHandle(summaryResynthesizer, location);
-      case PrelinkedReferenceKind.topLevelPropertyAccessor:
+      case ReferenceKind.topLevelPropertyAccessor:
         return new PropertyAccessorElementHandle(
             summaryResynthesizer, location);
-      case PrelinkedReferenceKind.prefix:
-      case PrelinkedReferenceKind.unresolved:
+      case ReferenceKind.prefix:
+      case ReferenceKind.unresolved:
         // Should never happen.  Exported names never refer to import prefixes,
         // and they always refer to defined entities.
         throw new StateError('Unexpected export name kind: ${exportName.kind}');
     }
   }
 
   /**
    * Build the export namespace for the library by aggregating together its
    * [publicNamespace] and [exportNames].
    */
   Namespace buildExportNamespace(
-      Namespace publicNamespace, List<PrelinkedExportName> exportNames) {
+      Namespace publicNamespace, List<LinkedExportName> exportNames) {
     HashMap<String, Element> definedNames = new HashMap<String, Element>();
     // Start by populating all the public names from [publicNamespace].
     publicNamespace.definedNames.forEach((String name, Element element) {
       definedNames[name] = element;
     });
     // Add all the names from [exportNames].
-    for (PrelinkedExportName exportName in exportNames) {
+    for (LinkedExportName exportName in exportNames) {
       definedNames.putIfAbsent(
           exportName.name, () => buildExportName(exportName));
     }
     return new Namespace(definedNames);
   }
 
   /**
    * Resynthesize a [FieldElement].
    */
   FieldElement buildField(UnlinkedVariable serializedField) {
@@ skipping 87 matching lines @@
   /**
    * Resynthesize an [ImportElement].
    */
   ImportElement buildImport(UnlinkedImport serializedImport, int dependency) {
     bool isSynthetic = serializedImport.isImplicit;
     // TODO(paulberry): it seems problematic for the offset to be 0 for
     // non-synthetic imports, since it is used to disambiguate location.
     ImportElementImpl importElement =
         new ImportElementImpl(isSynthetic ? -1 : serializedImport.offset);
     String absoluteUri = summaryResynthesizer.sourceFactory
-        .resolveUri(
-            librarySource, prelinkedLibrary.dependencies[dependency].uri)
+        .resolveUri(librarySource, linkedLibrary.dependencies[dependency].uri)
         .uri
         .toString();
     importElement.importedLibrary = new LibraryElementHandle(
         summaryResynthesizer,
         new ElementLocationImpl.con3(<String>[absoluteUri]));
     if (isSynthetic) {
       importElement.synthetic = true;
     } else {
       importElement.uri = serializedImport.uri;
       importElement.uriOffset = serializedImport.uriOffset;
@@ skipping 25 matching lines @@
     buildDocumentation(
         libraryElement, unlinkedUnits[0].libraryDocumentationComment);
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl(librarySource.shortName);
     libraryElement.definingCompilationUnit = definingCompilationUnit;
     definingCompilationUnit.source = librarySource;
     definingCompilationUnit.librarySource = librarySource;
     List<CompilationUnitElement> parts = <CompilationUnitElement>[];
     UnlinkedUnit unlinkedDefiningUnit = unlinkedUnits[0];
     assert(unlinkedDefiningUnit.publicNamespace.parts.length + 1 ==
-        prelinkedLibrary.units.length);
-    for (int i = 1; i < prelinkedLibrary.units.length; i++) {
+        linkedLibrary.units.length);
+    for (int i = 1; i < linkedLibrary.units.length; i++) {
       CompilationUnitElementImpl part = buildPart(
           unlinkedDefiningUnit.publicNamespace.parts[i - 1],
           unlinkedDefiningUnit.parts[i - 1],
           unlinkedUnits[i]);
       parts.add(part);
     }
     libraryElement.parts = parts;
     List<ImportElement> imports = <ImportElement>[];
     for (int i = 0; i < unlinkedDefiningUnit.imports.length; i++) {
       imports.add(buildImport(unlinkedDefiningUnit.imports[i],
-          prelinkedLibrary.importDependencies[i]));
+          linkedLibrary.importDependencies[i]));
     }
     libraryElement.imports = imports;
     List<ExportElement> exports = <ExportElement>[];
     assert(unlinkedDefiningUnit.exports.length ==
         unlinkedDefiningUnit.publicNamespace.exports.length);
     for (int i = 0; i < unlinkedDefiningUnit.exports.length; i++) {
       exports.add(buildExport(unlinkedDefiningUnit.publicNamespace.exports[i],
           unlinkedDefiningUnit.exports[i]));
     }
     libraryElement.exports = exports;
     populateUnit(definingCompilationUnit, 0);
     for (int i = 0; i < parts.length; i++) {
       populateUnit(parts[i], i + 1);
     }
     BuildLibraryElementUtils.patchTopLevelAccessors(libraryElement);
     // Update delayed Object class references.
     if (isCoreLibrary) {
       ClassElement objectElement = libraryElement.getType('Object');
       assert(objectElement != null);
       for (ClassElementImpl classElement in delayedObjectSubclasses) {
         classElement.supertype = objectElement.type;
       }
     }
     // Compute namespaces.
     libraryElement.publicNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(libraryElement);
     libraryElement.exportNamespace = buildExportNamespace(
-        libraryElement.publicNamespace, prelinkedLibrary.exportNames);
+        libraryElement.publicNamespace, linkedLibrary.exportNames);
     // Find the entry point.  Note: we can't use element.isEntryPoint because
     // that will trigger resynthesis of exported libraries.
     Element entryPoint =
         libraryElement.exportNamespace.get(FunctionElement.MAIN_FUNCTION_NAME);
     if (entryPoint is FunctionElement) {
       libraryElement.entryPoint = entryPoint;
     }
     // Create the synthetic element for `loadLibrary`.
     libraryElement.createLoadLibraryFunction(summaryResynthesizer.typeProvider);
     // Done.
@@ skipping 68 matching lines @@
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
           currentTypeParameters.length - type.paramReference].type;
     } else {
       // TODO(paulberry): handle references to things other than classes (note:
       // this should only occur in the case of erroneous code).
       // TODO(paulberry): test reference to something inside a part.
       // TODO(paulberry): test reference to something inside a part of the
       // current lib.
       UnlinkedReference reference = unlinkedUnit.references[type.reference];
-      PrelinkedReference referenceResolution =
-          prelinkedUnit.references[type.reference];
+      LinkedReference referenceResolution =
+          linkedUnit.references[type.reference];
       ElementLocationImpl location;
       if (referenceResolution.dependency != 0) {
         location = getReferencedLocation(
-            prelinkedLibrary.dependencies[referenceResolution.dependency],
+            linkedLibrary.dependencies[referenceResolution.dependency],
             referenceResolution.unit,
             reference.name);
-      } else if (referenceResolution.kind ==
-          PrelinkedReferenceKind.unresolved) {
+      } else if (referenceResolution.kind == ReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
       } else if (reference.name.isEmpty) {
         return summaryResynthesizer.typeProvider.dynamicType;
       } else {
         String referencedLibraryUri = librarySource.uri.toString();
         String partUri;
         if (referenceResolution.unit != 0) {
           String uri = unlinkedUnits[0].publicNamespace.parts[
               referenceResolution.unit - 1];
           Source partSource =
@@ skipping 10 matching lines @@
         typeArguments = <DartType>[];
         for (int i = 0; i < referenceResolution.numTypeParameters; i++) {
           if (i < type.typeArguments.length) {
             typeArguments.add(buildType(type.typeArguments[i]));
           } else {
             typeArguments.add(summaryResynthesizer.typeProvider.dynamicType);
           }
         }
       }
       switch (referenceResolution.kind) {
-        case PrelinkedReferenceKind.classOrEnum:
+        case ReferenceKind.classOrEnum:
           return new InterfaceTypeImpl.elementWithNameAndArgs(
               new ClassElementHandle(summaryResynthesizer, location),
               reference.name,
               typeArguments);
-        case PrelinkedReferenceKind.typedef:
+        case ReferenceKind.typedef:
           return new FunctionTypeImpl.elementWithNameAndArgs(
               new FunctionTypeAliasElementHandle(
                   summaryResynthesizer, location),
               reference.name,
               typeArguments,
               typeArguments.isNotEmpty);
         default:
           // TODO(paulberry): figure out how to handle this case (which should
           // only occur in the event of erroneous code).
           throw new UnimplementedError();
@@ skipping 93 matching lines @@
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
     }
   }
 
   /**
    * Build an [ElementLocationImpl] for the entity in the given [unit] of the
    * given [dependency], having the given [name].
    */
   ElementLocationImpl getReferencedLocation(
-      PrelinkedDependency dependency, int unit, String name) {
+      LinkedDependency dependency, int unit, String name) {
     Source referencedLibrarySource = summaryResynthesizer.sourceFactory
         .resolveUri(librarySource, dependency.uri);
     String referencedLibraryUri = referencedLibrarySource.uri.toString();
     // TODO(paulberry): consider changing Location format so that this is
     // not necessary (2nd string in location should just be the unit
     // number).
     String partUri;
     if (unit != 0) {
       UnlinkedUnit referencedLibraryDefiningUnit =
           summaryResynthesizer.getUnlinkedSummary(referencedLibraryUri);
       String uri =
           referencedLibraryDefiningUnit.publicNamespace.parts[unit - 1];
       Source partSource = summaryResynthesizer.sourceFactory
           .resolveUri(referencedLibrarySource, uri);
       partUri = partSource.uri.toString();
     } else {
       partUri = referencedLibraryUri;
     }
     return new ElementLocationImpl.con3(
         <String>[referencedLibraryUri, partUri, name]);
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit(CompilationUnitElementImpl unit, int unitNum) {
-    prelinkedUnit = prelinkedLibrary.units[unitNum];
+    linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
     unitHolder = new ElementHolder();
     unlinkedUnit.classes.forEach(buildClass);
     unlinkedUnit.enums.forEach(buildEnum);
     unlinkedUnit.executables.forEach(buildExecutable);
     unlinkedUnit.typedefs.forEach(buildTypedef);
     unlinkedUnit.variables.forEach(buildVariable);
     String absoluteUri = unit.source.uri.toString();
     unit.accessors = unitHolder.accessors;
     unit.enums = unitHolder.enums;
@@ skipping 18 matching lines @@
       elementMap[typeAlias.name] = typeAlias;
     }
     for (FunctionElement function in unit.functions) {
       elementMap[function.name] = function;
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
-    prelinkedUnit = null;
+    linkedUnit = null;
     unlinkedUnit = null;
   }
 }