Chaining not just element requests but also summaries access.

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 linked summary for
- * a given URI.
- */
-typedef LinkedLibrary GetLinkedSummaryCallback(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`.
+   * The parent [SummaryResynthesizer] which is asked to resynthesize elements
+   * and get summaries 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 linked summary for a given URI.
-   */
-  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;
 
   /**
    * Cache of [Source] objects that have already been converted from URIs.
    */
   final Map<String, Source> _sources = <String, Source>{};
 
   /**
@@ skipping 10 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(
-      this.parent,
-      AnalysisContext context,
-      this.typeProvider,
-      this.hasLibrarySummary,
-      this.getLinkedSummary,
-      this.getUnlinkedSummary,
+  SummaryResynthesizer(this.parent, AnalysisContext context, this.typeProvider,
       this.sourceFactory)
       : super(context);
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   @override
   Element getElement(ElementLocation location) {
@@ skipping 31 matching lines @@
 
   /**
    * 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, () {
-      LinkedLibrary serializedLibrary = getLinkedSummary(uri);
+      LinkedLibrary serializedLibrary = _getLinkedSummaryOrThrow(uri);
       List<UnlinkedUnit> serializedUnits = <UnlinkedUnit>[
-        getUnlinkedSummary(uri)
+        _getUnlinkedSummaryOrThrow(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));
+        serializedUnits.add(_getUnlinkedSummaryOrThrow(partAbsUri));
       }
       _LibraryResynthesizer libraryResynthesizer = new _LibraryResynthesizer(
           this, serializedLibrary, serializedUnits, librarySource);
       LibraryElement library = libraryResynthesizer.buildLibrary();
       _resynthesizedElements[uri] = libraryResynthesizer.resummarizedElements;
       return library;
     });
   }
 
   /**
+   * Return the [LinkedLibrary] for the given [uri] or `null` if it could not
+   * be found.
+   */
+  LinkedLibrary getLinkedSummary(String uri) {

[Paul Berry, 2016/01/15 16:37:38]

I'm concerned about the interface contract implied by this code.  Since the
class isn't abstract, and the methods getLinkedSummary, getUnlinkedSummary, and
hasLibrarySummary have implementations, it's not obvious to the reader that the
intended use is to derive from this class and provide implementations of these
three methods.

Also, the behavior of checking the parent first is implemented in these three
methods, but since they are intended to be overridden, clients will have to be
careful to re-implement correct behavior.  This seems like it will be easy to
mess up.

How about doing something like this instead:

abstract class SummaryResynthesizer extends ElementResynthesizer {
  ...
  /**
   * Return the [LinkedLibrary] for the given [uri] or `null` if it
   * could not be found.  Caller has already checked that
   * `parent.hasLibrarySummary(uri)` returns false.
   */
  LinkedLibrary getLinkedSummary(String uri);

  /**
   * ...similar comment here...
   */
  UnlinkedUnit getUnlinkedSummary(String uri);

  /**
   * ...similar comment here...
   */
  bool hasLibrarySummary(String uri);

  LinkedLibrary _getLinkedSummaryOrThrow(String uri) {
    if (parent.hasLibrarySummary(uri)) {
      return parent._getLinkedSummaryOrThrow(uri);
    }
    LinkedLibrary summary = getLinkedSummary(uri);
    if (summary != null) {
      return summary;
    }
    throw new StateError(...);
  }

  UnlinkedUnit _getUnlinkedSummaryOrThrow(String uri) {
    ...similar implementation...
  }
}

This way it's obvious what needs to be implemented by clients, and there's no
way clients can screw up the behavior of checking the parent first.

[scheglov, 2016/01/15 16:54:50]

Done.

+    if (parent != null) {
+      LinkedLibrary summary = parent.getLinkedSummary(uri);
+      if (summary != null) {
+        return summary;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the [UnlinkedUnit] for the given [uri] or `null` if it could not
+   * be found.
+   */
+  UnlinkedUnit getUnlinkedSummary(String uri) {
+    if (parent != null) {
+      UnlinkedUnit summary = parent.getUnlinkedSummary(uri);
+      if (summary != null) {
+        return summary;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return `true` if this resynthesizer get provide summaries of the libraries

[Paul Berry, 2016/01/15 16:37:38]

s/get/can/

+   * with the given [uri].
+   */
+  bool hasLibrarySummary(String uri) {
+    return false;
+  }
+
+  /**
+   * Return the [LinkedLibrary] for the given [uri] or throw [StateError] if it
+   * could not be found.
+   */
+  LinkedLibrary _getLinkedSummaryOrThrow(String uri) {
+    LinkedLibrary summary = getLinkedSummary(uri);
+    if (summary != null) {
+      return summary;
+    }
+    throw new StateError('Unable to find linked summary: $uri');
+  }
+
+  /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(uri, () => sourceFactory.forUri(uri));
   }
+
+  /**
+   * Return the [UnlinkedUnit] for the given [uri] or throw [StateError] if it
+   * could not be found.
+   */
+  UnlinkedUnit _getUnlinkedSummaryOrThrow(String uri) {
+    UnlinkedUnit summary = getUnlinkedSummary(uri);
+    if (summary != null) {
+      return summary;
+    }
+    throw new StateError('Unable to find unlinked summary: $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.
    */
@@ skipping 863 matching lines @@
       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);
+          summaryResynthesizer._getUnlinkedSummaryOrThrow(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]);
@@ skipping 40 matching lines @@
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
   }
 }