Extract _ReferencedUris information from UnlinkedUnit.

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 424 matching lines @@
         // URIs with the 'dart:' scheme are served from the SDK bundle.
         if (libraryUri.scheme == 'dart') {
           return null;
         }
 
         String libraryUriStr = libraryUri.toString();
         _LibraryNode node = nodes[libraryUriStr];
         if (node == null) {
           node = new _LibraryNode(this, nodes, libraryUri);
           nodes[libraryUriStr] = node;
-          _ReferencedUris referenced = _getReferencedUris(libraryFile);
 
           // Append the defining unit.
+          _ReferencedUris referenced;
           {
-            PackageBundle unlinked = _getUnlinked(libraryFile);
-            node.unlinkedBundles.add(unlinked);
-            _addToStoreUnlinked(
-                store, libraryUriStr, unlinked.unlinkedUnits.single);
+            PackageBundle bundle = _getUnlinked(libraryFile);
+            UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
+            referenced = new _ReferencedUris(unlinked);
+            node.unlinkedBundles.add(bundle);
+            _addToStoreUnlinked(store, libraryUriStr, unlinked);
           }
 
-          // Append unlinked bundles.
+          // Append parts.
           for (String uri in referenced.parted) {
             _File file = libraryFile.resolveUri(uri);
-            PackageBundle unlinked = _getUnlinked(file);
-            node.unlinkedBundles.add(unlinked);
-            _addToStoreUnlinked(
-                store, file.uri.toString(), unlinked.unlinkedUnits.single);
+            PackageBundle bundle = _getUnlinked(file);
+            UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
+            node.unlinkedBundles.add(bundle);
+            _addToStoreUnlinked(store, file.uri.toString(), unlinked);
           }
 
           // Create nodes for referenced libraries.
           for (String uri in referenced.imported) {
             _File file = libraryFile.resolveUri(uri);
             createLibraryNodes(file);
           }
           for (String uri in referenced.exported) {
             _File file = libraryFile.resolveUri(uri);
             createLibraryNodes(file);
@@ skipping 74 matching lines @@
   /**
    * Return the unlinked bundle of [file] for the current file state, or `null`.
    */
   PackageBundle _getCurrentUnlinked(_File file) {
     String key = '${file.currentContentHash}.unlinked';
     List<int> bytes = _byteStore.get(key);
     return bytes != null ? new PackageBundle.fromBuffer(bytes) : null;
   }
 
   /**
-   * TODO(scheglov) It would be nice to get URIs of "parts" from unlinked.
-   */
-  _ReferencedUris _getReferencedUris(_File file) {
-    // Try to get from the store.
-    {
-      String key = '${file.contentHash}.uris';
-      List<int> bytes = _byteStore.get(key);
-      if (bytes != null) {
-        fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
-        int table = bp.derefObject(0);
-        const fb.ListReader<String> stringListReader =
-            const fb.ListReader<String>(const fb.StringReader());
-        bool isLibrary = const fb.BoolReader().vTableGet(bp, table, 0);
-        List<String> imported = stringListReader.vTableGet(bp, table, 1);
-        List<String> exported = stringListReader.vTableGet(bp, table, 2);
-        List<String> parted = stringListReader.vTableGet(bp, table, 3);
-        _ReferencedUris referencedUris = new _ReferencedUris();
-        referencedUris.isLibrary = isLibrary;
-        referencedUris.imported.addAll(imported);
-        referencedUris.exported.addAll(exported);
-        referencedUris.parted.addAll(parted);
-        return referencedUris;
-      }
-    }
-
-    // Compute URIs.
-    _ReferencedUris referencedUris = new _ReferencedUris();
-    for (Directive directive in file.unit.directives) {
-      if (directive is PartOfDirective) {
-        referencedUris.isLibrary = false;
-      } else if (directive is UriBasedDirective) {
-        String uri = directive.uri.stringValue;
-        if (directive is ImportDirective) {
-          referencedUris.imported.add(uri);
-        } else if (directive is ExportDirective) {
-          referencedUris.exported.add(uri);
-        } else if (directive is PartDirective) {
-          referencedUris.parted.add(uri);
-        }
-      }
-    }
-
-    // Serialize into bytes.
-    List<int> bytes;
-    {
-      fb.Builder fbBuilder = new fb.Builder();
-      var importedOffset = fbBuilder.writeList(referencedUris.imported
-          .map((uri) => fbBuilder.writeString(uri))
-          .toList());
-      var exportedOffset = fbBuilder.writeList(referencedUris.exported
-          .map((uri) => fbBuilder.writeString(uri))
-          .toList());
-      var partedOffset = fbBuilder.writeList(referencedUris.parted
-          .map((uri) => fbBuilder.writeString(uri))
-          .toList());
-      fbBuilder.startTable();
-      fbBuilder.addBool(0, referencedUris.isLibrary);
-      fbBuilder.addOffset(1, importedOffset);
-      fbBuilder.addOffset(2, exportedOffset);
-      fbBuilder.addOffset(3, partedOffset);
-      var offset = fbBuilder.endTable();
-      bytes = fbBuilder.finish(offset, 'SoRU');
-    }
-
-    // We read the content and recomputed the hash.
-    // So, we need to update the key.
-    String key = '${file.contentHash}.uris';
-    _byteStore.put(key, bytes);
-
-    return referencedUris;
-  }
-
-  /**
    * Return the unlinked bundle of [file] for the current file state.
    *
    * Return [_getCurrentUnlinked] or read the [file] content is read, compute
    * the content hash and update the current file state accordingly. Parse the
    * content into the [CompilationUnit] and serialize into a new unlinked
    * bundle. The bundle is then put into the [_byteStore] and returned.
    */
   PackageBundle _getUnlinked(_File file) {
+    // By accessing 'contentHash' we ensure that the current file state
+    // has some version of the file content hash, so we will be able to
+    // use it to attempt to get the current unlinked bundle.
+    String key = '${file.contentHash}.unlinked';
     return _getCurrentUnlinked(file) ??
         _logger.run('Create unlinked for $file', () {
-          String key = '${file.contentHash}.unlinked';
           UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
           PackageBundleAssembler assembler = new PackageBundleAssembler();
           assembler.addUnlinkedUnitWithHash(
               file.uri.toString(), unlinkedUnit, key);
           List<int> bytes = assembler.assemble().toBuffer();
           _byteStore.put(key, bytes);
           return new PackageBundle.fromBuffer(bytes);
         });
   }
 
   /**
    * Verify the API signatures for the changed files, and decide which linked
    * libraries should be invalidated, and files reanalyzed.
+   *
+   * TODO(scheglov) I see that adding a local var changes (full) API signature.

[Paul Berry, 2016/10/31 15:56:56]

Do you have a repro for this?  If you'd rather spend your time on other things,
I'd be glad to investigate--feel free to file a bug in the issue tracker.

Note that I fixed some bugs which would cause this in
84ec7f01c060ee0a5e423c58a11707a4e3a60045 and
105f568452fa562207ce6fbc557bb7638024cc69.  Perhaps there are still some
outstanding problems :(

[scheglov, 2016/10/31 16:03:16]

Adding a local variable per se is not a problem.
But I suspect that are two, possibly related problems with API signatures.

1. They are order sensitive, i.e. "class A{} class B {}" and "class B {} class A
{}" are different.

2. When you add a variable that is that first one referencing a type, the type
is added to UnlinkedUnit.references, and so changes the signature. Or if you
reorder local variables, these type references are also reordered, and the
signature changes.

    */
   void _verifyUnlinkedSignatureOfChangedFiles() {
     if (_filesToVerifyUnlinkedSignature.isEmpty) {
       return;
     }
     int numOfFiles = _filesToVerifyUnlinkedSignature.length;
     _logger.run('Verify API signatures of $numOfFiles files', () {
       for (String path in _filesToVerifyUnlinkedSignature) {
         _File file = _fileForPath(path);
         // Get the existing old API signature, maybe null.
@@ skipping 369 matching lines @@
 }
 
 /**
  * TODO(scheglov) document
  */
 class _ReferencedUris {
   bool isLibrary = true;
   final List<String> imported = <String>[];
   final List<String> exported = <String>[];
   final List<String> parted = <String>[];
+
+  factory _ReferencedUris(UnlinkedUnit unit) {
+    _ReferencedUris referenced = new _ReferencedUris._();
+    referenced.parted.addAll(unit.publicNamespace.parts);
+    for (UnlinkedImport import in unit.imports) {
+      if (!import.isImplicit) {
+        referenced.imported.add(import.uri);
+      }
+    }
+    for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
+      referenced.exported.add(export.uri);
+    }
+    return referenced;
+  }
+
+  _ReferencedUris._();
 }