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

pkg/compiler/lib/src/js_emitter/metadata_collector.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 /// Represents an entry's position in one of the global metadata arrays.
 ///
 /// [_rc] is used to count the number of references of the token in the
 /// ast for a program.
@@ skipping 279 matching lines @@
   Placeholder getMetadataPlaceholder([debug]) {
     return new _ForwardingMetadataEntry(debug);
   }
 
   _MetadataEntry _addGlobalMetadata(jsAst.Node node) {
     String nameToKey(jsAst.Name name) => "${name.key}";
     String printed = jsAst.prettyPrint(
         node, _compiler, renamerForNames: nameToKey);
     return _globalMetadataMap.putIfAbsent(printed, () {
       _BoundMetadataEntry result = new _BoundMetadataEntry(node);
-      if (_compiler.hasIncrementalSupport) {
+      if (_compiler.options.hasIncrementalSupport) {
         result.finalize(_globalMetadataCounter++);
       }
       return result;
     });
   }
 
   jsAst.Expression _computeTypeRepresentation(DartType type,
                                               {ignoreTypeVariables: false}) {
     jsAst.Expression representation = _backend.rtiEncoder.getTypeRepresentation(
         type,
@@ skipping 19 matching lines @@
   jsAst.Expression addTypeInOutputUnit(DartType type,
                                        OutputUnit outputUnit,
                                        {ignoreTypeVariables: false}) {
     if (_typesMap[outputUnit] == null) {
       _typesMap[outputUnit] = new Map<DartType, _BoundMetadataEntry>();
     }
     return _typesMap[outputUnit].putIfAbsent(type, () {
       _BoundMetadataEntry result = new _BoundMetadataEntry(
           _computeTypeRepresentation(type,
                                      ignoreTypeVariables: ignoreTypeVariables));
-      if (_compiler.hasIncrementalSupport) {
+      if (_compiler.options.hasIncrementalSupport) {
         result.finalize(_globalTypesCounter++);
       }
       return result;
     });
   }
 
   List<jsAst.DeferredNumber> computeMetadata(FunctionElement element) {
     return reporter.withCurrentElement(element, () {
       if (!_mustEmitMetadataFor(element)) return const <jsAst.DeferredNumber>[];
       List<jsAst.DeferredNumber> metadata = <jsAst.DeferredNumber>[];
@@ skipping 18 matching lines @@
     }
     void countTokensInTypes(Iterable<_BoundMetadataEntry> entries) {
       jsAst.TokenCounter counter = new jsAst.TokenCounter();
       entries.where((_BoundMetadataEntry e) => e._rc > 0)
              .map((_BoundMetadataEntry e) => e.entry)
              .forEach(counter.countTokens);
     }
 
     jsAst.ArrayInitializer finalizeMap(Map<dynamic, _BoundMetadataEntry> map) {
       // When in incremental mode, we allocate entries eagerly.
-      if (_compiler.hasIncrementalSupport) {
+      if (_compiler.options.hasIncrementalSupport) {
         return new jsAst.ArrayInitializer(map.values.toList());
       }
 
       bool isUsed(_BoundMetadataEntry entry) => entry.isUsed;
       List<_BoundMetadataEntry> entries = map.values.where(isUsed).toList();
       entries.sort();
 
       // TODO(herhut): Bucket entries by index length and use a stable
       //               distribution within buckets.
       int count = 0;
@@ skipping 33 matching lines @@
     if (token is _ForwardingMetadataEntry && !token.isBound) {
       _foundUnboundToken = true;
     }
   }
 
   bool findUnboundPlaceholders(jsAst.Node node) {
     node.accept(this);
     return _foundUnboundToken;
   }
 }