Compute and flush sets of transitively referenced files in File[System]State.

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';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/source/source_resource.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
+import 'package:meta/meta.dart';
 
 /**
  * [FileContentOverlay] is used to temporary override content of files.
  */
 class FileContentOverlay {
   final _map = <String, String>{};
 
   /**
    * Return the content of the file with the given [path], or `null` the
    * overlay does not override the content of the file.
@@ skipping 45 matching lines @@
 
   String _content;
   String _contentHash;
   LineInfo _lineInfo;
   UnlinkedUnit _unlinked;
   List<int> _apiSignature;
 
   List<FileState> _importedFiles;
   List<FileState> _exportedFiles;
   List<FileState> _partedFiles;
-  List<FileState> _dependencies;
+  Set<FileState> _directReferencedFiles = new Set<FileState>();
+  Set<FileState> _transitiveFiles;
 
   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 the list of all direct dependencies.
+   * Return the set of all directly referenced files - imported, exported or
+   * parted.
    */
-  List<FileState> get dependencies => _dependencies;
+  Set<FileState> get directReferencedFiles => _directReferencedFiles;
 
   /**
    * The list of files this file exports.
    */
   List<FileState> get exportedFiles => _exportedFiles;
 
   @override
   int get hashCode => uri.hashCode;
 
   /**
@@ skipping 24 matching lines @@
    * 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;
 
   /**
+   * Return the set of transitive files - the file itself and all of the
+   * directly or indirectly referenced files.
+   */
+  Set<FileState> get transitiveFiles {
+    if (_transitiveFiles == null) {
+      _transitiveFiles = new Set<FileState>();
+
+      void appendReferenced(FileState file) {
+        if (_transitiveFiles.add(file)) {
+          file._directReferencedFiles.forEach(appendReferenced);
+        }
+      }
+
+      appendReferenced(this);
+    }
+    return _transitiveFiles;
+  }
+
+  /**
    * The [UnlinkedUnit] of the file.
    */
   UnlinkedUnit get unlinked => _unlinked;
 
   @override
   bool operator ==(Object other) {
     return other is FileState && other.uri == uri;
   }
 
   /**
@@ skipping 112 matching lines @@
         if (file != null) {
           _partedFiles.add(file);
           // TODO(scheglov) Sort for stable results?
           _fsState._partToLibraries
               .putIfAbsent(file, () => <FileState>[])
               .add(this);
         }
       }
     }
 
-    // Compute direct dependencies.
-    _dependencies = (new Set<FileState>()
-          ..addAll(_importedFiles)
-          ..addAll(_exportedFiles)
-          ..addAll(_partedFiles))
-        .toList();
+    // Compute referenced files.
+    Set<FileState> oldDirectReferencedFiles = _directReferencedFiles;
+    _directReferencedFiles = new Set<FileState>()
+      ..addAll(_importedFiles)
+      ..addAll(_exportedFiles)
+      ..addAll(_partedFiles);
+
+    // If the set of directly referenced files of this file is changed,
+    // then the transitive sets of files that include this file are also
+    // changed. Reset these transitive sets.
+    if (_directReferencedFiles.length != oldDirectReferencedFiles.length ||
+        !_directReferencedFiles.containsAll(oldDirectReferencedFiles)) {
+      for (FileState file in _fsState._uriToFile.values) {
+        if (file._transitiveFiles != null &&
+            file._transitiveFiles.contains(this)) {
+          file._transitiveFiles = null;
+        }
+      }
+    }
 
     // Return whether the API signature changed.
     return apiSignatureChanged;
   }
 
   @override
   String toString() => path;
 
   /**
    * Return the [FileState] for the given [relativeUri].
@@ skipping 53 matching lines @@
   /**
    * Mapping from a path to the corresponding canonical [FileState].
    */
   final Map<String, FileState> _pathToCanonicalFile = {};
 
   /**
    * Mapping from a part to the libraries it is a part of.
    */
   final Map<FileState, List<FileState>> _partToLibraries = {};
 
+  FileSystemStateTestView _testView;
+
   FileSystemState(
       this._logger,
       this._byteStore,
       this._contentOverlay,
       this._resourceProvider,
       this._sourceFactory,
       this._analysisOptions,
-      this._salt);
+      this._salt) {
+    _testView = new FileSystemStateTestView(this);
+  }
 
   /**
    * Return the set of known files.
    */
   Set<String> get knownFiles => _pathToFiles.keys.toSet();
 
+  @visibleForTesting
+  FileSystemStateTestView get test => _testView;
+
   /**
    * 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 getFileForPath(String path) {
     FileState file = _pathToCanonicalFile[path];
     if (file == null) {
@@ skipping 51 matching lines @@
     FileState canonicalFile = getFileForPath(path);
     List<FileState> allFiles = _pathToFiles[path].toList();
     if (allFiles.length == 1) {
       return allFiles;
     }
     return allFiles
       ..remove(canonicalFile)
       ..insert(0, canonicalFile);
   }
 }
+
+@visibleForTesting
+class FileSystemStateTestView {
+  final FileSystemState state;
+
+  FileSystemStateTestView(this.state);
+
+  Set<FileState> get filesWithoutTransitive {
+    return state._uriToFile.values
+        .where((f) => f._transitiveFiles == null)
+        .toSet();
+  }
+}