Implement GC for FileState(s).

pkg/front_end/lib/src/incremental_kernel_generator_impl.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:io';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/src/base/api_signature.dart';
@@ skipping 61 matching lines @@
   /// The set of absolute file URIs that were reported through [invalidate]
   /// and not checked for actual changes yet.
   final Set<Uri> _invalidatedFiles = new Set<Uri>();
 
   IncrementalKernelGeneratorImpl(
       this._options, this._uriTranslator, this._entryPoint,
       {WatchUsedFilesFn watch})
       : _logger = _options.logger,
         _byteStore = _options.byteStore {
     _computeSalt();
+
+    Future<Null> onFileAdded(Uri uri) {
+      if (watch != null) {
+        return watch(uri, true);
+      }
+      return new Future.value();
+    }
+
     _fsState = new FileSystemState(
-        _options.fileSystem, _uriTranslator, _salt, (uri) => watch(uri, true));
+        _options.fileSystem, _uriTranslator, _salt, onFileAdded);
   }
 
   @override
   Future<DeltaProgram> computeDelta() async {
     return await _logger.runAsync('Compute delta', () async {
       await _refreshInvalidatedFiles();
 
       // Ensure that the graph starting at the entry point is ready.
       FileState entryLibrary =
           await _logger.runAsync('Build graph of files', () async {
@@ skipping 203 matching lines @@
       _invalidatedFiles.clear();
 
       // Refresh the files.
       for (var fileUri in invalidatedFiles) {
         var file = _fsState.getFileByFileUri(fileUri);
         if (file != null) {
           _logger.writeln('Refresh $fileUri');
           await file.refresh();
         }
       }
+
+      // The file graph might have changed, perform GC.
+      _fsState.gc(_entryPoint);
     });
   }
 
   List<int> _writeProgramBytes(Program program, bool filter(Library library)) {
     ByteSink byteSink = new ByteSink();
     new LimitedBinaryPrinter(byteSink, filter).writeProgramFile(program);
     return byteSink.builder.takeBytes();
   }
 }
 
 /// Compilation result for a library cycle.
 class _LibraryCycleResult {
   final LibraryCycle cycle;
 
   /// The signature of the result.
   ///
   /// Currently it is based on the full content of the transitive closure of
   /// the [cycle] files and all its dependencies.
   /// TODO(scheglov) Not used yet.
   /// TODO(scheglov) Use API signatures.
   /// TODO(scheglov) Or use tree shaking and compute signatures of outlines.
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   _LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }