Exclude the file URI from _ReferencedUris.

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 278 matching lines @@
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
     _explicitFiles.remove(path);
     _filesToAnalyze.remove(path);
   }
 
   /**
+   * TODO(scheglov) see [_addToStoreUnlinked]
+   */
+  void _addToStoreLinked(
+      SummaryDataStore store, String uri, LinkedLibrary linked) {
+    store.linkedMap[uri] = linked;
+  }
+
+  /**
+   * TODO(scheglov) The existing [SummaryDataStore.addBundle] uses
+   * [PackageBundle.unlinkedUnitUris] to add [PackageBundle.unlinkedUnits].
+   * But we store unlinked bundles with the hash of the file content. This
+   * means that when two files are the same, but have different URIs, we
+   * add [UnlinkedUnit] with wrong URI.
+   *
+   * We need to clean this up.
+   */
+  void _addToStoreUnlinked(
+      SummaryDataStore store, String uri, UnlinkedUnit unlinked) {
+    store.unlinkedMap[uri] = unlinked;
+  }
+
+  /**
    * TODO(scheglov) replace with actual [AnalysisResult] computing.
    */
   List<String> _computeAndPrintErrors(_File file) {
     // TODO(scheglov) Computing resolved unit fails for these units.
     // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
     // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
     if (file.path.endsWith(
             'pkg/analyzer/lib/plugin/embedded_resolver_provider.dart') ||
         file.path.endsWith('pkg/analyzer/lib/source/embedder.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/ast.dart') ||
@@ skipping 106 matching lines @@
           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.
+          {
+            PackageBundle unlinked = _getUnlinked(libraryFile);
+            node.unlinkedBundles.add(unlinked);
+            _addToStoreUnlinked(
+                store, libraryUriStr, unlinked.unlinkedUnits.single);
+          }
+
           // Append unlinked bundles.
           for (String uri in referenced.parted) {
             _File file = libraryFile.resolveUri(uri);
             PackageBundle unlinked = _getUnlinked(file);
             node.unlinkedBundles.add(unlinked);
-            store.addBundle(null, unlinked);
+            _addToStoreUnlinked(
+                store, file.uri.toString(), unlinked.unlinkedUnits.single);
           }
 
           // 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);
           }
         }
 
         // Done with this node.
         return node;
       }
 
       _LibraryNode libraryNode = _logger.run('Compute library nodes', () {
         return createLibraryNodes(libraryFile);
       });
 
       Set<String> libraryUrisToLink = new Set<String>();
       _logger.run('Load linked bundles', () {
         for (_LibraryNode node in nodes.values) {
           String key = '${node.dependencySignature}.linked';
           List<int> bytes = _byteStore.get(key);
           if (bytes != null) {
             PackageBundle linked = new PackageBundle.fromBuffer(bytes);
-            store.addBundle(null, linked);
+            _addToStoreLinked(
+                store, node.uri.toString(), linked.linkedLibraries.single);
           } else {
             libraryUrisToLink.add(node.uri.toString());
           }
         }
         int numOfLoaded = nodes.length - libraryUrisToLink.length;
         _logger.writeln('Loaded $numOfLoaded linked bundles.');
       });
 
       Map<String, LinkedLibraryBuilder> linkedLibraries = {};
       _logger.run('Link bundles', () {
@@ skipping 16 matching lines @@
       linkedLibraries.forEach((uri, linkedBuilder) {
         _LibraryNode node = nodes[uri];
         String key = '${node.dependencySignature}.linked';
         List<int> bytes;
         {
           PackageBundleAssembler assembler = new PackageBundleAssembler();
           assembler.addLinkedLibrary(uri, linkedBuilder);
           bytes = assembler.assemble().toBuffer();
         }
         PackageBundle linked = new PackageBundle.fromBuffer(bytes);
-        store.addBundle(null, linked);
+        _addToStoreLinked(store, uri, linked.linkedLibraries.single);
         _byteStore.put(key, bytes);
       });
 
       return new _LibraryContext(libraryFile, libraryNode, store);
     });
   }
 
   /**
    * Return the [_File] for the given [path] in [_sourceFactory].
    */
@@ skipping 34 matching lines @@
         referencedUris.isLibrary = isLibrary;
         referencedUris.imported.addAll(imported);
         referencedUris.exported.addAll(exported);
         referencedUris.parted.addAll(parted);
         return referencedUris;
       }
     }
 
     // Compute URIs.
     _ReferencedUris referencedUris = new _ReferencedUris();
-    referencedUris.parted.add(file.uri.toString());
     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) {
@@ skipping 290 matching lines @@
   }
 
   @override
   String toString() => uri.toString();
 
   /**
    * Fill the [_content] and [_contentHash] fields.
    *
    * If the [_content] field is still `null`, get the content from the
    * content cache or from the [source]. If the content cannot be accessed
-   * because of an exception, it considers to be an empty string.
+   * because of an exception, it is considered to be an empty string.
    *
    * When a new content is read, the new [_contentHash] should be computed and
    * the current file state should be updated.
    */
   void _readContentAndComputeHash() {
     try {
       _content = driver._contentCache.getContents(source);
       _content ??= source.contents.data;
     } catch (_) {
-      // TODO(scheglov) Fix the bug with not existing sources.
-      // We should not put "self URI" into cached _ReferencedUris.
-      // Otherwise such not-existing/empty sources all have the same hash,
-      // but their "self URIs" must be all different.
       _content = '';
+      // TODO(scheglov) We fail to report URI_DOES_NOT_EXIST.
+      // On one hand we need to provide an unlinked bundle to prevent
+      // analysis context from reading the file (we want it to work
+      // hermetically and handle one one file at a time). OTOH,
+      // ResynthesizerResultProvider happily reports that any source in the
+      // SummaryDataStore has MODIFICATION_TIME `0`. We need to return `-1`
+      // for missing files. Maybe add this feature to SummaryDataStore?
     }
     // Compute the content hash.
     List<int> textBytes = UTF8.encode(_content);
     List<int> hashBytes = md5.convert(textBytes).bytes;
     _contentHash = hex.encode(hashBytes);
     // Update the current file state.
     driver._fileContentHashMap[path] = _contentHash;
   }
 }
 
@@ skipping 112 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>[];
 }