Add MultiSourceInformationStrategy

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 188 matching lines @@
   /// 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 generate source-information from both the old and the new
+  /// source-information engines. (experimental)
+  final bool useMultiSourceInfo;
+
   /// 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.
   final bool useStartupEmitter;
 
   /// Enable verbose printing during compilation. Includes progress messages
   /// during each phase and a time-breakdown between phases at the end.
@@ skipping 69 matching lines @@
         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),
+        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.
   ///
   /// This validates and normalizes dependent options to be consistent. For
   /// example, if [analyzeAll] is true, the resulting options object will also
   /// have [analyzeOnly] as true.
@@ skipping 37 matching lines @@
       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 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.");
     }
     if (!libraryRoot.path.endsWith("/")) {
@@ skipping 50 matching lines @@
         resolveOnly: resolveOnly,
         sourceMapUri: sourceMapUri,
         strips: strips,
         testMode: testMode,
         trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations,
         trustPrimitives: trustPrimitives,
         trustTypeAnnotations: trustTypeAnnotations,
         useContentSecurityPolicy: useContentSecurityPolicy,
         useKernel: useKernel,
         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,
       this.allowNativeExtensions: false,
       this.analyzeAll: false,
@@ skipping 28 matching lines @@
       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.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,
       {entryPoint,
       libraryRoot,
@@ skipping 35 matching lines @@
       compileOnly,
       sourceMapUri,
       strips,
       testMode,
       trustJSInteropTypeAnnotations,
       trustPrimitives,
       trustTypeAnnotations,
       useContentSecurityPolicy,
       useKernel,
       useFrequencyNamer,
+      useMultiSourceInfo,
       useNewSourceInfo,
       useStartupEmitter,
       verbose}) {
     return new CompilerOptions._(
         entryPoint ?? options.entryPoint,
         libraryRoot ?? options.libraryRoot,
         packageRoot ?? options.packageRoot,
         packageConfig ?? options.packageConfig,
         packagesDiscoveryProvider ?? options.packagesDiscoveryProvider,
         environment ?? options.environment,
@@ skipping 44 matching lines @@
         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,
+        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 84 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";