Mix file: and package: URIs during analysis.

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:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/error.dart';
@@ skipping 397 matching lines @@
   /**
    * 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;
+      SummaryDataStore store, Uri uri, UnlinkedUnit unlinked) {
+    String uriStr = uri.toString();
+    store.unlinkedMap[uriStr] = unlinked;
   }
 
   /**
    * Return the cached or newly computed analysis result of the file with the
    * given [path].
    *
    * The result will have the fully resolved unit and will always be newly
    * compute only if [withUnit] is `true`.
    */
   AnalysisResult _computeAnalysisResult(String path, {bool withUnit: false}) {
     // If we don't need the fully resolved unit, check for the cached result.
     if (!withUnit) {
-      FileState file = _fsState.getFile(path);
+      FileState file = _fsState.getFileForPath(path);
       // Prepare the key for the cached result.
       String key = _getResolvedUnitKey(file);
       if (key == null) {
         _logger.run('Compute the dependency hash for $path', () {
           _createLibraryContext(file);
           key = _getResolvedUnitKey(file);
         });
       }
       // Check for the cached result.
       AnalysisResult result = _getCachedAnalysisResult(file, key);
@@ skipping 84 matching lines @@
 
         String libraryUriStr = libraryUri.toString();
         _LibraryNode node = nodes[libraryUriStr];
         if (node == null) {
           node = new _LibraryNode(this, libraryFile, libraryUri);
           nodes[libraryUriStr] = node;
 
           // Append the defining unit.
           {
             UnlinkedUnit unlinked = libraryFile.unlinked;
-            _addToStoreUnlinked(store, libraryUriStr, unlinked);
+            _addToStoreUnlinked(store, libraryFile.uri, unlinked);
           }
 
           // Append parts.
           for (FileState part in libraryFile.partedFiles) {
-            String partUriStr = part.uri.toString();
             UnlinkedUnit unlinked = part.unlinked;
-            _addToStoreUnlinked(store, partUriStr, unlinked);
+            _addToStoreUnlinked(store, part.uri, unlinked);
           }
 
           // Create nodes for referenced libraries.
           libraryFile.importedFiles.forEach(createLibraryNodes);
           libraryFile.exportedFiles.forEach(createLibraryNodes);
         }
 
         // 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);
             _addToStoreLinked(
-                store, node.uri.toString(), linked.linkedLibraries.single);
+                store, node.file.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', () {
         linkedLibraries = link(libraryUrisToLink, (String uri) {
           LinkedLibrary linkedLibrary = store.linkedMap[uri];
-          if (linkedLibrary == null) {
-            throw new StateError('No linked library for: $uri');
-          }
           return linkedLibrary;
         }, (String uri) {
           UnlinkedUnit unlinkedUnit = store.unlinkedMap[uri];
-          if (unlinkedUnit == null) {
-            throw new StateError('No unlinked unit for: $uri');
-          }
           return unlinkedUnit;
         }, (_) => null, _analysisOptions.strongMode);
         _logger.writeln('Linked ${linkedLibraries.length} bundles.');
       });
 
       linkedLibraries.forEach((uri, linkedBuilder) {
         _LibraryNode node = nodes[uri];
         String key = '${node.dependencySignature}.linked';
         List<int> bytes;
         {
@@ skipping 81 matching lines @@
   }
 
   /**
    * Verify the API signature for the file with the given [path], and decide
    * which linked libraries should be invalidated, and files reanalyzed.
    *
    * TODO(scheglov) I see that adding a local var changes (full) API signature.
    */
   FileState _verifyApiSignature(String path) {
     return _logger.run('Verify API signature of $path', () {
-      FileState file = _fsState.getFile(path);
-      bool apiChanged = file.refresh();
-      if (apiChanged) {
+      bool anyApiChanged = false;
+      List<FileState> files = _fsState.getFilesForPath(path);
+      for (FileState file in files) {
+        bool apiChanged = file.refresh();
+        if (apiChanged) {
+          anyApiChanged = true;
+        }
+      }
+      if (anyApiChanged) {
         _logger.writeln('API signatures mismatch found for $path');
         _dependencySignatureMap.clear();
         _filesToAnalyze.addAll(_explicitFiles);
       }
-      return file;
+      return files[0];
     });
   }
 
   /**
    * Returns a [Future] that completes after performing [times] pumpings of
    * the event queue.
    */
   static Future _pumpEventQueue(int times) {
     if (times == 0) {
       return new Future.value();
@@ skipping 245 matching lines @@
   /**
    * Complete the [signal] future if it is not completed yet. It is safe to
    * call this method multiple times, but the [signal] will complete only once.
    */
   void notify() {
     if (!_completer.isCompleted) {
       _completer.complete(null);
     }
   }
 }