Reapply "Add "load from .dill" file capability and run a white-box test.""

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 184 matching lines @@
 
   /// 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;
 
+  /// 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 80 matching lines @@
         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),
+        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 40 matching lines @@
       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 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 52 matching lines @@
         resolutionOutput: resolutionOutput,
         resolveOnly: resolveOnly,
         sourceMapUri: sourceMapUri,
         strips: strips,
         testMode: testMode,
         trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations,
         trustPrimitives: trustPrimitives,
         trustTypeAnnotations: trustTypeAnnotations,
         useContentSecurityPolicy: useContentSecurityPolicy,
         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 30 matching lines @@
       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.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 37 matching lines @@
       resolveOnly,
       compileOnly,
       sourceMapUri,
       strips,
       testMode,
       trustJSInteropTypeAnnotations,
       trustPrimitives,
       trustTypeAnnotations,
       useContentSecurityPolicy,
       useKernel,
+      loadFromDill,
       useFrequencyNamer,
       useMultiSourceInfo,
       useNewSourceInfo,
       useStartupEmitter,
       verbose}) {
     return new CompilerOptions._(
         entryPoint ?? options.entryPoint,
         libraryRoot ?? options.libraryRoot,
         packageRoot ?? options.packageRoot,
         packageConfig ?? options.packageConfig,
@@ skipping 47 matching lines @@
         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,
+        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";