Separate prelinked and unlinked parts of 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 '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 summary for a given
- * URI.
+ * Callback used by [SummaryResynthesizer] to obtain the prelinked summary for
+ * a given URI.
  */
-typedef PrelinkedLibrary GetSummaryCallback(String uri);
+typedef PrelinkedLibrary GetPrelinkedSummaryCallback(String uri);
+
+/**
+ * Callback used by [SummaryResynthesizer] to obtain the unlinked summary for a
+ * given URI.
+ */
+typedef UnlinkedUnit GetUnlinkedSummaryCallback(String uri);
 
 /**
  * Specialization of [FunctionTypeImpl] used for function types resynthesized
  * from summaries.
  */
 class ResynthesizedFunctionTypeImpl extends FunctionTypeImpl
     with ResynthesizedType {
   final SummaryResynthesizer summaryResynthesizer;
 
   ResynthesizedFunctionTypeImpl(
@@ skipping 47 matching lines @@
 
   int get _numTypeParameters;
 }
 
 /**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 class SummaryResynthesizer extends ElementResynthesizer {
   /**
-   * Callback used to obtain the summary for a given URI.
+   * Callback used to obtain the prelinked summary for a given URI.
    */
-  final GetSummaryCallback getSummary;
+  final GetPrelinkedSummaryCallback getPrelinkedSummary;
+
+  /**
+   * 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;
 
   /**
    * Cache of [Source] objects that have already been converted from URIs.
    */
   final Map<String, Source> _sources = <String, Source>{};
@@ skipping 15 matching lines @@
   final Map<String, Map<String, Map<String, Element>>> _resynthesizedElements =
       <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.getSummary, this.sourceFactory)
+  SummaryResynthesizer(AnalysisContext context, this.getPrelinkedSummary,
+      this.getUnlinkedSummary, this.sourceFactory)
       : super(context),
         typeProvider = context.typeProvider;
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   @override
   Element getElement(ElementLocation location) {
@@ skipping 21 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 = getSummary(uri);
-      _LibraryResynthesizer libraryResynthesizer =
-          new _LibraryResynthesizer(this, serializedLibrary, _getSource(uri));
+      PrelinkedLibrary serializedLibrary = getPrelinkedSummary(uri);
+      List<UnlinkedUnit> serializedUnits = <UnlinkedUnit>[
+        getUnlinkedSummary(uri)
+      ];
+      Source librarySource = _getSource(uri);
+      for (UnlinkedPart part in serializedUnits[0].parts) {
+        String partAbsUri =
+            sourceFactory.resolveUri(librarySource, part.uri).uri.toString();
+        serializedUnits.add(getUnlinkedSummary(partAbsUri));
+      }
+      _LibraryResynthesizer libraryResynthesizer = new _LibraryResynthesizer(
+          this, serializedLibrary, serializedUnits, librarySource);
       LibraryElement library = libraryResynthesizer.buildLibrary();
       _resynthesizedElements[uri] = libraryResynthesizer.resummarizedElements;
       return library;
     });
   }
 
   /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(uri, () => sourceFactory.forUri(uri));
   }
 }
 
 /**
  * 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;
 
   /**
-   * The library to be resynthesized.
+   * Prelinked summary of the library to be resynthesized.
    */
   final PrelinkedLibrary prelinkedLibrary;
 
   /**
+   * Unlinked compilation units constituting the library to be resynthesized.
+   */
+  final List<UnlinkedUnit> unlinkedUnits;
+
+  /**
    * [Source] object for the library to be resynthesized.
    */
   final Source librarySource;
 
   /**
    * [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.
    */
   PrelinkedUnit prelinkedUnit;
 
   /**
+   * 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 class or typedef currently being resynthesized.
    *
    * TODO(paulberry): extend this to do the right thing for generic methods.
    */
   List<TypeParameterElement> currentTypeParameters;
 
-  _LibraryResynthesizer(this.summaryResynthesizer,
-      PrelinkedLibrary serializedLibrary, this.librarySource)
-      : prelinkedLibrary = serializedLibrary;
+  _LibraryResynthesizer(this.summaryResynthesizer, this.prelinkedLibrary,
+      this.unlinkedUnits, this.librarySource);
 
   /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     try {
       currentTypeParameters =
           serializedClass.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedClass.typeParameters.length; i++) {
         finishTypeParameter(
@@ skipping 350 matching lines @@
         .toString();
     importElement.importedLibrary = new LibraryElementHandle(
         summaryResynthesizer,
         new ElementLocationImpl.con3(<String>[absoluteUri]));
     if (isSynthetic) {
       importElement.synthetic = true;
     } else {
       importElement.uri = serializedImport.uri;
     }
     if (serializedImport.prefixReference != 0) {
-      UnlinkedReference serializedPrefix = prelinkedLibrary.units[0]
-          .unlinked
-          .references[serializedImport.prefixReference];
+      UnlinkedReference serializedPrefix =
+          unlinkedUnits[0].references[serializedImport.prefixReference];
       importElement.prefix = new PrefixElementImpl(serializedPrefix.name, -1);
     }
     importElement.combinators =
         serializedImport.combinators.map(buildCombinator).toList();
     return importElement;
   }
 
   /**
    * Main entry point.  Resynthesize the [LibraryElement] and return it.
    */
   LibraryElement buildLibrary() {
     // TODO(paulberry): is it ok to pass -1 for offset and nameLength?
     LibraryElementImpl libraryElement = new LibraryElementImpl(
-        summaryResynthesizer.context,
-        prelinkedLibrary.units[0].unlinked.libraryName,
-        -1,
-        -1);
+        summaryResynthesizer.context, unlinkedUnits[0].libraryName, -1, -1);
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl(librarySource.shortName);
     libraryElement.definingCompilationUnit = definingCompilationUnit;
     definingCompilationUnit.source = librarySource;
     definingCompilationUnit.librarySource = librarySource;
     List<CompilationUnitElement> parts = <CompilationUnitElement>[];
-    UnlinkedUnit unlinkedDefiningUnit = prelinkedLibrary.units[0].unlinked;
+    UnlinkedUnit unlinkedDefiningUnit = unlinkedUnits[0];
     assert(
         unlinkedDefiningUnit.parts.length + 1 == prelinkedLibrary.units.length);
     for (int i = 1; i < prelinkedLibrary.units.length; i++) {
-      CompilationUnitElementImpl part = buildPart(
-          unlinkedDefiningUnit.parts[i - 1].uri,
-          prelinkedLibrary.units[i].unlinked);
+      CompilationUnitElementImpl part =
+          buildPart(unlinkedDefiningUnit.parts[i - 1].uri, 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]));
     }
     libraryElement.imports = imports;
     libraryElement.exports =
@@ skipping 69 matching lines @@
     if (type.paramReference != 0) {
       // 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 =
-          prelinkedUnit.unlinked.references[type.reference];
+      UnlinkedReference reference = unlinkedUnit.references[type.reference];
       PrelinkedReference referenceResolution =
           prelinkedUnit.references[type.reference];
       String referencedLibraryUri;
       String partUri;
       if (referenceResolution.dependency != 0) {
         PrelinkedDependency dependency =
             prelinkedLibrary.dependencies[referenceResolution.dependency];
         Source referencedLibrarySource = summaryResynthesizer.sourceFactory
             .resolveUri(librarySource, dependency.uri);
         referencedLibraryUri = referencedLibrarySource.uri.toString();
-        PrelinkedLibrary referencedLibrary =
-            summaryResynthesizer.getSummary(referencedLibraryUri);
         // TODO(paulberry): consider changing Location format so that this is
         // not necessary (2nd string in location should just be the unit
         // number).
         if (referenceResolution.unit != 0) {
-          String uri = referencedLibrary.units[0].unlinked.parts[0].uri;
+          UnlinkedUnit referencedLibraryDefiningUnit =
+              summaryResynthesizer.getUnlinkedSummary(referencedLibraryUri);
+          String uri = referencedLibraryDefiningUnit.parts[0].uri;
           Source partSource = summaryResynthesizer.sourceFactory
               .resolveUri(referencedLibrarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       } else if (referenceResolution.kind ==
           PrelinkedReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
       } else if (reference.name.isEmpty) {
         return summaryResynthesizer.typeProvider.dynamicType;
       } else {
         referencedLibraryUri = librarySource.uri.toString();
         if (referenceResolution.unit != 0) {
-          String uri = prelinkedLibrary.units[0].unlinked.parts[
-              referenceResolution.unit - 1].uri;
+          String uri = unlinkedUnits[0].parts[referenceResolution.unit - 1].uri;
           Source partSource =
               summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       }
       ResynthesizedType resynthesizedType;
       ElementLocationImpl location = new ElementLocationImpl.con3(
           <String>[referencedLibraryUri, partUri, reference.name]);
@@ skipping 110 matching lines @@
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
     }
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit(CompilationUnitElementImpl unit, int unitNum) {
     prelinkedUnit = prelinkedLibrary.units[unitNum];
+    unlinkedUnit = unlinkedUnits[unitNum];
     unitHolder = new ElementHolder();
-    UnlinkedUnit unlinkedUnit = prelinkedUnit.unlinked;
     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;
     unit.functions = unitHolder.functions;
     List<FunctionTypeAliasElement> typeAliases = unitHolder.typeAliases;
@@ skipping 11 matching lines @@
     }
     for (ClassElement cls in unit.enums) {
       elementMap[cls.name] = cls;
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
+    unlinkedUnit = null;
   }
 }