Pass backend Target into Kernel driver.

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/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
 import 'package:kernel/kernel.dart' hide Source;
-import 'package:kernel/target/targets.dart' show TargetFlags;
-import 'package:kernel/target/vm_fasta.dart' show VmFastaTarget;
+import 'package:kernel/target/targets.dart' show Target;
 import 'package:meta/meta.dart';
 
 /// This function is invoked for each newly discovered file, and the returned
 /// [Future] is awaited before reading the file content.
 typedef Future<Null> KernelDriverFileAddedFn(Uri uri);
 
 /// This class computes [KernelResult]s for Dart files.
 ///
 /// Let the "current file state" represent a map from file URI to the file
 /// contents most recently read from that file. When the driver needs to
@@ skipping 18 matching lines @@
 
   /// 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;
 
-  /// Is `true` if strong mode analysis should be used.
-  final bool _strongMode;
+  /// The backend target to generate kernels for.
+  final Target _target;
 
   /// 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 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._logger, this._fileSystem, this._byteStore,
-      this._uriTranslator, this._strongMode,
+      this._uriTranslator, this._target,
       {KernelDriverFileAddedFn fileAddedFn})
       : _fileAddedFn = fileAddedFn {
     _computeSalt();
 
     Future<Null> onFileAdded(Uri uri) {
       if (_fileAddedFn != null) {
         return _fileAddedFn(uri);
       }
       return new Future.value();
     }
@@ skipping 30 matching lines @@
         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,
-          new VmFastaTarget(new TargetFlags(strongMode: _strongMode)));
+      DillTarget dillTarget =
+          new DillTarget(new Ticker(isVerbose: false), _uriTranslator, _target);
 
       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 129 matching lines @@
           }
         }
       }
     } while (wasChanged);
   }
 
   /// Compute salt and put into [_salt].
   void _computeSalt() {
     var saltBuilder = new ApiSignature();
     saltBuilder.addInt(DATA_VERSION);
-    saltBuilder.addBool(_strongMode);
+    saltBuilder.addBool(_target.strongMode);
     _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 70 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 = [];
 }