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

pkg/compiler/lib/src/enqueue.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.enqueue;
 
 import 'dart:collection' show
     Queue;
 
 import 'common.dart';
@@ skipping 58 matching lines @@
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
     : resolution = new ResolutionEnqueuer(
           compiler, compiler.backend.createItemCompilationContext,
-          compiler.analyzeOnly && compiler.analyzeMain
+          compiler.options.analyzeOnly && compiler.options.analyzeMain
               ? const EnqueuerStrategy() : const TreeShakingEnqueuerStrategy()),
       codegen = new CodegenEnqueuer(
           compiler, compiler.backend.createItemCompilationContext,
           const TreeShakingEnqueuerStrategy()),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
 
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
     resolution.nativeEnqueuer =
@@ skipping 60 matching lines @@
 
   ImpactUseCase get impactUse;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
-    if (internalAddToWorkList(element) && compiler.dumpInfo) {
+    if (internalAddToWorkList(element) && compiler.options.dumpInfo) {
       // TODO(sigmund): add other missing dependencies (internals, selectors
       // enqueued after allocations), also enable only for the codegen enqueuer.
       compiler.dumpInfoTask.registerDependency(
           compiler.currentElement, element);
     }
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
    *
@@ skipping 485 matching lines @@
       case TypeUseKind.INSTANTIATION:
         registerInstantiatedType(type);
         break;
       case TypeUseKind.INSTANTIATION:
       case TypeUseKind.IS_CHECK:
       case TypeUseKind.AS_CAST:
       case TypeUseKind.CATCH_TYPE:
         _registerIsCheck(type);
         break;
       case TypeUseKind.CHECKED_MODE_CHECK:
-        if (compiler.enableTypeAssertions) {
+        if (compiler.options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
     type = universe.registerIsCheck(type, compiler);
@@ skipping 258 matching lines @@
     return compiler.backend.isAccessibleByReflection(element);
   }
 
   bool internalAddToWorkList(Element element) {
     // Don't generate code for foreign elements.
     if (compiler.backend.isForeign(element)) return false;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
-      if (!compiler.enableTypeAssertions
+      if (!compiler.options.enableTypeAssertions
           || element.enclosingElement.isClosure) {
         return false;
       }
     }
 
-    if (compiler.hasIncrementalSupport && !isProcessed(element)) {
+    if (compiler.options.hasIncrementalSupport && !isProcessed(element)) {
       newlyEnqueuedElements.add(element);
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Codegen work list is closed. Trying to add $element");
     }
     CodegenWorkItem workItem = new CodegenWorkItem(
         compiler, element, itemCompilationContextCreator());
     queue.add(workItem);
@@ skipping 17 matching lines @@
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         generatedCode.remove(closure);
         removeFromSet(instanceMembersByName, closure);
         removeFromSet(instanceFunctionsByName, closure);
       }
     }
   }
 
   void handleUnseenSelector(DynamicUse dynamicUse) {
-    if (compiler.hasIncrementalSupport) {
+    if (compiler.options.hasIncrementalSupport) {
       newlySeenSelectors.add(dynamicUse);
     }
     super.handleUnseenSelector(dynamicUse);
   }
 }
 
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
     enqueuer.task.measure(() {
@@ skipping 68 matching lines @@
   @override
   void visitStaticUse(StaticUse staticUse) {
     enqueuer.registerStaticUse(staticUse);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.registerTypeUse(typeUse);
   }
 }