Add support for SDK outline in KernelDriver.

pkg/front_end/lib/src/incremental/kernel_driver.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 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/api_signature.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
@@ skipping 33 matching lines @@
 /// A call to [invalidate] removes the specified file from the current file
 /// state, so that it will be reread before any following [getKernel] will
 /// return a result.
 class KernelDriver {
   /// The version of data format, should be incremented on every format change.
   static const int DATA_VERSION = 1;
 
   /// Options used by the kernel compiler.
   final ProcessedOptions _options;
 
+  /// The optional SDK outline as a serialized program.
+  /// If provided, the driver will not attempt to read SDK files.
+  final List<int> _sdkOutlineBytes;
+
   /// The logger to report compilation progress.
   final PerformanceLog _logger;
 
   /// The [FileSystem] which should be used by the front end to access files.
   final FileSystem _fileSystem;
 
   /// The byte storage to get and put serialized data.
   final ByteStore _byteStore;
 
   /// The object that knows how to resolve "package:" and "dart:" URIs.
   final UriTranslator _uriTranslator;
 
   /// The function that is invoked when a new file is about to be added to
   /// the current file state. The [Future] that it returns is awaited before
   /// reading the file contents.
   final KernelDriverFileAddedFn _fileAddedFn;
 
+  /// The optional SDK outline loaded from [_sdkOutlineBytes].
+  /// Might be `null` if the bytes are not provided, or if not loaded yet.
+  Program _sdkOutline;
+
   /// The salt to mix into all hashes used as keys for serialized data.
   List<int> _salt;
 
   /// The current file system state.
   FileSystemState _fsState;
 
   /// 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>();
 
   /// The object that provides additional information for tests.
   final _TestView _testView = new _TestView();
 
   KernelDriver(this._options, this._uriTranslator,
-      {KernelDriverFileAddedFn fileAddedFn})
+      {List<int> sdkOutlineBytes, KernelDriverFileAddedFn fileAddedFn})
       : _logger = _options.logger,
         _fileSystem = _options.fileSystem,
         _byteStore = _options.byteStore,
+        _sdkOutlineBytes = sdkOutlineBytes,
         _fileAddedFn = fileAddedFn {
     _computeSalt();
 
     Future<Null> onFileAdded(Uri uri) {
       if (_fileAddedFn != null) {
         return _fileAddedFn(uri);
       }
       return new Future.value();
     }
 
@@ skipping 16 matching lines @@
   /// reported using [invalidate].
   ///
   /// If the driver has the cached result for the file with the current file
   /// state, it is returned.
   ///
   /// Otherwise the driver will compute new kernel files and return them.
   Future<KernelResult> getKernel(Uri uri) async {
     return await runWithFrontEndContext('Compute delta', () async {
       await _refreshInvalidatedFiles();
 
+      // Load the SDK outline before building the graph, so that the file
+      // system state is configured to skip SDK libraries.
+      await _loadSdkOutline();
+
       // Ensure that the graph starting at the entry point is ready.
       FileState entryLibrary =
           await _logger.runAsync('Build graph of files', () async {
         return await _fsState.getFile(uri);
       });
 
       List<LibraryCycle> cycles = _logger.run('Compute library cycles', () {
         List<LibraryCycle> cycles = entryLibrary.topologicalOrder;
         _logger.writeln('Computed ${cycles.length} cycles.');
         return cycles;
       });
 
       CanonicalName nameRoot = new CanonicalName.root();
       DillTarget dillTarget = new DillTarget(
           new Ticker(isVerbose: false), _uriTranslator, _options.target);
 
+      // If there is SDK outline, load it.
+      if (_sdkOutline != null) {
+        dillTarget.loader.appendLibraries(_sdkOutline);
+        await dillTarget.buildOutlines();
+      }
+
       List<LibraryCycleResult> results = [];
       _testView.compiledCycles.clear();
       await _logger.runAsync('Compute results for cycles', () async {
         for (LibraryCycle cycle in cycles) {
           LibraryCycleResult result =
               await _compileCycle(nameRoot, dillTarget, cycle);
           results.add(result);
         }
       });
 
@@ skipping 139 matching lines @@
         }
       }
     } while (wasChanged);
   }
 
   /// Compute salt and put into [_salt].
   void _computeSalt() {
     var saltBuilder = new ApiSignature();
     saltBuilder.addInt(DATA_VERSION);
     saltBuilder.addBool(_options.strongMode);
+    if (_sdkOutlineBytes != null) {
+      saltBuilder.addBytes(_sdkOutlineBytes);
+    }
     _salt = saltBuilder.toByteList();
   }
 
   String _getCycleSignature(LibraryCycle cycle) {
     bool hasMixinApplication =
         cycle.libraries.any((library) => library.hasMixinApplicationLibrary);
     var signatureBuilder = new ApiSignature();
     signatureBuilder.addBytes(_salt);
     Set<FileState> transitiveFiles = cycle.libraries
         .map((library) => library.transitiveFiles)
@@ skipping 18 matching lines @@
     for (var library in cycle.libraries) {
       signatureBuilder.addBytes(library.contentHash);
       for (var part in library.partFiles) {
         signatureBuilder.addBytes(part.contentHash);
       }
     }
 
     return signatureBuilder.toHex();
   }
 
+  /// Load the SDK outline if its bytes are provided, and configure the file
+  /// system state to skip SDK library files.
+  Future<Null> _loadSdkOutline() async {
+    if (_sdkOutlineBytes != null) {
+      if (_sdkOutline == null) {
+        await _logger.runAsync('Load SDK outline from bytes.', () async {
+          _sdkOutline = new Program();
+          new BinaryBuilder(_sdkOutlineBytes).readProgram(_sdkOutline);
+          // Configure the file system state to skip the outline libraries.
+          for (var outlineLibrary in _sdkOutline.libraries) {
+            _fsState.skipSdkLibraries.add(outlineLibrary.importUri);
+          }
+        });
+      }
+    }
+  }
+
   /// Refresh all the invalidated files and update dependencies.
   Future<Null> _refreshInvalidatedFiles() async {
     await _logger.runAsync('Refresh invalidated files', () async {
       // Create a copy to avoid concurrent modifications.
       var invalidatedFiles = _invalidatedFiles.toList();
       _invalidatedFiles.clear();
 
       // Refresh the files.
       for (var fileUri in invalidatedFiles) {
         var file = _fsState.getFileByFileUri(fileUri);
@@ skipping 33 matching lines @@
 
   LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }
 
 @visibleForTesting
 class _TestView {
   /// The list of [LibraryCycle]s compiled for the last delta.
   /// It does not include libraries which were read from the cache.
   final List<LibraryCycle> compiledCycles = [];
 }