Implement GC for FileState(s).

pkg/front_end/lib/src/incremental/file_state.dart

 // Copyright (c) 2017, 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:typed_data';
 
 import 'package:crypto/crypto.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/api_signature.dart';
@@ skipping 36 matching lines @@
   List<int> _apiSignature;
 
   List<NamespaceExport> _exports;
   List<FileState> _importedLibraries;
   List<FileState> _exportedLibraries;
   List<FileState> _partFiles;
 
   Set<FileState> _directReferencedFiles = new Set<FileState>();
   List<FileState> _directReferencedLibraries = <FileState>[];
 
+  /// This flag is set to `true` during the mark phase of garbage collection
+  /// and set back to `false` for survived instances.
+  bool _gcMarked = false;
+
   FileState._(this._fsState, this.uri, this.fileUri);
 
   /// The MD5 signature of the file API as a byte array.
   /// It depends on all non-comment tokens outside the block bodies.
   List<int> get apiSignature => _apiSignature;
 
   /// The content of the file.
   List<int> get content => _content;
 
   /// The MD5 hash of the [content].
@@ skipping 235 matching lines @@
   /// files in this [FileSystem] always have the same content as the
   /// corresponding [FileState]s, thus avoiding race conditions when a file
   /// is updated on the actual file system.
   FileSystem get fileSystemView {
     return _fileSystemView ??= new _FileSystemView(this);
   }
 
   /// The `file:` URI of all files currently tracked by this instance.
   Iterable<Uri> get fileUris => _fileUriToFile.keys;
 
+  /// Perform mark and sweep garbage collection of [FileState]s.
+  void gc(Uri entryPoint) {
+    void mark(FileState file) {
+      if (!file._gcMarked) {
+        file._gcMarked = true;
+        file._directReferencedFiles.forEach(mark);
+      }
+    }
+
+    var file = _uriToFile[entryPoint];
+    if (file == null) return;
+
+    mark(file);
+
+    var urisToRemove = new Set<Uri>();
+    var fileUrisToRemove = new Set<Uri>();
+    for (var file in _uriToFile.values) {
+      if (file._gcMarked) {
+        file._gcMarked = false;
+      } else {
+        urisToRemove.add(file.uri);
+        fileUrisToRemove.add(file.fileUri);
+      }
+    }
+
+    urisToRemove.forEach(_uriToFile.remove);
+    fileUrisToRemove.forEach(_fileUriToFile.remove);
+  }
+
   /// Return the [FileState] for the given [absoluteUri], or `null` if the
   /// [absoluteUri] cannot be resolved into a file URI.
   ///
   /// The returned file has the last known state since it was last refreshed.
   Future<FileState> getFile(Uri absoluteUri) async {
     // Resolve the absolute URI into the absolute file URI.
     Uri fileUri;
     if (absoluteUri.isScheme('file')) {
       fileUri = absoluteUri;
     } else {
@@ skipping 184 matching lines @@
       node.isEvaluated = true;
       cycle.libraries.add(node.file);
     }
     topologicallySortedCycles.add(cycle);
   }
 
   _LibraryNode getNode(FileState file) {
     return nodesOfFiles.putIfAbsent(file, () => new _LibraryNode(this, file));
   }
 }