Record information about parts of dependent libraries in summaries.

This information will be necessary in order to determine whether a
summary needs to be re-linked, since a change to a part of library A may
affect any other library that depends on library A, even if the defining
compilation unit of library A is unaffected.

[email protected]

Review URL: https://codereview.chromium.org/1574113002 .

Author: stereotype441

pkg/analyzer/lib/src/summary/format.dart

@@ -45,35 +45,57 @@ class PrelinkedDependencyBuilder {
   bool _finished = false;
 
   String _uri;
+  List<String> _parts;
 
   PrelinkedDependencyBuilder();
 
   /**
-   * The relative URI used to import one library from the other.
+   * The relative URI of the dependent library.  This URI is relative to the
+   * importing library, even if there are intervening `export` declarations.
+   * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
+   * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
+   * `b/d/e.dart`.
    */
   void set uri(String _value) {
     assert(!_finished);
     _uri = _value;
   }
 
+  /**
+   * URI for the compilation units listed in the library's `part` declarations.
+   * These URIs are relative to the importing library.
+   */
+  void set parts(List<String> _value) {
+    assert(!_finished);
+    _parts = _value;
+  }
+
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_uri;
+    fb.Offset offset_parts;
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
+    if (!(_parts == null || _parts.isEmpty)) {
+      offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
+    }
     fbBuilder.startTable();
     if (offset_uri != null) {
       fbBuilder.addOffset(0, offset_uri);
     }
+    if (offset_parts != null) {
+      fbBuilder.addOffset(1, offset_parts);
+    }
     return fbBuilder.endTable();
   }
 }
 
-PrelinkedDependencyBuilder encodePrelinkedDependency({String uri}) {
+PrelinkedDependencyBuilder encodePrelinkedDependency({String uri, List<String> parts}) {
   PrelinkedDependencyBuilder builder = new PrelinkedDependencyBuilder();
   builder.uri = uri;
+  builder.parts = parts;
   return builder;
 }
 
@@ -84,9 +106,19 @@ PrelinkedDependencyBuilder encodePrelinkedDependency({String uri}) {
 abstract class PrelinkedDependency extends base.SummaryClass {
 
   /**
-   * The relative URI used to import one library from the other.
+   * The relative URI of the dependent library.  This URI is relative to the
+   * importing library, even if there are intervening `export` declarations.
+   * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
+   * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
+   * `b/d/e.dart`.
    */
   String get uri;
+
+  /**
+   * URI for the compilation units listed in the library's `part` declarations.
+   * These URIs are relative to the importing library.
+   */
+  List<String> get parts;
 }
 
 class _PrelinkedDependencyReader extends fb.TableReader<_PrelinkedDependencyImpl> {
@@ -102,17 +134,25 @@ class _PrelinkedDependencyImpl implements PrelinkedDependency {
   _PrelinkedDependencyImpl(this._bp);
 
   String _uri;
+  List<String> _parts;
 
   @override
   Map<String, Object> toMap() => {
     "uri": uri,
+    "parts": parts,
   };
 
   @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
+
+  @override
+  List<String> get parts {
+    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
+    return _parts;
+  }
 }
 
 class PrelinkedLibraryBuilder {

pkg/analyzer/lib/src/summary/prelink.dart

@@ -156,11 +156,13 @@ class _Prelinker {
     assert(dependencies.length == dependencyToPublicNamespace.length);
     int dependency = dependencies.length;
     uriToDependency[relativeUri] = dependency;
-    dependencies.add(encodePrelinkedDependency(uri: relativeUri));
+    List<String> unitUris = getUnitUris(relativeUri);
+    PrelinkedDependencyBuilder prelinkedDependency =
+        encodePrelinkedDependency(uri: relativeUri, parts: unitUris.sublist(1));
+    dependencies.add(prelinkedDependency);
 
     Map<String, _Meaning> aggregated = <String, _Meaning>{};
 
-    List<String> unitUris = getUnitUris(relativeUri);
     for (int unitNum = 0; unitNum < unitUris.length; unitNum++) {
       String unitUri = unitUris[unitNum];
       UnlinkedPublicNamespace importedNamespace = getImportCached(unitUri);

pkg/analyzer/lib/src/summary/summarize_elements.dart

@@ -390,8 +390,11 @@ class _LibrarySerializer {
   int serializeDependency(LibraryElement dependentLibrary) {
     return dependencyMap.putIfAbsent(dependentLibrary, () {
       int index = dependencies.length;
+      List<String> parts = dependentLibrary.parts
+          .map((CompilationUnitElement e) => e.source.uri.toString())
+          .toList();
       dependencies.add(encodePrelinkedDependency(
-          uri: dependentLibrary.source.uri.toString()));
+          uri: dependentLibrary.source.uri.toString(), parts: parts));
       return index;
     });
   }

pkg/analyzer/test/src/summary/summary_test.dart

@@ -112,10 +112,9 @@ class PrelinkerTest extends SummarizeElementsTest {
             summarize_elements.serializeLibrary(
                 library, analysisContext.typeProvider);
         for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
-          uriToNamespace[serializedLibrary.unitUris[i]] =
-              new UnlinkedUnit.fromBuffer(
-                      serializedLibrary.unlinkedUnits[i].toBuffer())
-                  .publicNamespace;
+          uriToNamespace[
+              serializedLibrary.unitUris[i]] = new UnlinkedUnit.fromBuffer(
+              serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
         }
       }
       return uriToNamespace;
@@ -370,6 +369,21 @@ abstract class SummaryTest {
     expect(prelinked.dependencies[dependency].uri, relativeUri);
   }
 
+  /**
+   * Verify that the given [dependency] lists the given [absoluteUris] or
+   * [relativeUris] as its parts.
+   */
+  void checkDependencyParts(PrelinkedDependency dependency,
+      List<String> absoluteUris, List<String> relativeUris) {
+    if (expectAbsoluteUrisInDependencies) {
+      // The element model doesn't (yet) store enough information to recover
+      // relative URIs, so we have to use the absolute URI.
+      // TODO(paulberry): fix this.
+      relativeUris = absoluteUris;
+    }
+    expect(dependency.parts, relativeUris);
+  }
+
   /**
    * Check that the given [documentationComment] matches the first
    * Javadoc-style comment found in [text].
@@ -403,8 +417,11 @@ abstract class SummaryTest {
   /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [absoluteUri] and [relativeUri].
+   *
+   * The [PrelinkedDependency] is returned.
    */
-  void checkHasDependency(String absoluteUri, String relativeUri) {
+  PrelinkedDependency checkHasDependency(
+      String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
@@ -414,11 +431,12 @@ abstract class SummaryTest {
     List<String> found = <String>[];
     for (PrelinkedDependency dep in prelinked.dependencies) {
       if (dep.uri == relativeUri) {
-        return;
+        return dep;
       }
       found.add(dep.uri);
     }
     fail('Did not find dependency $relativeUri.  Found: $found');
+    return null;
   }
 
   /**
@@ -786,8 +804,7 @@ b.C c4;''');
   UnlinkedTypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-            allowErrors: allowErrors)
-        .type;
+        allowErrors: allowErrors).type;
   }
 
   /**
@@ -1441,6 +1458,8 @@ class C {
   test_dependencies_export_none() {
     // Exports are not listed as dependencies since no change to the exported
     // file can change the summary of the exporting file.
+    // TODO(paulberry): this needs to change since the element model for a
+    // library includes its export namespace.
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('export "a.dart";');
@@ -1521,6 +1540,32 @@ class C {
     checkLacksDependency(absUri('/b.dart'), 'b.dart');
   }
 
+  test_dependencies_parts() {
+    addNamedSource(
+        '/a.dart', 'library a; part "b.dart"; part "c.dart"; class A {}');
+    addNamedSource('/b.dart', 'part of a;');
+    addNamedSource('/c.dart', 'part of a;');
+    serializeLibraryText('import "a.dart"; A a;');
+    PrelinkedDependency dep = checkHasDependency(absUri('/a.dart'), 'a.dart');
+    checkDependencyParts(
+        dep, [absUri('/b.dart'), absUri('/c.dart')], ['b.dart', 'c.dart']);
+  }
+
+  test_dependencies_parts_relative_to_importing_library() {
+    addNamedSource('/a/b.dart', 'export "c/d.dart";');
+    addNamedSource('/a/c/d.dart',
+        'library d; part "e/f.dart"; part "g/h.dart"; class D {}');
+    addNamedSource('/a/c/e/f.dart', 'part of d;');
+    addNamedSource('/a/c/g/h.dart', 'part of d;');
+    serializeLibraryText('import "a/b.dart"; D d;');
+    PrelinkedDependency dep =
+        checkHasDependency(absUri('/a/c/d.dart'), 'a/c/d.dart');
+    checkDependencyParts(
+        dep,
+        [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')],
+        ['a/c/e/f.dart', 'a/c/g/h.dart']);
+  }
+
   test_elements_in_part() {
     addNamedSource(
         '/part1.dart',
@@ -1812,8 +1857,7 @@ enum E { v }''';
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-            'class C { void operator[]=(int i, bool v) => null; }')
-        .executables[0];
+        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);

pkg/analyzer/tool/summary/idl.dart

@@ -68,9 +68,19 @@ const topLevel = null;
  */
 class PrelinkedDependency {
   /**
-   * The relative URI used to import one library from the other.
+   * The relative URI of the dependent library.  This URI is relative to the
+   * importing library, even if there are intervening `export` declarations.
+   * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
+   * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
+   * `b/d/e.dart`.
    */
   String uri;
+
+  /**
+   * URI for the compilation units listed in the library's `part` declarations.
+   * These URIs are relative to the importing library.
+   */
+  List<String> parts;
 }
 
 /**