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

pkg/compiler/lib/src/closure.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 closureToClassMapper;
 
 import 'common.dart';
 import 'common/names.dart' show
     Identifiers;
 import 'common/resolution.dart' show
@@ skipping 725 matching lines @@
       }
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     MemberElement member = executableContext.memberContext;
     DartType type = elements.getType(node);
     // TODO(karlklose,johnniwinther): if the type is null, the annotation is
     // from a parameter which has been analyzed before the method has been
     // resolved and the result has been thrown away.
-    if (compiler.enableTypeAssertions && type != null &&
+    if (compiler.options.enableTypeAssertions && type != null &&
         type.containsTypeVariables) {
       if (insideClosure && member.isFactoryConstructor) {
         // This is a closure in a factory constructor.  Since there is no
         // [:this:], we have to mark the type arguments as free variables to
         // capture them in the closure.
         type.forEachTypeVariable((TypeVariableType variable) {
           useTypeVariableAsLocal(variable);
         });
       }
       if (member.isInstanceMember && !member.isField) {
@@ skipping 49 matching lines @@
       DartType type = elements.getType(node.arguments.head);
       analyzeType(type);
     }
     node.visitChildren(this);
   }
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       mutatedVariables.add(element);
-      if (compiler.enableTypeAssertions) {
+      if (compiler.options.enableTypeAssertions) {
         TypedElement typedElement = element;
         analyzeTypeVariables(typedElement.type);
       }
     }
     super.visitSendSet(node);
   }
 
   visitNewExpression(NewExpression node) {
     DartType type = elements.getType(node);
     analyzeType(type);
@@ skipping 231 matching lines @@
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
     closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       DartType type = element.type;
       // If the method needs RTI, or checked mode is set, we need to
       // escape the potential type variables used in that closure.
       if (element is FunctionElement &&
           (compiler.backend.methodNeedsRti(element) ||
-           compiler.enableTypeAssertions)) {
+           compiler.options.enableTypeAssertions)) {
         analyzeTypeVariables(type);
       }
 
       visitChildren();
     });
 
 
     ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
@@ skipping 78 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }