Add support for compiling Dart via the FE in dart2js.

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 controlling diagnostic messages.
@@ skipping 182 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 useKernelInSsa;
+
+  /// Preview the unified front-end and compilation from kernel.
+  ///
+  /// When enabled the compiler will use the unified front-end to compile
+  /// sources to kernel, and then continue compilation from the kernel
+  /// representation. Setting this flag will implicitly set [useKernelInSsa] to
+  /// true as well.
+  ///
+  /// When this flag is on, the compiler also acccepts reading .dill files from
+  /// disk. The compiler reads the sources differently depending on the
+  /// extension format.
   final bool useKernel;
 
-  /// Read input from a .dill file rather than a .dart input (only to be used in
-  /// conjunction with useKernel = true).
-  final bool loadFromDill;
-
   // Whether to use kernel internally for global type inference calculations.
   // TODO(efortuna): Remove this and consolidate with useKernel.
   final bool kernelGlobalInference;
 
   /// When obfuscating for minification, whether to use the frequency of a name
   /// as an heuristic to pick shorter names.
   final bool useFrequencyNamer;
 
   /// Whether to generate source-information from both the old and the new
   /// source-information engines. (experimental)
@@ skipping 97 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),
+        useKernelInSsa: _hasOption(options, Flags.useKernelInSsa),
         useKernel: _hasOption(options, Flags.useKernel),
-        loadFromDill: _hasOption(options, Flags.loadFromDill),
         useFrequencyNamer:
             !_hasOption(options, Flags.noFrequencyBasedMinification),
         useMultiSourceInfo: _hasOption(options, Flags.useMultiSourceInfo),
         useNewSourceInfo: _hasOption(options, Flags.useNewSourceInfo),
         useStartupEmitter: _hasOption(options, Flags.fastStartup),
         verbose: _hasOption(options, Flags.verbose));
   }
 
   /// Creates an option object for the compiler.
   ///
@@ skipping 41 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 useKernelInSsa: false,
       bool useKernel: false,
-      bool loadFromDill: false,
       bool useFrequencyNamer: true,
       bool useMultiSourceInfo: false,
       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 24 matching lines @@
         analyzeOnly:
             analyzeOnly || analyzeSignaturesOnly || analyzeAll || resolveOnly,
         analyzeSignaturesOnly: analyzeSignaturesOnly,
         buildId: buildId,
         deferredMapUri: deferredMapUri,
         fatalWarnings: fatalWarnings,
         terseDiagnostics: terseDiagnostics,
         suppressWarnings: suppressWarnings,
         suppressHints: suppressHints,
         shownPackageWarnings: shownPackageWarnings,
-        disableInlining: disableInlining,
-        disableTypeInference: disableTypeInference,
+        // TODO(sigmund): remove once we support inlining and type-inference
+        // with `useKernel`.
+        disableInlining: disableInlining || useKernel,
+        disableTypeInference: disableTypeInference || useKernel,
         dumpInfo: dumpInfo,
         enableAssertMessage: enableAssertMessage,
         enableExperimentalMirrors: enableExperimentalMirrors,
         enableMinification: enableMinification,
         enableNativeLiveTypeAnalysis: enableNativeLiveTypeAnalysis,
         enableTypeAssertions: enableTypeAssertions,
         enableUserAssertions: enableUserAssertions,
         experimentalTrackAllocations: experimentalTrackAllocations,
         experimentalAllocationsPath: experimentalAllocationsPath,
-        generateCodeWithCompileTimeErrors: generateCodeWithCompileTimeErrors,
+        generateCodeWithCompileTimeErrors:
+            generateCodeWithCompileTimeErrors && !useKernel,
         generateSourceMap: generateSourceMap,
         kernelGlobalInference: kernelGlobalInference,
         outputUri: outputUri,
         platformConfigUri: platformConfigUri ??
             _resolvePlatformConfig(libraryRoot, null, const []),
         preserveComments: preserveComments,
         preserveUris: preserveUris,
         resolutionInputs: resolutionInputs,
         resolutionOutput: resolutionOutput,
         resolveOnly: resolveOnly,
         sourceMapUri: sourceMapUri,
         strips: strips,
         testMode: testMode,
         trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations,
         trustPrimitives: trustPrimitives,
         trustTypeAnnotations: trustTypeAnnotations,
         useContentSecurityPolicy: useContentSecurityPolicy,
+        useKernelInSsa: useKernelInSsa || useKernel,
         useKernel: useKernel,
-        loadFromDill: loadFromDill,
         useFrequencyNamer: useFrequencyNamer,
         useMultiSourceInfo: useMultiSourceInfo,
         useNewSourceInfo: useNewSourceInfo,
         useStartupEmitter: useStartupEmitter,
         verbose: verbose);
   }
 
   CompilerOptions._(this.entryPoint, this.libraryRoot, this.packageRoot,
       this.packageConfig, this.packagesDiscoveryProvider, this.environment,
       {this.allowMockCompilation: false,
@@ skipping 31 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.useKernelInSsa: false,
       this.useKernel: false,
-      this.loadFromDill: false,
       this.useFrequencyNamer: false,
       this.useMultiSourceInfo: 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,
@@ skipping 38 matching lines @@
       resolutionOutput,
       resolveOnly,
       compileOnly,
       sourceMapUri,
       strips,
       testMode,
       trustJSInteropTypeAnnotations,
       trustPrimitives,
       trustTypeAnnotations,
       useContentSecurityPolicy,
+      useKernelInSsa,
       useKernel,
-      loadFromDill,
       useFrequencyNamer,
       useMultiSourceInfo,
       useNewSourceInfo,
       useStartupEmitter,
       verbose}) {
     return new CompilerOptions._(
         entryPoint ?? options.entryPoint,
         libraryRoot ?? options.libraryRoot,
         packageRoot ?? options.packageRoot,
         packageConfig ?? options.packageConfig,
@@ skipping 50 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,
+        useKernelInSsa: useKernelInSsa ?? options.useKernelInSsa,
         useKernel: useKernel ?? options.useKernel,
-        loadFromDill: loadFromDill ?? options.loadFromDill,
         useFrequencyNamer: useFrequencyNamer ?? options.useFrequencyNamer,
         useMultiSourceInfo: useMultiSourceInfo ?? options.useMultiSourceInfo,
         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 86 matching lines @@
       _extractStringOption(options, "--platform-config=", null),
       _extractCsvOption(options, '--categories='));
 }
 
 /// 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";