Chain SummaryResynthesizer(s).

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
  * a given URI.
  */
 typedef PrelinkedLibrary GetPrelinkedSummaryCallback(String uri);
 
 /**
  * Callback used by [SummaryResynthesizer] to obtain the unlinked summary for a
  * given URI.
  */
 typedef UnlinkedUnit GetUnlinkedSummaryCallback(String uri);
 
 /**
+ * Callback used by [SummaryResynthesizer] to check whether it can access
+ * summaries of the library with the given [uri].
+ */
+typedef bool HasLibrarySummaryCallback(String uri);
+
+/**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 class SummaryResynthesizer extends ElementResynthesizer {
   /**
+   * The parent [SummaryResynthesizer] which is asked to resynthesis elements
+   * before this resynthesizer attempts to do this. Can be `null`.
+   */
+  final SummaryResynthesizer parent;
+
+  /**
+   * Callback used to check whether summaries for a given URI can be accessed.
+   */
+  final HasLibrarySummaryCallback hasLibrarySummary;
+
+  /**
    * Callback used to obtain the prelinked summary for a given URI.
    */
   final GetPrelinkedSummaryCallback getPrelinkedSummary;
 
   /**
    * Callback used to obtain the unlinked summary for a given URI.
    */
   final GetUnlinkedSummaryCallback getUnlinkedSummary;
 
   /**
@@ skipping 20 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.typeProvider,
-      this.getPrelinkedSummary, this.getUnlinkedSummary, this.sourceFactory)
+  SummaryResynthesizer(
+      this.parent,
+      AnalysisContext context,
+      this.typeProvider,
+      this.hasLibrarySummary,
+      this.getPrelinkedSummary,
+      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) {
-      return getLibraryElement(location.components[0]);
-    } else if (location.components.length == 3) {
-      String uri = location.components[0];
+    List<String> components = location.components;
+    // Ask the parent resynthesizer.
+    if (parent != null && components.length >= 1) {
+      String libraryUri = components[0];

[Paul Berry, 2016/01/14 18:54:39]

Personally I would move this up to line 110, and delete lines 119 and 122.  It's
clearer, and the only behavioral difference is that it changes the type of
exception that would be thrown in the case where location.components is the
empty list (which should never happen anyway).

Your call, though.

[scheglov, 2016/01/14 22:43:08]

Done.

+      if (parent.hasLibrarySummary(libraryUri)) {
+        return parent.getElement(location);
+      }
+    }
+    // Resynthesize locally.
+    if (components.length == 1) {
+      String libraryUri = components[0];
+      return getLibraryElement(libraryUri);
+    } else if (components.length == 3) {
+      String libraryUri = components[0];
       Map<String, Map<String, Element>> libraryMap =
-          _resynthesizedElements[uri];
+          _resynthesizedElements[libraryUri];
       if (libraryMap == null) {
-        getLibraryElement(uri);
-        libraryMap = _resynthesizedElements[uri];
+        getLibraryElement(libraryUri);
+        libraryMap = _resynthesizedElements[libraryUri];
         assert(libraryMap != null);
       }
-      Map<String, Element> compilationUnitElements =
-          libraryMap[location.components[1]];
+      Map<String, Element> compilationUnitElements = libraryMap[components[1]];
       if (compilationUnitElements != null) {
-        Element element = compilationUnitElements[location.components[2]];
+        Element element = compilationUnitElements[components[2]];
         if (element != null) {
           return element;
         }
       }
       throw new Exception('Element not found in summary: $location');
     } else {
       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) {
+    if (parent != null && parent.hasLibrarySummary(uri)) {
+      return parent.getLibraryElement(uri);
+    }
     return _resynthesizedLibraries.putIfAbsent(uri, () {
       PrelinkedLibrary serializedLibrary = getPrelinkedSummary(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));
@@ skipping 712 matching lines @@
   /**
    * Build a [DartType] object based on an [UnlinkedTypeRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
   DartType buildType(UnlinkedTypeRef type) {
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
-          currentTypeParameters.length - type.paramReference].type;
+              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];
       ElementLocationImpl location;
@@ skipping 217 matching lines @@
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }