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

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show
     ForeignResolver;
 import '../common/registry.dart' show
@@ skipping 123 matching lines @@
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   Resolution get resolution => compiler.resolution;
 
   DiagnosticReporter get reporter => compiler.reporter;
   CoreTypes get coreTypes => compiler.coreTypes;
 
   void processNativeClasses(Iterable<LibraryElement> libraries) {
-    if (compiler.hasIncrementalSupport) {
+    if (compiler.options.hasIncrementalSupport) {
       // Since [Set.add] returns bool if an element was added, this restricts
       // [libraries] to ones that haven't already been processed. This saves
       // time during incremental compiles.
       libraries = libraries.where(processedLibraries.add);
     }
     libraries.forEach(processNativeClassesInLibrary);
     if (helpers.isolateHelperLibrary != null) {
       processNativeClassesInLibrary(helpers.isolateHelperLibrary);
     }
     processSubclassesOfNativeClasses(libraries);
@@ skipping 208 matching lines @@
     if (flushing) return;
     flushing = true;
     while (!queue.isEmpty) {
       (queue.removeFirst())();
     }
     flushing = false;
   }
 
   processClass(BaseClassElementX classElement, cause) {
     // TODO(ahe): Fix this assertion to work in incremental compilation.
-    assert(compiler.hasIncrementalSupport ||
+    assert(compiler.options.hasIncrementalSupport ||
            !registeredClasses.contains(classElement));
 
     bool firstTime = registeredClasses.isEmpty;
     pendingClasses.remove(classElement);
     registeredClasses.add(classElement);
 
     // TODO(ahe): Is this really a global dependency?
     classElement.ensureResolved(resolution);
     compiler.backend.registerInstantiatedType(
         classElement.rawType, world, compiler.globalDependencies);
@@ skipping 193 matching lines @@
       'native exception');
   }
 }
 
 
 class NativeResolutionEnqueuer extends NativeEnqueuerBase {
 
   Map<String, ClassElement> tagOwner = new Map<String, ClassElement>();
 
   NativeResolutionEnqueuer(Enqueuer world, Compiler compiler)
-    : super(world, compiler, compiler.enableNativeLiveTypeAnalysis);
+    : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
   void processNativeClass(ClassElement classElement) {
     super.processNativeClass(classElement);
 
     // Js Interop interfaces do not have tags.
     if (backend.isJsInterop(classElement)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in backend.getNativeTagsOfClass(classElement)) {
       ClassElement owner = tagOwner[tag];
@@ skipping 65 matching lines @@
 }
 
 
 class NativeCodegenEnqueuer extends NativeEnqueuerBase {
 
   final CodeEmitterTask emitter;
 
   final Set<ClassElement> doneAddSubtypes = new Set<ClassElement>();
 
   NativeCodegenEnqueuer(Enqueuer world, Compiler compiler, this.emitter)
-    : super(world, compiler, compiler.enableNativeLiveTypeAnalysis);
+    : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
   void processNativeClasses(Iterable<LibraryElement> libraries) {
     super.processNativeClasses(libraries);
 
     // HACK HACK - add all the resolved classes.
     NativeEnqueuerBase enqueuer = compiler.enqueuer.resolution.nativeEnqueuer;
     for (final classElement in enqueuer.registeredClasses) {
       if (unusedClasses.contains(classElement)) {
         enqueueClass(classElement, 'was resolved');
       }
@@ skipping 37 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }