Start actually adding incrementality into incremental kernel generator.

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/dependency_walker.dart' as graph;
 import 'package:front_end/src/fasta/parser/top_level_parser.dart';
 import 'package:front_end/src/fasta/scanner.dart';
 import 'package:front_end/src/fasta/source/directive_listener.dart';
 import 'package:front_end/src/fasta/translate_uri.dart';
+import 'package:kernel/target/vm.dart';
 
 /// Information about a file being compiled, explicitly or implicitly.
 ///
 /// It provides a consistent view on its properties.
 ///
 /// The properties are not guaranteed to represent the most recent state
 /// of the file system. To update the file to the most recent state, [refresh]
 /// should be called.
 class FileState {
   final FileSystemState _fsState;
 
+  /// The absolute URI of the file.
+  final Uri uri;
+
   /// The resolved URI of the file in the file system.
   final Uri fileUri;
 
   bool _exists;
   List<int> _content;
+  List<int> _contentHash;
 
   List<FileState> _importedLibraries;
   List<FileState> _exportedLibraries;
   List<FileState> _partFiles;
 
+  Set<FileState> _directReferencedFiles = new Set<FileState>();
   List<FileState> _directReferencedLibraries = <FileState>[];
 
-  FileState._(this._fsState, this.fileUri);
+  FileState._(this._fsState, this.uri, this.fileUri);
 
   /// The content of the file.
   List<int> get content => _content;
 
+  /**

[Siggi Cherem (dart-lang), 2017/05/16 21:37:01]

nit: let's only use "///" for dartdocs

[scheglov, 2017/05/16 22:03:38]

Fixed.
I try to follow this style.

+   * The MD5 hash of the [content].
+   */
+  List<int> get contentHash => _contentHash;
+
   /// Libraries that this library file directly imports or exports.
   List<FileState> get directReferencedLibraries => _directReferencedLibraries;
 
   /// Whether the file exists.
   bool get exists => _exists;
 
   /// The list of the libraries exported by this library.
   List<FileState> get exportedLibraries => _exportedLibraries;
 
   @override
-  int get hashCode => fileUri.hashCode;
+  int get hashCode => uri.hashCode;
 
   /// The list of the libraries imported by this library.
   List<FileState> get importedLibraries => _importedLibraries;
 
   /// The list of files this library file references as parts.
   List<FileState> get partFiles => _partFiles;
 
   /// Return topologically sorted cycles of dependencies for this library.
   List<LibraryCycle> get topologicalOrder {
     var libraryWalker = new _LibraryWalker();
     libraryWalker.walk(libraryWalker.getNode(this));
     return libraryWalker.topologicallySortedCycles;
   }
 
+  /// Return the set of transitive files - the file itself and all of the
+  /// directly or indirectly referenced files.
+  Set<FileState> get transitiveFiles {
+    // TODO(scheglov) add caching.
+    var transitiveFiles = new Set<FileState>();
+
+    void appendReferenced(FileState file) {
+      if (transitiveFiles.add(file)) {
+        file._directReferencedFiles.forEach(appendReferenced);
+      }
+    }
+
+    appendReferenced(this);
+    return transitiveFiles;
+  }
+
   @override
   bool operator ==(Object other) {
-    return other is FileState && other.fileUri == fileUri;
+    return other is FileState && other.uri == uri;
   }
 
   /// Read the file content and ensure that all of the file properties are
   /// consistent with the read content, including all its dependencies.
   Future<Null> refresh() async {
     // Read the content.
     try {
       FileSystemEntity entry = _fsState.fileSystem.entityForUri(fileUri);
       _content = await entry.readAsBytes();
       _exists = true;
     } catch (_) {
       _content = new Uint8List(0);
       _exists = false;
     }
 
+    // Compute the content hash.
+    _contentHash = md5.convert(_content).bytes;
+
     // Parse directives.
     ScannerResult scannerResults = _scan();
     var listener = new DirectiveListener();
     new TopLevelParser(listener).parseUnit(scannerResults.tokens);
 
     // Build the graph.
     _importedLibraries = <FileState>[];
     _exportedLibraries = <FileState>[];
     _partFiles = <FileState>[];
     await _addFileForRelativeUri(_importedLibraries, 'dart:core');
     for (String uri in listener.imports) {
       await _addFileForRelativeUri(_importedLibraries, uri);
     }
+    await _addVmTargetImportsForCore();
     for (String uri in listener.exports) {
       await _addFileForRelativeUri(_exportedLibraries, uri);
     }
     for (String uri in listener.parts) {
       await _addFileForRelativeUri(_partFiles, uri);
     }
 
-    // Compute referenced libraries.
+    // Compute referenced files.
+    _directReferencedFiles = new Set<FileState>()
+      ..addAll(_importedLibraries)
+      ..addAll(_exportedLibraries)
+      ..addAll(_partFiles);
     _directReferencedLibraries = (new Set<FileState>()
           ..addAll(_importedLibraries)
           ..addAll(_exportedLibraries))
         .toList();
   }
 
   @override
   String toString() {
     if (fileUri.scheme == 'file') return fileUri.path;
     return fileUri.toString();
   }
 
   /// Add the [FileState] for the given [relativeUri] to the [files].
   /// Do nothing if the URI cannot be parsed, cannot correspond any file, etc.
   Future<Null> _addFileForRelativeUri(
       List<FileState> files, String relativeUri) async {
     if (relativeUri.isEmpty) return;
 
     // Resolve the relative URI into absolute.
     // The result is either:
     //   1) The absolute file URI.
     //   2) The absolute non-file URI, e.g. `package:foo/foo.dart`.
     Uri absoluteUri;
     try {
       absoluteUri = fileUri.resolve(relativeUri);
     } on FormatException {
       return;
     }
 
-    // Resolve the absolute URI into the absolute file URI.
-    Uri resolvedUri;
-    if (absoluteUri.isScheme('file')) {
-      resolvedUri = absoluteUri;
-    } else {
-      resolvedUri = _fsState.uriTranslator.translate(absoluteUri);
-      if (resolvedUri == null) return;
+    FileState file = await _fsState.getFile(absoluteUri);
+    if (file == null) return;
+    files.add(file);
+  }
+
+  /// Fasta unconditionally loads all VM libraries.  In order to be able to
+  /// serve them using the file system view, pretend that all of them were
+  /// imported into `dart:core`.
+  /// TODO(scheglov) Ask VM people whether all these libraries are required.
+  Future<Null> _addVmTargetImportsForCore() async {
+    if (uri.toString() != 'dart:core') return;
+    for (String uri in new VmTarget(null).extraRequiredLibraries) {
+      await _addFileForRelativeUri(_importedLibraries, uri);
     }
-
-    FileState file = await _fsState.getFile(resolvedUri);
-    files.add(file);
   }
 
   /// Scan the content of the file.
   ScannerResult _scan() {
     var zeroTerminatedBytes = new Uint8List(_content.length + 1);
     zeroTerminatedBytes.setRange(0, _content.length, _content);
     return scan(zeroTerminatedBytes);
   }
 }
 
@@ skipping 10 matching lines @@
   FileSystemState(this.fileSystem, this.uriTranslator);
 
   /// Return the [FileSystem] that is backed by this [FileSystemState].  The
   /// 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);
   }
 
-  /// Return the [FileState] for the given resolved file [fileUri].
+  /// 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 fileUri) async {
-    FileState file = _fileUriToFile[fileUri];
+  Future<FileState> getFile(Uri absoluteUri) async {
+    // Resolve the absolute URI into the absolute file URI.
+    Uri fileUri;
+    if (absoluteUri.isScheme('file')) {
+      fileUri = absoluteUri;
+    } else {
+      fileUri = uriTranslator.translate(absoluteUri);
+      if (fileUri == null) return null;
+    }
+
+    FileState file = _fileUriToFile[absoluteUri];
     if (file == null) {
-      file = new FileState._(this, fileUri);
+      file = new FileState._(this, absoluteUri, fileUri);
+      _fileUriToFile[absoluteUri] = file;
       _fileUriToFile[fileUri] = file;
 
       // Build the sub-graph of the file.
       await file.refresh();
     }
     return file;
   }
 }
 
 /// List of libraries that reference each other, so form a cycle.
 class LibraryCycle {
   final List<FileState> libraries = <FileState>[];
 
+  bool get _isForVm {
+    return libraries.any((l) => l.uri.toString().endsWith('dart:_vmservice'));
+  }
+
   @override
-  String toString() => '[' + libraries.join(', ') + ']';
+  String toString() {
+    if (_isForVm) {
+      return '[core + vm]';
+    }
+    return '[' + libraries.join(', ') + ']';
+  }
 }
 
 /// [FileSystemState] based implementation of [FileSystem].
 /// It provides a consistent view on the known file system state.
 class _FileSystemView implements FileSystem {
   final FileSystemState fsState;
 
   _FileSystemView(this.fsState);
 
   @override
@@ skipping 72 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));
   }
 }