Add flag to dart2js to configure whether to use the kernel lowering.

pkg/compiler/lib/src/options.dart

 // Copyright (c) 2016, 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.
 
 library dart2js.src.options;
 
 import '../compiler.dart' show PackagesDiscoveryProvider;
 import 'commandline_options.dart' show Flags;
 
 /// Options used for parsing.
@@ skipping 203 matching lines @@
 
   /// Whether to trust primitive types during inference and optimizations.
   final bool trustPrimitives;
 
   /// Whether to trust type annotations during inference and optimizations.
   final bool trustTypeAnnotations;
 
   /// Whether to generate code compliant with content security policy (CSP).
   final bool useContentSecurityPolicy;
 
+  /// Whether to use kernel internally as part of compilation.
+  final bool useKernel;
+
   /// When obfuscating for minification, whether to use the frequency of a name
   /// as an heuristic to pick shorter names.
   final bool useFrequencyNamer;
 
   /// Whether to use the new source-information implementation for source-maps.
   /// (experimental)
   final bool useNewSourceInfo;
 
   /// Whether the user requested to use the fast startup emitter. The full
   /// emitter might still be used if the program uses dart:mirrors.
@@ skipping 77 matching lines @@
         resolveOnly: _hasOption(options, Flags.resolveOnly),
         sourceMapUri: _extractUriOption(options, '--source-map='),
         strips: _extractCsvOption(options, '--force-strip='),
         testMode: _hasOption(options, Flags.testMode),
         trustJSInteropTypeAnnotations:
             _hasOption(options, Flags.trustJSInteropTypeAnnotations),
         trustPrimitives: _hasOption(options, Flags.trustPrimitives),
         trustTypeAnnotations: _hasOption(options, Flags.trustTypeAnnotations),
         useContentSecurityPolicy:
             _hasOption(options, Flags.useContentSecurityPolicy),
+        useKernel: _hasOption(options, Flags.useKernel),
         useFrequencyNamer:
             !_hasOption(options, Flags.noFrequencyBasedMinification),
         useNewSourceInfo: _hasOption(options, Flags.useNewSourceInfo),
         useStartupEmitter: _hasOption(options, Flags.fastStartup),
         verbose: _hasOption(options, Flags.verbose));
   }
 
   /// Creates an option object for the compiler.
   ///
   /// This validates and normalizes dependent options to be consistent. For
@@ skipping 40 matching lines @@
       List<Uri> resolutionInputs: null,
       Uri resolutionOutput: null,
       bool resolveOnly: false,
       Uri sourceMapUri: null,
       List<String> strips: const [],
       bool testMode: false,
       bool trustJSInteropTypeAnnotations: false,
       bool trustPrimitives: false,
       bool trustTypeAnnotations: false,
       bool useContentSecurityPolicy: false,
+      bool useKernel: false,
       bool useFrequencyNamer: true,
       bool useNewSourceInfo: false,
       bool useStartupEmitter: false,
       bool verbose: false}) {
     // TODO(sigmund): should entrypoint be here? should we validate it is not
     // null? In unittests we use the same compiler to analyze or build multiple
     // entrypoints.
     if (libraryRoot == null) {
       throw new ArgumentError("[libraryRoot] is null.");
     }
@@ skipping 52 matching lines @@
         resolutionInputs: resolutionInputs,
         resolutionOutput: resolutionOutput,
         resolveOnly: resolveOnly,
         sourceMapUri: sourceMapUri,
         strips: strips,
         testMode: testMode,
         trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations,
         trustPrimitives: trustPrimitives,
         trustTypeAnnotations: trustTypeAnnotations,
         useContentSecurityPolicy: useContentSecurityPolicy,
+        useKernel: useKernel,
         useFrequencyNamer: useFrequencyNamer,
         useNewSourceInfo: useNewSourceInfo,
         useStartupEmitter: useStartupEmitter,
         verbose: verbose);
   }
 
   CompilerOptions._(this.entryPoint, this.libraryRoot, this.packageRoot,
       this.packageConfig, this.packagesDiscoveryProvider, this.environment,
       {this.allowMockCompilation: false,
       this.allowNativeExtensions: false,
@@ skipping 30 matching lines @@
       this.resolutionOutput: null,
       this.resolveOnly: false,
       this.compileOnly: false,
       this.sourceMapUri: null,
       this.strips: const [],
       this.testMode: false,
       this.trustJSInteropTypeAnnotations: false,
       this.trustPrimitives: false,
       this.trustTypeAnnotations: false,
       this.useContentSecurityPolicy: false,
+      this.useKernel: false,
       this.useFrequencyNamer: false,
       this.useNewSourceInfo: false,
       this.useStartupEmitter: false,
       this.verbose: false})
       : _shownPackageWarnings = shownPackageWarnings;
 
   /// Creates a copy of the [CompilerOptions] where the provided non-null
   /// option values replace existing.
   static CompilerOptions copy(CompilerOptions options,
       {entryPoint,
@@ skipping 37 matching lines @@
       resolutionOutput,
       resolveOnly,
       compileOnly,
       sourceMapUri,
       strips,
       testMode,
       trustJSInteropTypeAnnotations,
       trustPrimitives,
       trustTypeAnnotations,
       useContentSecurityPolicy,
+      useKernel,
       useFrequencyNamer,
       useNewSourceInfo,
       useStartupEmitter,
       verbose}) {
     return new CompilerOptions._(
         entryPoint ?? options.entryPoint,
         libraryRoot ?? options.libraryRoot,
         packageRoot ?? options.packageRoot,
         packageConfig ?? options.packageConfig,
         packagesDiscoveryProvider ?? options.packagesDiscoveryProvider,
@@ skipping 49 matching lines @@
         sourceMapUri: sourceMapUri ?? options.sourceMapUri,
         strips: strips ?? options.strips,
         testMode: testMode ?? options.testMode,
         trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations ??
             options.trustJSInteropTypeAnnotations,
         trustPrimitives: trustPrimitives ?? options.trustPrimitives,
         trustTypeAnnotations:
             trustTypeAnnotations ?? options.trustTypeAnnotations,
         useContentSecurityPolicy:
             useContentSecurityPolicy ?? options.useContentSecurityPolicy,
+        useKernel: useKernel ?? options.useKernel,
         useFrequencyNamer: useFrequencyNamer ?? options.useFrequencyNamer,
         useNewSourceInfo: useNewSourceInfo ?? options.useNewSourceInfo,
         useStartupEmitter: useStartupEmitter ?? options.useStartupEmitter,
         verbose: verbose ?? options.verbose);
   }
 
   /// Returns `true` if warnings and hints are shown for all packages.
   bool get showAllPackageWarnings {
     return _shownPackageWarnings != null && _shownPackageWarnings.isEmpty;
   }
@@ skipping 87 matching lines @@
 }
 
 /// Locations of the platform descriptor files relative to the library root.
 const String _clientPlatform = "lib/dart_client.platform";
 const String _serverPlatform = "lib/dart_server.platform";
 const String _sharedPlatform = "lib/dart_shared.platform";
 
 const String _UNDETERMINED_BUILD_ID = "build number could not be determined";
 const bool _forceIncrementalSupport =
     const bool.fromEnvironment('DART2JS_EXPERIMENTAL_INCREMENTAL_SUPPORT');