Load extraRequiredLibraries from the target passed in the options

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:convert';
 import 'dart:typed_data';
 
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/resolve_relative_uri.dart';
 import 'package:front_end/src/dependency_walker.dart' as graph;
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/incremental/format.dart';
 import 'package:front_end/src/incremental/unlinked_unit.dart';
-import 'package:kernel/target/vm.dart';
+import 'package:kernel/target/targets.dart';
 
 /// This function is called for each newly discovered file, and the returned
 /// [Future] is awaited before reading the file content.
 typedef Future<Null> NewFileFn(Uri uri);
 
 /// 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
@@ skipping 146 matching lines @@
       if (coreFile != null) {
         _importedLibraries.add(coreFile);
       }
     }
     for (var import_ in unlinkedUnit.imports) {
       FileState file = await _getFileForRelativeUri(import_.uri);
       if (file != null) {
         _importedLibraries.add(file);
       }
     }
-    await _addVmTargetImportsForCore();
+    await _addTargetExtraRequiredLibraries();
     for (var export_ in unlinkedUnit.exports) {
       FileState file = await _getFileForRelativeUri(export_.uri);
       if (file != null) {
         _exportedLibraries.add(file);
         _exports.add(new NamespaceExport(file, export_.combinators));
       }
     }
     for (var part_ in unlinkedUnit.parts) {
       FileState file = await _getFileForRelativeUri(part_);
       if (file != null) {
@@ skipping 25 matching lines @@
       }
     }
   }
 
   @override
   String toString() {
     if (uri.scheme == 'file') return uri.path;
     return uri.toString();
   }
 
-  /// 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 {
+  /// Fasta unconditionally loads extra libraries based on the target.  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,sigmund): remove this implicit import, instead make fasta
+  /// and IKG aware of extra code that needs to be loaded.
+  Future<Null> _addTargetExtraRequiredLibraries() async {
     if (uri.toString() != 'dart:core') return;
-    for (String uri in new VmTarget(null).extraRequiredLibraries) {
+    for (String uri in _fsState.target.extraRequiredLibraries) {
       FileState file = await _getFileForRelativeUri(uri);
       // TODO(scheglov) add error handling
       if (file != null) {
         _importedLibraries.add(file);
       }
     }
   }
 
   /// Return the [FileState] for the given [relativeUri] or `null` if the URI
   /// cannot be parsed, cannot correspond any file, etc.
@@ skipping 12 matching lines @@
     }
 
     return await _fsState.getFile(absoluteUri);
   }
 }
 
 /// Information about known file system state.
 class FileSystemState {
   final ByteStore _byteStore;
   final FileSystem fileSystem;
+  final Target target;
   final UriTranslator uriTranslator;
   final List<int> _salt;
   final NewFileFn _newFileFn;
 
   _FileSystemView _fileSystemView;
 
   /// Mapping from import URIs to corresponding [FileState]s. For example, this
   /// may contain an entry for `dart:core`.
   final Map<Uri, FileState> _uriToFile = {};
 
   /// Mapping from file URIs to corresponding [FileState]s. This map should only
   /// contain `file:*` URIs as keys.
   final Map<Uri, FileState> _fileUriToFile = {};
 
   /// The set of absolute URIs with the `dart` scheme that should be skipped.
   /// We do this when we use SDK outline instead of compiling SDK sources.
   final Set<Uri> skipSdkLibraries = new Set<Uri>();
 
-  FileSystemState(this._byteStore, this.fileSystem, this.uriTranslator,
-      this._salt, this._newFileFn);
+  FileSystemState(this._byteStore, this.fileSystem, this.target,
+      this.uriTranslator, this._salt, this._newFileFn);
 
   /// 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);
   }
 
   /// The `file:` URI of all files currently tracked by this instance.
@@ skipping 220 matching lines @@
       cycle.libraries.add(node.file);
       fileToCycleMap[node.file] = cycle;
     }
     topologicallySortedCycles.add(cycle);
   }
 
   _LibraryNode getNode(FileState file) {
     return nodesOfFiles.putIfAbsent(file, () => new _LibraryNode(this, file));
   }
 }