Use LinkedDependency.parts to find part URIs during resynthesis.

pkg/analyzer/test/src/summary/resynthesize_test.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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 33 matching lines @@
 
   void addLibrarySource(String filePath, String contents) {
     otherLibrarySources.add(addNamedSource(filePath, contents));
   }
 
   void checkLibrary(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElementImpl original = resolve2(source);
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibrary(original, allowErrors: allowErrors),
-        source.uri.toString());
+        source.uri.toString(),
+        original);
     checkLibraryElements(original, resynthesized);
   }
 
   void checkLibraryElements(
       LibraryElementImpl original, LibraryElementImpl resynthesized) {
     compareElements(resynthesized, original, '(library)');
     expect(resynthesized.displayName, original.displayName);
     expect(original.enclosingElement, isNull);
     expect(resynthesized.enclosingElement, isNull);
     expect(resynthesized.hasExtUri, original.hasExtUri);
@@ skipping 29 matching lines @@
     // `loadLibrary` functions until after both are created.
     if (original.name != 'dart.core' && original.name != 'dart.async') {
       compareExecutableElements(
           resynthesized.loadLibraryFunction as ExecutableElementImpl,
           original.loadLibraryFunction as ExecutableElementImpl,
           '(loadLibraryFunction)');
     }
     // TODO(paulberry): test metadata.
   }
 
+  /**
+   * Verify that the [resynthesizer] didn't do any unnecessary work when
+   * resynthesizing [library].
+   */
+  void checkMinimalResynthesisWork(
+      _TestSummaryResynthesizer resynthesizer, LibraryElement library) {
+    // Check that no other summaries needed to be resynthesized to resynthesize
+    // the library element.
+    expect(resynthesizer.resynthesisCount, 1);
+    // Check that the only linked summary consulted was that for [uri].
+    expect(resynthesizer.linkedSummariesRequested, hasLength(1));
+    expect(resynthesizer.linkedSummariesRequested.first,
+        library.source.uri.toString());
+    // Check that the only unlinked summaries consulted were those for the
+    // library in question.
+    Set<String> expectedCompilationUnitUris =
+        <String>[library.source.uri.toString()].toSet();
+    for (CompilationUnitElement partUnit in library.parts) {

[scheglov, 2016/02/01 21:45:22]

You could use "library.units" and avoid the special case for the defining unit.

[Paul Berry, 2016/02/01 22:32:32]

Done.

+      expectedCompilationUnitUris.add(partUnit.source.uri.toString());
+    }
+    for (String requestedUri in resynthesizer.unlinkedSummariesRequested) {
+      expect(expectedCompilationUnitUris, contains(requestedUri));
+    }
+  }
+
   void compareClassElements(
       ClassElementImpl resynthesized, ClassElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     expect(resynthesized.fields.length, original.fields.length,
         reason: '$desc fields.length');
     for (int i = 0; i < resynthesized.fields.length; i++) {
       String name = original.fields[i].name;
       compareFieldElements(
           resynthesized.fields[i], original.fields[i], '$desc.field $name');
     }
@@ skipping 569 matching lines @@
     } else {
       fail('Unexpected type for resynthesized ($desc):'
           ' ${element.runtimeType}');
       return null;
     }
   }
 
   /**
    * Resynthesize the library element associated with [uri] using
    * [resynthesizer], and verify that it only had to consult one summary in
-   * order to do so.
+   * order to do so.  [original] is consulted merely to verify that no
+   * unnecessary resynthesis work was performed.
    */
   LibraryElementImpl resynthesizeLibraryElement(
-      _TestSummaryResynthesizer resynthesizer, String uri) {
+      _TestSummaryResynthesizer resynthesizer,
+      String uri,
+      LibraryElement original) {
     LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
-    // Check that no other summaries needed to be resynthesized to resynthesize
-    // the library element.
-    expect(resynthesizer.resynthesisCount, 1);
+    checkMinimalResynthesisWork(resynthesizer, original);
     return resynthesized;
   }
 
   @override
   void setUp() {
     super.setUp();
     resetWithOptions(options);
   }
 
   test_class_abstract() {
@@ skipping 598 matching lines @@
    * Docs
    */
   C();
 }''');
   }
 
   test_core() {
     String uri = 'dart:core';
     LibraryElementImpl original =
         resolve2(analysisContext2.sourceFactory.forUri(uri));
-    LibraryElementImpl resynthesized =
-        resynthesizeLibraryElement(encodeLibraryElement(original), uri);
+    LibraryElementImpl resynthesized = resynthesizeLibraryElement(
+        encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 
   test_enum_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 enum E { v }''');
@@ skipping 880 matching lines @@
 
   /**
    * Encode the library containing [original] into a summary and then use
    * [_TestSummaryResynthesizer.getElement] to retrieve just the original
    * element from the resynthesized summary.
    */
   Element validateGetElement(Element original) {
     _TestSummaryResynthesizer resynthesizer = encodeLibrary(original.library);
     ElementLocationImpl location = original.location;
     Element result = resynthesizer.getElement(location);
+    checkMinimalResynthesisWork(resynthesizer, original.library);
     // Check that no other summaries needed to be resynthesized to resynthesize
     // the library element.
     expect(resynthesizer.resynthesisCount, 1);
     expect(result.location, location);
     return result;
   }
 }
 
 class _TestSummaryResynthesizer extends SummaryResynthesizer {
   final Map<String, UnlinkedUnit> unlinkedSummaries;
   final Map<String, LinkedLibrary> linkedSummaries;
 
+  /**
+   * The set of uris for which unlinked summaries have been requested using
+   * [getUnlinkedSummary].
+   */
+  final Set<String> unlinkedSummariesRequested = new Set<String>();
+
+  /**
+   * The set of uris for which linked summaries have been requested using
+   * [getLinkedSummary].
+   */
+  final Set<String> linkedSummariesRequested = new Set<String>();
+
   _TestSummaryResynthesizer(
       SummaryResynthesizer parent,
       AnalysisContext context,
       TypeProvider typeProvider,
       SourceFactory sourceFactory,
       this.unlinkedSummaries,
       this.linkedSummaries,
       bool strongMode)
       : super(parent, context, typeProvider, sourceFactory, strongMode);
 
   @override
   LinkedLibrary getLinkedSummary(String uri) {
+    linkedSummariesRequested.add(uri);
     LinkedLibrary serializedLibrary = linkedSummaries[uri];
     if (serializedLibrary == null) {
       fail('Unexpectedly tried to get linked summary for $uri');
     }
     return serializedLibrary;
   }
 
   @override
   UnlinkedUnit getUnlinkedSummary(String uri) {
+    unlinkedSummariesRequested.add(uri);
     UnlinkedUnit serializedUnit = unlinkedSummaries[uri];
     if (serializedUnit == null) {
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }