Mix file: and package: URIs during analysis.

pkg/analyzer/lib/src/dart/analysis/file_state.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:convert';
 import 'dart:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/listener.dart';
@@ skipping 58 matching lines @@
   /**
    * The absolute path of the file.
    */
   final String path;
 
   /**
    * The absolute URI of the file.
    */
   final Uri uri;
 
-  Source _source;
+  /**
+   * The [Source] of the file with the [uri].
+   */
+  Source source;
 
   String _content;
   String _contentHash;
   LineInfo _lineInfo;
   UnlinkedUnit _unlinked;
   List<int> _apiSignature;
 
   List<FileState> _importedFiles;
   List<FileState> _exportedFiles;
   List<FileState> _partedFiles;
   List<FileState> _dependencies;
 
-  FileState(this._fsState, this.path, this.uri) {
-    _source = new FileSource(_fsState._resourceProvider.getFile(path), uri);
-  }
+  FileState._(this._fsState, this.path, this.uri, this.source);
 
   /**
    * The unlinked API signature of the file.
    */
   List<int> get apiSignature => _apiSignature;
 
   /**
    * The content of the file.
    */
   String get content => _content;
 
   /**
    * The MD5 hash of the [content].
    */
   String get contentHash => _contentHash;
 
   /**
-   * Return information about line in the file.
-   */
-  LineInfo get lineInfo => _lineInfo;
-
-  /**
    * Return the list of all direct dependencies.
    */
   List<FileState> get dependencies => _dependencies;
 
   /**
    * The list of files this file exports.
    */
   List<FileState> get exportedFiles => _exportedFiles;
 
   /**
    * The list of files this file imports.
    */
   List<FileState> get importedFiles => _importedFiles;
 
   /**
+   * Return information about line in the file.
+   */
+  LineInfo get lineInfo => _lineInfo;
+
+  /**
    * The list of files this library file references as parts.
    */
   List<FileState> get partedFiles => _partedFiles;
 
   /**
-   * The [Source] of the file in the [SourceFactory].
-   */
-  Source get source => _source;
-
-  /**
    * The [UnlinkedUnit] of the file.
    */
   UnlinkedUnit get unlinked => _unlinked;
 
   /**
    * Read the file content and ensure that all of the file properties are
    * consistent with the read content, including API signature.
    *
    * Return `true` if the API signature changed since the last refresh.
    */
@@ skipping 28 matching lines @@
       signature.addBytes(contentBytes);
       unlinkedKey = '${signature.toHex()}.unlinked';
     }
 
     // Prepare bytes of the unlinked bundle - existing or new.
     List<int> bytes;
     {
       bytes = _fsState._byteStore.get(unlinkedKey);
       if (bytes == null) {
         CompilationUnit unit =
-            _parse(_source, _content, _fsState._analysisOptions);
+            _parse(source, _content, _fsState._analysisOptions);
         _fsState._logger.run('Create unlinked for $path', () {
           UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
           bytes = unlinkedUnit.toBuffer();
           _fsState._byteStore.put(unlinkedKey, bytes);
         });
       }
     }
 
     // Read the unlinked bundle.
     _unlinked = new UnlinkedUnit.fromBuffer(bytes);
     _lineInfo = new LineInfo(_unlinked.lineStarts);
     List<int> newApiSignature = _unlinked.apiSignature;
     bool apiSignatureChanged = _apiSignature != null &&
         !_equalByteLists(_apiSignature, newApiSignature);
     _apiSignature = newApiSignature;
 
     // Build the graph.
     _importedFiles = <FileState>[];
     _exportedFiles = <FileState>[];
     _partedFiles = <FileState>[];
     for (UnlinkedImport import in _unlinked.imports) {
       if (!import.isImplicit) {
         String uri = import.uri;
         if (!_isDartUri(uri)) {
           FileState file = _fileForRelativeUri(uri);
-          _importedFiles.add(file);
+          if (file != null) {
+            _importedFiles.add(file);
+          }
         }
       }
     }
     for (UnlinkedExportPublic export in _unlinked.publicNamespace.exports) {
       String uri = export.uri;
       if (!_isDartUri(uri)) {
         FileState file = _fileForRelativeUri(uri);
-        _exportedFiles.add(file);
+        if (file != null) {
+          _exportedFiles.add(file);
+        }
       }
     }
     for (String uri in _unlinked.publicNamespace.parts) {
       if (!_isDartUri(uri)) {
         FileState file = _fileForRelativeUri(uri);
-        _partedFiles.add(file);
+        if (file != null) {
+          _partedFiles.add(file);
+        }
       }
     }
 
     // Compute direct dependencies.
     _dependencies = (new Set<FileState>()
           ..addAll(_importedFiles)
           ..addAll(_exportedFiles)
           ..addAll(_partedFiles))
         .toList();
 
     // Return whether the API signature changed.
     return apiSignatureChanged;
   }
 
   @override
   String toString() => path;
 
   /**
    * Return the [FileState] for the given [relativeUri].
    */
   FileState _fileForRelativeUri(String relativeUri) {
     Uri absoluteUri = resolveRelativeUri(uri, FastUri.parse(relativeUri));
-    String absolutePath = _fsState._sourceFactory
-        .resolveUri(null, absoluteUri.toString())
-        .fullName;
-    return _fsState.getFile(absolutePath, absoluteUri);
+    return _fsState.getFileForUri(absoluteUri);
   }
 
   /**
    * Return `true` if the given byte lists are equal.
    */
   static bool _equalByteLists(List<int> a, List<int> b) {
     if (a == null) {
       return b == null;
     } else if (b == null) {
       return false;
@@ skipping 39 matching lines @@
  */
 class FileSystemState {
   final PerformanceLog _logger;
   final ResourceProvider _resourceProvider;
   final ByteStore _byteStore;
   final FileContentOverlay _contentOverlay;
   final SourceFactory _sourceFactory;
   final AnalysisOptions _analysisOptions;
   final Uint32List _salt;
 
-  final Map<String, FileState> _pathToFile = <String, FileState>{};
+  /**
+   * Mapping from a URI to the corresponding [FileState].
+   */
+  final Map<Uri, FileState> _uriToFile = {};
+
+  /**
+   * Mapping from a path to the corresponding [FileState]s, canonical or not.
+   */
+  final Map<String, List<FileState>> _pathToFiles = {};
+
+  /**
+   * Mapping from a path to the corresponding canonical [FileState].
+   */
+  final Map<String, FileState> _pathToCanonicalFile = {};
 
   FileSystemState(
       this._logger,
       this._byteStore,
       this._contentOverlay,
       this._resourceProvider,
       this._sourceFactory,
       this._analysisOptions,
       this._salt);
 
   /**
-   * Return the [FileState] for the give [path]. The returned file has the
-   * last known state since if was last refreshed.
+   * Return the canonical [FileState] for the given absolute [path]. The
+   * returned file has the last known state since if was last refreshed.
+   *
+   * Here "canonical" means that if the [path] is in a package `lib` then the
+   * returned file will have the `package:` style URI.
    */
-  FileState getFile(String path, [Uri uri]) {
-    FileState file = _pathToFile[path];
+  FileState getFileForPath(String path) {
+    FileState file = _pathToCanonicalFile[path];
     if (file == null) {
-      uri ??= _uriForPath(path);
-      file = new FileState(this, path, uri);
-      _pathToFile[path] = file;
+      File resource = _resourceProvider.getFile(path);
+      Source fileSource = resource.createSource();
+      Uri uri = _sourceFactory.restoreUri(fileSource);
+      // Try to get the existing instance.
+      file = _uriToFile[uri];
+      // If we have a file, call it the canonical one and return it.
+      if (file != null) {
+        _pathToCanonicalFile[path] = file;
+        return file;
+      }
+      // Create a new file.
+      FileSource uriSource = new FileSource(resource, uri);
+      file = new FileState._(this, path, uri, uriSource);
+      _uriToFile[uri] = file;
+      _pathToFiles.putIfAbsent(path, () => <FileState>[]).add(file);
+      _pathToCanonicalFile[path] = file;
       file.refresh();
     }
     return file;
   }
 
   /**
-   * Return the default [Uri] for the given path in [_sourceFactory].
+   * Return the [FileState] for the given absolute [uri]. May return `null` if
+   * the [uri] is invalid, e.g. a `package:` URI without a package name. The
+   * returned file has the last known state since if was last refreshed.
    */
-  Uri _uriForPath(String path) {
-    Source fileSource = _resourceProvider.getFile(path).createSource();
-    return _sourceFactory.restoreUri(fileSource);
+  FileState getFileForUri(Uri uri) {
+    FileState file = _uriToFile[uri];
+    if (file == null) {
+      Source uriSource = _sourceFactory.resolveUri(null, uri.toString());
+      // If the URI is invalid, for example package:/test/d.dart (note the
+      // leading '/'), then `null` is returned. We should ignore this URI.
+      if (uriSource == null) {
+        return null;
+      }
+      String path = uriSource.fullName;
+      File resource = _resourceProvider.getFile(path);
+      FileSource source = new FileSource(resource, uri);
+      file = new FileState._(this, path, uri, source);
+      _uriToFile[uri] = file;
+      _pathToFiles.putIfAbsent(path, () => <FileState>[]).add(file);
+      file.refresh();
+    }
+    return file;
+  }
+
+  /**
+   * Return the list of all [FileState]s corresponding to the given [path]. The
+   * list has at least one item, and the first item is the canonical file.
+   */
+  List<FileState> getFilesForPath(String path) {
+    FileState canonicalFile = getFileForPath(path);
+    List<FileState> allFiles = _pathToFiles[path].toList();
+    if (allFiles.length == 1) {
+      return allFiles;
+    }
+    return allFiles
+      ..remove(canonicalFile)
+      ..insert(0, canonicalFile);
   }
 }