Pass FileSystemState into FileTracker.

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/context/context_root.dart';
 import 'package:analyzer/context/declared_variables.dart';
@@ skipping 222 matching lines @@
   final StreamController<ExceptionResult> _exceptionController =
       new StreamController<ExceptionResult>();
 
   /**
    * The instance of the [Search] helper.
    */
   Search _search;
 
   AnalysisDriverTestView _testView;
 
+  FileSystemState _fsState;
+
   /**
    * The [FileTracker] used by this driver.
    */
   FileTracker _fileTracker;
 
   /**
    * When this flag is set to `true`, the set of analyzed files must not change,
    * and all [AnalysisResult]s are cached infinitely.
    *
    * The flag is intended to be used for non-interactive clients, like DDC,
@@ skipping 32 matching lines @@
       this._analysisOptions,
       {PackageBundle sdkBundle,
       this.disableChangesAndCacheAllResults: false,
       SummaryDataStore externalSummaries})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle,
         _externalSummaries = externalSummaries {
     _onResults = _resultController.stream.asBroadcastStream();
     _testView = new AnalysisDriverTestView(this);
-    _createFileTracker(logger);
+    _createFileTracker();
     _scheduler.add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
   Set<String> get addedFiles => _fileTracker.addedFiles;
 
   /**
    * Return the analysis options used to control analysis.
    */
   AnalysisOptions get analysisOptions => _analysisOptions;
 
   /**
    * Return the stream that produces [ExceptionResult]s.
    */
   Stream<ExceptionResult> get exceptions => _exceptionController.stream;
 
   /**
    * The current file system state.
    */
-  FileSystemState get fsState => _fileTracker.fsState;
+  FileSystemState get fsState => _fsState;
 
   /**
    * Return `true` if the driver has a file to analyze.
    */
   bool get hasFilesToAnalyze {
     return _fileTracker.hasChangedFiles ||
         _requestedFiles.isNotEmpty ||
         _requestedParts.isNotEmpty ||
         _fileTracker.hasPendingFiles ||
         _partsToAnalyze.isNotEmpty;
   }
 
   /**
    * Return the set of files that are known at this moment. This set does not
    * always include all added files or all implicitly used file. If a file has
    * not been processed yet, it might be missing.
    */
-  Set<String> get knownFiles => _fileTracker.fsState.knownFilePaths;
+  Set<String> get knownFiles => _fsState.knownFilePaths;
 
   /**
    * Return the path of the folder at the root of the context.
    */
   String get name => contextRoot?.root ?? '';
 
   /**
    * Return the number of files scheduled for analysis.
    */
   int get numberOfFilesToAnalyze => _fileTracker.numberOfPendingFiles;
@@ skipping 112 matching lines @@
   }
 
   /**
    * Add the file with the given [path] to the set of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis are eventually produced by the [results] stream.
    */
   void addFile(String path) {
-    if (!_fileTracker.fsState.hasUri(path)) {
+    if (!_fsState.hasUri(path)) {
       return;
     }
     if (AnalysisEngine.isDartFileName(path)) {
       _fileTracker.addFile(path);
     }
   }
 
   /**
    * The file with the given [path] might have changed - updated, added or
    * removed. Or not, we don't know. Or it might have, but then changed back.
@@ skipping 27 matching lines @@
    */
   void configure(
       {AnalysisOptions analysisOptions, SourceFactory sourceFactory}) {
     if (analysisOptions != null) {
       _analysisOptions = analysisOptions;
     }
     if (sourceFactory != null) {
       _sourceFactory = sourceFactory;
     }
     Iterable<String> addedFiles = _fileTracker.addedFiles;
-    _createFileTracker(_logger);
+    _createFileTracker();
     _fileTracker.addFiles(addedFiles);
   }
 
   /**
    * Notify the driver that the client is going to stop using it.
    */
   void dispose() {
     _scheduler._remove(this);
   }
 
@@ skipping 48 matching lines @@
     _scheduler.notify(this);
     return task.completer.future;
   }
 
   /**
    * Return a [Future] that completes with the [AnalysisDriverUnitIndex] for
    * the file with the given [path], or with `null` if the file cannot be
    * analyzed.
    */
   Future<AnalysisDriverUnitIndex> getIndex(String path) {
-    if (!_fileTracker.fsState.hasUri(path)) {
+    if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<AnalysisDriverUnitIndex>();
     _indexRequestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisDriverUnitIndex>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
@@ skipping 15 matching lines @@
    *
    * If the driver has the cached analysis result for the file, it is returned.
    *
    * Otherwise causes the analysis state to transition to "analyzing" (if it is
    * not in that state already), the driver will produce the analysis result for
    * it, which is consistent with the current file state (including new states
    * of the files previously reported using [changeFile]), prior to the next
    * time the analysis state transitions to "idle".
    */
   Future<AnalysisResult> getResult(String path) {
-    if (!_fileTracker.fsState.hasUri(path)) {
+    if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
 
     // Return the cached result.
     {
       AnalysisResult result = _priorityResults[path];
       if (disableChangesAndCacheAllResults) {
         result ??= _allCachedResults[path];
       }
       if (result != null) {
@@ skipping 12 matching lines @@
 
   /**
    * Return a [Future] that completes with the [SourceKind] for the Dart
    * file with the given [path]. If the file is not a Dart file or cannot
    * be analyzed, the [Future] completes with `null`.
    *
    * The [path] must be absolute and normalized.
    */
   Future<SourceKind> getSourceKind(String path) async {
     if (AnalysisEngine.isDartFileName(path)) {
-      FileState file = _fileTracker.fsState.getFileForPath(path);
+      FileState file = _fsState.getFileForPath(path);
       return file.isPart ? SourceKind.PART : SourceKind.LIBRARY;
     }
     return null;
   }
 
   /**
    * Return a [Future] that completes with top-level declarations with the
    * given [name] in all known libraries.
    */
   Future<List<TopLevelDeclarationInSource>> getTopLevelNameDeclarations(
       String name) {
     var task = new _TopLevelNameDeclarationsTask(this, name);
     _topLevelNameDeclarationsTasks.add(task);
     _scheduler.notify(this);
     return task.completer.future;
   }
 
   /**
    * Return a [Future] that completes with the [UnitElementResult] for the
    * file with the given [path], or with `null` if the file cannot be analyzed.
    */
   Future<UnitElementResult> getUnitElement(String path) {
-    if (!_fileTracker.fsState.hasUri(path)) {
+    if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<UnitElementResult>();
     _unitElementRequestedFiles
         .putIfAbsent(path, () => <Completer<UnitElementResult>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
   /**
    * Return a [Future] that completes with the signature for the
    * [UnitElementResult] for the file with the given [path], or with `null` if
    * the file cannot be analyzed.
    *
    * The signature is based the APIs of the files of the library (including
    * the file itself) of the requested file and the transitive closure of files
    * imported and exported by the the library.
    */
   Future<String> getUnitElementSignature(String path) {
-    if (!_fileTracker.fsState.hasUri(path)) {
+    if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<String>();
     _unitElementSignatureRequests
         .putIfAbsent(path, () => <Completer<String>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
@@ skipping 241 matching lines @@
    * analyzed anyway, even without a library.
    *
    * Return [AnalysisResult._UNCHANGED] if [skipIfSameSignature] is `true` and
    * the resolved signature of the file in its library is the same as the one
    * that was the most recently produced to the client.
    */
   AnalysisResult _computeAnalysisResult(String path,
       {bool withUnit: false,
       bool asIsIfPartWithoutLibrary: false,
       bool skipIfSameSignature: false}) {
-    FileState file = _fileTracker.fsState.getFileForPath(path);
+    FileState file = _fsState.getFileForPath(path);
 
     // Prepare the library - the file itself, or the known library.
     FileState library = file.isPart ? file.library : file;
     if (library == null) {
       if (asIsIfPartWithoutLibrary) {
         library = file;
       } else {
         return null;
       }
     }
@@ skipping 21 matching lines @@
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       try {
         LibraryContext libraryContext = _createLibraryContext(library);
         try {
           _testView.numOfAnalyzedLibraries++;
           LibraryAnalyzer analyzer = new LibraryAnalyzer(
               analysisOptions,
               declaredVariables,
               sourceFactory,
-              _fileTracker.fsState,
+              _fsState,
               libraryContext.store,
               library);
           Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
 
           List<int> bytes;
           CompilationUnit resolvedUnit;
           for (FileState unitFile in results.keys) {
             UnitAnalysisResult unitResult = results[unitFile];
             List<int> unitBytes =
                 _serializeResolvedUnit(unitResult.unit, unitResult.errors);
@@ skipping 33 matching lines @@
     });
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
   }
 
   UnitElementResult _computeUnitElement(String path) {
-    FileState file = _fileTracker.fsState.getFileForPath(path);
+    FileState file = _fsState.getFileForPath(path);
     FileState library = file.library ?? file;
 
     // Create the AnalysisContext to resynthesize elements in.
     LibraryContext libraryContext = _createLibraryContext(library);
 
     // Resynthesize the CompilationUnitElement in the context.
     try {
       CompilationUnitElement element =
           libraryContext.computeUnitElement(library.source, file.source);
       String signature = library.transitiveSignature;
       return new UnitElementResult(path, file.contentHash, signature, element);
     } finally {
       libraryContext.dispose();
     }
   }
 
   String _computeUnitElementSignature(String path) {
-    FileState file = _fileTracker.fsState.getFileForPath(path);
+    FileState file = _fsState.getFileForPath(path);
     FileState library = file.library ?? file;
     return library.transitiveSignature;
   }
 
   /**
-   * Creates a new [FileTracker] object and stores it in [_fileTracker].
+   * Creates new [FileSystemState] and [FileTracker] objects.
    *
    * This is used both on initial construction and whenever the configuration
    * changes.
    */
-  void _createFileTracker(PerformanceLog logger) {
+  void _createFileTracker() {
     _fillSalt();
-    _fileTracker = new FileTracker(
-        logger,
-        _byteStore,
-        _contentOverlay,
-        _resourceProvider,
-        sourceFactory,
-        _analysisOptions,
-        _salt,
-        _externalSummaries,
-        _changeHook);
+    _fsState = new FileSystemState(_logger, _byteStore, _contentOverlay,
+        _resourceProvider, sourceFactory, analysisOptions, _salt,
+        externalSummaries: _externalSummaries);
+    _fileTracker = new FileTracker(_logger, _fsState, _changeHook);
   }
 
   /**
    * Return the context in which the [library] should be analyzed.
    */
   LibraryContext _createLibraryContext(FileState library) =>
       new LibraryContext.forSingleLibrary(
           library,
           _logger,
           _sdkBundle,
@@ skipping 848 matching lines @@
       }
 
       // If no more files to check, complete and done.
       if (filesToCheck.isEmpty) {
         completer.complete(definingFiles);
         return true;
       }
 
       // Check the next file.
       String path = filesToCheck.removeLast();
-      FileState file = driver._fileTracker.fsState.getFileForPath(path);
+      FileState file = driver._fsState.getFileForPath(path);
       if (file.definedClassMemberNames.contains(name)) {
         definingFiles.add(path);
       }
       checkedFiles.add(path);
     }
 
     // We're not done yet.
     return false;
   }
 }
@@ skipping 36 matching lines @@
       }
 
       // If no more files to check, complete and done.
       if (filesToCheck.isEmpty) {
         completer.complete(referencingFiles);
         return true;
       }
 
       // Check the next file.
       String path = filesToCheck.removeLast();
-      FileState file = driver._fileTracker.fsState.getFileForPath(path);
+      FileState file = driver._fsState.getFileForPath(path);
       if (file.referencedNames.contains(name)) {
         referencingFiles.add(path);
       }
       checkedFiles.add(path);
     }
 
     // We're not done yet.
     return false;
   }
 }
@@ skipping 29 matching lines @@
 
     // If no more files to check, complete and done.
     if (filesToCheck.isEmpty) {
       completer.complete(libraryDeclarations);
       return true;
     }
 
     // Check the next file.
     String path = filesToCheck.removeLast();
     if (checkedFiles.add(path)) {
-      FileState file = driver._fileTracker.fsState.getFileForPath(path);
+      FileState file = driver._fsState.getFileForPath(path);
       if (!file.isPart) {
         bool isExported = false;
         TopLevelDeclaration declaration = file.topLevelDeclarations[name];
         for (FileState part in file.partedFiles) {
           declaration ??= part.topLevelDeclarations[name];
         }
         if (declaration == null) {
           declaration = file.exportedTopLevelDeclarations[name];
           isExported = true;
         }
         if (declaration != null) {
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }