Move all flags to CompilerOptions (first step to stop passing the compiler to

pkg/compiler/lib/src/compiler.dart

 // Copyright (c) 2012, 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.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
@@ skipping 166 matching lines @@
   /**
    * Dependencies that are only included due to mirrors.
    *
    * We should get rid of this and ensure that all dependencies are
    * associated with a particular element.
    */
   // TODO(johnniwinther): This should not be a [ResolutionRegistry].
   final Registry mirrorDependencies =
       new ResolutionRegistry(null, new TreeElementMapping(null));
 
-  final bool enableMinification;
-
-  final bool useFrequencyNamer;
-
-  /// When `true` emits URIs in the reflection metadata.
-  final bool preserveUris;
-
-  final bool enableTypeAssertions;
-  final bool enableUserAssertions;
-  final bool trustTypeAnnotations;
-  final bool trustPrimitives;
-  final bool trustJSInteropTypeAnnotations;
-  final bool disableTypeInferenceFlag;
-  final Uri deferredMapUri;
-  final bool dumpInfo;
-  final bool useContentSecurityPolicy;
-  final bool enableExperimentalMirrors;
-  final bool enableAssertMessage;
-
-  /**
-   * The maximum size of a concrete type before it widens to dynamic during
-   * concrete type inference.
-   */
-  final int maxConcreteTypeSize;
-  final bool analyzeAllFlag;
-  final bool analyzeOnly;
-
-  /// If true, disable tree-shaking for the main script.
-  final bool analyzeMain;
-
-  /**
-   * If true, skip analysis of method bodies and field initializers. Implies
-   * [analyzeOnly].
-   */
-  final bool analyzeSignaturesOnly;
-  final bool enableNativeLiveTypeAnalysis;
+  /// Options provided from command-line arguments.
+  final api.CompilerOptions options;
 
   /**
    * If true, stop compilation after type inference is complete. Used for
    * debugging and testing purposes only.
    */
   bool stopAfterTypeInference = false;
 
-  /**
-   * If [:true:], comment tokens are collected in [commentMap] during scanning.
-   */
-  final bool preserveComments;
-
-  /// Use the new CPS based backend end.  This flag works for both the Dart and
-  /// JavaScript backend.
-  final bool useCpsIr;
-
-  /**
-   * Is the compiler in verbose mode.
-   */
-  final bool verbose;
-
-  /**
-   * URI of the main source map if the compiler is generating source
-   * maps.
-   */
-  final Uri sourceMapUri;
-
-  /**
-   * URI of the main output if the compiler is generating source maps.
-   */
-  final Uri outputUri;
-
-  /// If `true`, some values are cached for reuse in incremental compilation.
-  /// Incremental compilation is basically calling [run] more than once.
-  final bool hasIncrementalSupport;
-
-  /// If `true` native extension syntax is supported by the frontend.
-  final bool allowNativeExtensions;
-
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
-  /// Generate output even when there are compile-time errors.
-  final bool generateCodeWithCompileTimeErrors;
-
-  /// The compiler is run from the build bot.
-  final bool testMode;
-
-  bool disableInlining = false;
-
   List<Uri> librariesToAnalyzeWhenRun;
 
   /// The set of platform libraries reported as unsupported.
   ///
   /// For instance when importing 'dart:io' without '--categories=Server'.
   Set<Uri> disallowedLibraryUris = new Setlet<Uri>();
 
   Tracer tracer;
 
   CompilerTask measuredTask;
@@ skipping 90 matching lines @@
   GenericTask reuseLibraryTask;
 
   /// The constant environment for the frontend interpretation of compile-time
   /// constants.
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
-  String buildId;
 
   /// A customizable filter that is applied to enqueued work items.
   QueueFilter enqueuerFilter = new QueueFilter();
 
   final Selector symbolValidatedConstructorSelector = new Selector.call(
       const PublicName('validated'), CallStructure.ONE_ARG);
 
   static const String CREATE_INVOCATION_MIRROR =
       'createInvocationMirror';
 
-  static const String UNDETERMINED_BUILD_ID =
-      "build number could not be determined";
-
   bool enabledRuntimeType = false;
   bool enabledFunctionApply = false;
   bool enabledInvokeOn = false;
   bool hasIsolateSupport = false;
 
   bool get hasCrashed => _reporter.hasCrashed;
 
   Stopwatch progress;
 
   bool get shouldPrintProgress {
-    return verbose && progress.elapsedMilliseconds > 500;
+    return options.verbose && progress.elapsedMilliseconds > 500;
   }
 
   static const int PHASE_SCANNING = 0;
   static const int PHASE_RESOLVING = 1;
   static const int PHASE_DONE_RESOLVING = 2;
   static const int PHASE_COMPILING = 3;
   int phase;
 
   bool compilationFailedInternal = false;
 
   bool get compilationFailed => compilationFailedInternal;
 
   void set compilationFailed(bool value) {
     if (value) {
       elementsWithCompileTimeErrors.add(currentElement);
     }
     compilationFailedInternal = value;
   }
 
-  /// Set by the backend if real reflection is detected in use of dart:mirrors.
-  bool disableTypeInferenceForMirrors = false;
-
-  Compiler({this.enableTypeAssertions: false,
-            this.enableUserAssertions: false,
-            this.trustTypeAnnotations: false,
-            this.trustPrimitives: false,
-            this.trustJSInteropTypeAnnotations: false,
-            bool disableTypeInferenceFlag: false,
-            this.maxConcreteTypeSize: 5,
-            this.enableMinification: false,
-            this.preserveUris: false,
-            this.enableNativeLiveTypeAnalysis: false,
-            bool emitJavaScript: true,
-            bool dart2dartMultiFile: false,
-            bool generateSourceMap: true,
-            bool analyzeAllFlag: false,
-            bool analyzeOnly: false,
-            this.analyzeMain: false,
-            bool analyzeSignaturesOnly: false,
-            this.preserveComments: false,
-            this.useCpsIr: false,
-            this.useFrequencyNamer: false,
-            this.verbose: false,
-            this.sourceMapUri: null,
-            this.outputUri: null,
-            this.buildId: UNDETERMINED_BUILD_ID,
-            this.deferredMapUri: null,
-            this.dumpInfo: false,
-            bool useStartupEmitter: false,
-            bool enableConditionalDirectives: false,
-            bool useNewSourceInfo: false,
-            this.useContentSecurityPolicy: false,
-            bool hasIncrementalSupport: false,
-            this.enableExperimentalMirrors: false,
-            this.enableAssertMessage: false,
-            this.allowNativeExtensions: false,
-            this.generateCodeWithCompileTimeErrors: false,
-            this.testMode: false,
-            DiagnosticOptions diagnosticOptions,
-            api.CompilerOutput outputProvider,
-            List<String> strips: const []})
-      : this.disableTypeInferenceFlag =
-          disableTypeInferenceFlag || !emitJavaScript,
-        this.analyzeOnly =
-            analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
-        this.analyzeSignaturesOnly = analyzeSignaturesOnly,
-        this.analyzeAllFlag = analyzeAllFlag,
-        this.hasIncrementalSupport = hasIncrementalSupport,
-        cacheStrategy = new CacheStrategy(hasIncrementalSupport),
+  Compiler({api.CompilerOptions options,
+            api.CompilerOutput outputProvider})
+      : this.options = options,
+        this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput() : outputProvider {
-    if (hasIncrementalSupport) {
-      // TODO(ahe): This is too much. Any method from platform and package
-      // libraries can be inlined.
-      disableInlining = true;
-    }
+
     world = new World(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
-    _reporter = new _CompilerDiagnosticReporter(this, diagnosticOptions);
+    _reporter = new _CompilerDiagnosticReporter(
+        this, options.diagnosticOptions);
     _parsing = new _CompilerParsing(this);
     _resolution = new _CompilerResolution(this);
     _coreTypes = new _CompilerCoreTypes(_resolution);
     types = new Types(_resolution);
     tracer = new Tracer(this, this.outputProvider);
 
-    if (verbose) {
+    if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies = new GlobalDependencyRegistry(this);
 
-    if (emitJavaScript) {
+    if (options.emitJavaScript) {
       js_backend.JavaScriptBackend jsBackend =
           new js_backend.JavaScriptBackend(
-              this, generateSourceMap: generateSourceMap,
-              useStartupEmitter: useStartupEmitter,
-              useNewSourceInfo: useNewSourceInfo);
+              this, generateSourceMap: options.generateSourceMap,
+              useStartupEmitter: options.useStartupEmitter,
+              useNewSourceInfo: options.useNewSourceInfo);
       backend = jsBackend;
     } else {
-      backend = new dart_backend.DartBackend(this, strips,
-                                             multiFile: dart2dartMultiFile);
-      if (dumpInfo) {
+      backend = new dart_backend.DartBackend(this, options.strips,
+          multiFile: options.dart2dartMultiFile);
+      if (options.dumpInfo) {
         throw new ArgumentError('--dump-info is not supported for dart2dart.');
       }
     }
 
     tasks = [
       libraryLoader = new LibraryLoaderTask(this),
       serialization = new SerializationTask(this),
       scanner = new ScannerTask(this),
       dietParser = new DietParserTask(
-          this, enableConditionalDirectives: enableConditionalDirectives),
+          this, enableConditionalDirectives: options.enableConditionalDirectives),
       parser = new ParserTask(
-          this, enableConditionalDirectives: enableConditionalDirectives),
+          this, enableConditionalDirectives: options.enableConditionalDirectives),
       patchParser = new PatchParserTask(
-          this, enableConditionalDirectives: enableConditionalDirectives),
+          this, enableConditionalDirectives: options.enableConditionalDirectives),
       resolver = new ResolverTask(this, backend.constantCompilerTask),
       closureToClassMapper = new closureMapping.ClosureTask(this),
       checker = new TypeCheckerTask(this),
       typesTask = new ti.TypesTask(this),
       constants = backend.constantCompilerTask,
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this),
       dumpInfoTask = new DumpInfoTask(this),
       reuseLibraryTask = new GenericTask('Reuse library', this),
     ];
 
     tasks.addAll(backend.tasks);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
-  bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
-
-  bool get analyzeAll => analyzeAllFlag || compileAll;
+  bool get analyzeAll => options.analyzeAll || compileAll;
 
   bool get compileAll => false;
 
-  bool get disableTypeInference {
-    return disableTypeInferenceFlag || compilationFailed;
-  }
+  bool get disableTypeInference =>
+      options.disableTypeInference || compilationFailed;
 
   int getNextFreeClassId() => nextFreeClassId++;
 
   void unimplemented(Spannable spannable, String methodName) {
     reporter.internalError(spannable, "$methodName not implemented.");
   }
 
   // Compiles the dart script at [uri].
   //
   // The resulting future will complete with true if the compilation
@@ skipping 70 matching lines @@
   ///       <main-uri> => <intermediate-uri1> => <intermediate-uri2> => <uri>
   ///
   Set<String> computeImportChainsFor(LoadedLibraries loadedLibraries, Uri uri) {
     // TODO(johnniwinther): Move computation of dependencies to the library
     // loader.
     Uri rootUri = loadedLibraries.rootUri;
     Set<String> importChains = new Set<String>();
     // The maximum number of full imports chains to process.
     final int chainLimit = 10000;
     // The maximum number of imports chains to show.
-    final int compactChainLimit = verbose ? 20 : 10;
+    final int compactChainLimit = options.verbose ? 20 : 10;
     int chainCount = 0;
     loadedLibraries.forEachImportChain(uri,
         callback: (Link<Uri> importChainReversed) {
       Link<CodeLocation> compactImportChain = const Link<CodeLocation>();
       CodeLocation currentCodeLocation =
           new UriLocation(importChainReversed.head);
       compactImportChain = compactImportChain.prepend(currentCodeLocation);
       for (Link<Uri> link = importChainReversed.tail;
            !link.isEmpty;
            link = link.tail) {
         Uri uri = link.head;
         if (!currentCodeLocation.inSameLocation(uri)) {
           currentCodeLocation =
-              verbose ? new UriLocation(uri) : new CodeLocation(uri);
+              options.verbose ? new UriLocation(uri) : new CodeLocation(uri);
           compactImportChain =
               compactImportChain.prepend(currentCodeLocation);
         }
       }
       String importChain =
           compactImportChain.map((CodeLocation codeLocation) {
             return codeLocation.relativize(rootUri);
           }).join(' => ');
 
       if (!importChains.contains(importChain)) {
@@ skipping 52 matching lines @@
       bool importsMirrorsLibrary =
           loadedLibraries.containsLibrary(Uris.dart_mirrors);
       if (importsMirrorsLibrary && !backend.supportsReflection) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
         reporter.reportErrorMessage(
             NO_LOCATION_SPANNABLE,
             MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND,
             {'importChain': importChains.join(
                 MessageTemplate.MIRRORS_NOT_SUPPORTED_BY_BACKEND_PADDING)});
-      } else if (importsMirrorsLibrary && !enableExperimentalMirrors) {
+      } else if (importsMirrorsLibrary && !options.enableExperimentalMirrors) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
         reporter.reportWarningMessage(
             NO_LOCATION_SPANNABLE,
             MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
             {'importChain': importChains.join(
                  MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
       }
 
       coreClasses.functionClass.ensureResolved(resolution);
       functionApplyMethod =
           coreClasses.functionClass.lookupLocalMember('apply');
 
-      if (preserveComments) {
+      if (options.preserveComments) {
         return libraryLoader.loadLibrary(Uris.dart_mirrors)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   bool isProxyConstant(ConstantValue value) {
     FieldElement field = coreLibrary.find('proxy');
@@ skipping 100 matching lines @@
     StringToken.canonicalizedSubstrings.clear();
     Selector.canonicalizedValues.clear();
 
     // The selector objects held in static fields must remain canonical.
     for (Selector selector in Selectors.ALL) {
       Selector.canonicalizedValues
         .putIfAbsent(selector.hashCode, () => <Selector>[])
         .add(selector);
     }
 
-    assert(uri != null || analyzeOnly || hasIncrementalSupport);
+    assert(uri != null || options.analyzeOnly || options.hasIncrementalSupport);
     return new Future.sync(() {
       if (librariesToAnalyzeWhenRun != null) {
         return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
-          reporter.log('Analyzing $libraryUri ($buildId)');
+          reporter.log('Analyzing $libraryUri (${options.buildId})');
           return libraryLoader.loadLibrary(libraryUri);
         });
       }
     }).then((_) {
       if (uri != null) {
-        if (analyzeOnly) {
-          reporter.log('Analyzing $uri ($buildId)');
+        if (options.analyzeOnly) {
+          reporter.log('Analyzing $uri (${options.buildId})');
         } else {
-          reporter.log('Compiling $uri ($buildId)');
+          reporter.log('Compiling $uri (${options.buildId})');
         }
         return libraryLoader.loadLibrary(uri).then((LibraryElement library) {
           mainApp = library;
         });
       }
     }).then((_) {
       compileLoadedLibraries();
     });
   }
 
   void computeMain() {
     if (mainApp == null) return;
 
     Element main = mainApp.findExported(Identifiers.main);
     ErroneousElement errorElement = null;
     if (main == null) {
-      if (analyzeOnly) {
+      if (options.analyzeOnly) {
         if (!analyzeAll) {
           errorElement = new ErroneousElementX(
               MessageKind.CONSIDER_ANALYZE_ALL, {'main': Identifiers.main},
               Identifiers.main, mainApp);
         }
       } else {
         // Compilation requires a main method.
         errorElement = new ErroneousElementX(
             MessageKind.MISSING_MAIN, {'main': Identifiers.main},
             Identifiers.main, mainApp);
@@ skipping 23 matching lines @@
               MessageKind.MAIN_WITH_EXTRA_PARAMETER, {'main': Identifiers.main},
               Identifiers.main,
               parameter);
           mainFunction = backend.helperForMainArity();
           // Don't warn about main not being used:
           enqueuer.resolution.registerStaticUse(new StaticUse.foreignUse(main));
         });
       }
     }
     if (mainFunction == null) {
-      if (errorElement == null && !analyzeOnly && !analyzeAll) {
+      if (errorElement == null && !options.analyzeOnly && !analyzeAll) {
         reporter.internalError(mainApp, "Problem with '${Identifiers.main}'.");
       } else {
         mainFunction = errorElement;
       }
     }
     if (errorElement != null &&
         errorElement.isSynthesized &&
         !mainApp.isSynthesized) {
       reporter.reportWarningMessage(
           errorElement, errorElement.messageKind,
           errorElement.messageArguments);
     }
   }
 
   /// Analyze all members of the library in [libraryUri].
   ///
   /// If [skipLibraryWithPartOfTag] is `true`, member analysis is skipped if the
   /// library has a `part of` tag, assuming it is a part and not a library.
   ///
   /// This operation assumes an unclosed resolution queue and is only supported
   /// when the '--analyze-main' option is used.
   Future<LibraryElement> analyzeUri(
       Uri libraryUri,
       {bool skipLibraryWithPartOfTag: true}) {
-    assert(analyzeMain);
-    reporter.log('Analyzing $libraryUri ($buildId)');
+    assert(options.analyzeMain);
+    reporter.log('Analyzing $libraryUri (${options.buildId})');
     return libraryLoader.loadLibrary(
         libraryUri, skipFileWithPartOfTag: true).then(
             (LibraryElement library) {
       if (library == null) return null;
       fullyEnqueueLibrary(library, enqueuer.resolution);
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() {
     computeMain();
 
     mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
     // In order to see if a library is deferred, we must compute the
     // compile-time constants that are metadata.  This means adding
     // something to the resolution queue.  So we cannot wait with
     // this until after the resolution queue is processed.
     deferredLoadTask.beforeResolution(this);
     impactStrategy = backend.createImpactStrategy(
         supportDeferredLoad: deferredLoadTask.isProgramSplit,
-        supportDumpInfo: dumpInfo);
+        supportDumpInfo: options.dumpInfo);
 
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
       reporter.log('Enqueuing ${library.canonicalUri}');
         fullyEnqueueLibrary(library, enqueuer.resolution);
       });
-    } else if (analyzeMain) {
+    } else if (options.analyzeMain) {
       if (mainApp != null) {
         fullyEnqueueLibrary(mainApp, enqueuer.resolution);
       }
       if (librariesToAnalyzeWhenRun != null) {
         for (Uri libraryUri in librariesToAnalyzeWhenRun) {
           fullyEnqueueLibrary(libraryLoader.lookupLibrary(libraryUri),
               enqueuer.resolution);
         }
       }
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveLibraryMetadata();
     reporter.log('Resolving...');
     processQueue(enqueuer.resolution, mainFunction);
     enqueuer.resolution.logSummary(reporter.log);
 
     _reporter.reportSuppressedMessagesSummary();
 
     if (compilationFailed){
-      if (!generateCodeWithCompileTimeErrors) return;
+      if (!options.generateCodeWithCompileTimeErrors) return;
       if (!backend.enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
         return;
       }
     }
 
-    if (analyzeOnly) {
+    if (options.analyzeOnly) {
       if (!analyzeAll && !compilationFailed) {
         // No point in reporting unused code when [analyzeAll] is true: all
         // code is artificially used.
         // If compilation failed, it is possible that the error prevents the
         // compiler from analyzing all the code.
         // TODO(johnniwinther): Reenable this when the reporting is more
         // precise.
         //reportUnusedCode();
       }
       return;
@@ skipping 25 matching lines @@
     if (compileAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
         fullyEnqueueLibrary(library, enqueuer.codegen);
       });
     }
     processQueue(enqueuer.codegen, mainFunction);
     enqueuer.codegen.logSummary(reporter.log);
 
     int programSize = backend.assembleProgram();
 
-    if (dumpInfo) {
+    if (options.dumpInfo) {
       dumpInfoTask.reportSize(programSize);
       dumpInfoTask.dumpInfo();
     }
 
     backend.sourceInformationStrategy.onComplete();
 
     checkQueues();
   }
 
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
@@ skipping 50 matching lines @@
         backend.registerInstantiatedType(
             backend.listImplementation.rawType, world, globalDependencies);
         backend.stringImplementation.ensureResolved(resolution);
         backend.registerInstantiatedType(
             backend.stringImplementation.rawType, world, globalDependencies);
 
         backend.registerMainHasArguments(world);
       }
       world.addToWorkList(main);
     }
-    if (verbose) {
+    if (options.verbose) {
       progress.reset();
     }
     emptyQueue(world);
     world.queueIsClosed = true;
     // Notify the impact strategy impacts are no longer needed for this
     // enqueuer.
     impactStrategy.onImpactUsed(world.impactUse);
     backend.onQueueClosed();
     assert(compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
   }
@@ skipping 99 matching lines @@
   }
 
   /// Messages for which compile-time errors are reported but compilation
   /// continues regardless.
   static const List<MessageKind> BENIGN_ERRORS = const <MessageKind>[
       MessageKind.INVALID_METADATA,
       MessageKind.INVALID_METADATA_GENERIC,
   ];
 
   bool markCompilationAsFailed(DiagnosticMessage message, api.Diagnostic kind) {
-    if (testMode) {
+    if (options.testMode) {
       // When in test mode, i.e. on the build-bot, we always stop compilation.
       return true;
     }
     if (reporter.options.fatalWarnings) {
       return true;
     }
     return !BENIGN_ERRORS.contains(message.message.kind);
   }
 
   void fatalDiagnosticReported(DiagnosticMessage message,
@@ skipping 188 matching lines @@
     }
     backend.forgetElement(element);
   }
 
   bool elementHasCompileTimeError(Element element) {
     return elementsWithCompileTimeErrors.contains(element);
   }
 
   EventSink<String> outputProvider(String name, String extension) {
     if (compilationFailed) {
-      if (!generateCodeWithCompileTimeErrors || testMode) {
+      if (!options.generateCodeWithCompileTimeErrors || options.testMode) {
         // Disable output in test mode: The build bot currently uses the time
         // stamp of the generated file to determine whether the output is
         // up-to-date.
         return new NullSink('$name.$extension');
       }
     }
     return userOutputProvider.createEventSink(name, extension);
   }
 }
 
@@ skipping 487 matching lines @@
     reportDiagnostic(
         createMessage(element, MessageKind.COMPILER_CRASHED),
         const <DiagnosticMessage>[],
         api.Diagnostic.CRASH);
     pleaseReportCrash();
   }
 
   void pleaseReportCrash() {
     print(
         MessageTemplate.TEMPLATES[MessageKind.PLEASE_REPORT_THE_CRASH]
-            .message({'buildId': compiler.buildId}));
+            .message({'buildId': compiler.options.buildId}));
   }
 
   /// Finds the approximate [Element] for [node]. [currentElement] is used as
   /// the default value.
   Element elementFromSpannable(Spannable node) {
     Element element;
     if (node is Element) {
       element = node;
     } else if (node is HInstruction) {
       element = _elementFromHInstruction(node);
@@ skipping 127 matching lines @@
   }
 
   @override
   WorldImpact computeWorldImpact(Element element) {
     return _worldImpactCache.putIfAbsent(element, () {
       assert(compiler.parser != null);
       Node tree = compiler.parser.parse(element);
       assert(invariant(element, !element.isSynthesized || tree == null));
       ResolutionImpact resolutionImpact =
           compiler.resolver.resolve(element);
-      if (tree != null && !compiler.analyzeSignaturesOnly) {
+      if (tree != null && !compiler.options.analyzeSignaturesOnly) {
         // TODO(het): don't do this if suppressWarnings is on, currently we have
         // to do it because the typechecker also sets types
         // Only analyze nodes with a corresponding [TreeElements].
         compiler.checker.check(element);
       }
       WorldImpact worldImpact =
           compiler.backend.impactTransformer.transformResolutionImpact(
               resolutionImpact);
       return worldImpact;
     });
@@ skipping 63 matching lines @@
     if (_otherDependencies == null) {
       _otherDependencies = new Setlet<Element>();
     }
     _otherDependencies.add(element.implementation);
   }
 
   Iterable<Element> get otherDependencies {
     return _otherDependencies != null ? _otherDependencies : const <Element>[];
   }
 }