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

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.
 
 library dart2js.js_emitter.full_emitter;
 
 import 'dart:convert';
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 134 matching lines @@
   final Map<jsAst.Name, String> mangledFieldNames =
       new HashMap<jsAst.Name, String>();
   final Map<jsAst.Name, String> mangledGlobalFieldNames =
       new HashMap<jsAst.Name, String>();
   final Set<jsAst.Name> recordedMangledNames = new Set<jsAst.Name>();
 
   JavaScriptBackend get backend => compiler.backend;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
-  String get space => compiler.enableMinification ? "" : " ";
-  String get n => compiler.enableMinification ? "" : "\n";
-  String get N => compiler.enableMinification ? "\n" : ";\n";
+  String get space => compiler.options.enableMinification ? "" : " ";
+  String get n => compiler.options.enableMinification ? "" : "\n";
+  String get N => compiler.options.enableMinification ? "\n" : ";\n";
 
   /**
    * List of expressions and statements that will be included in the
    * precompiled function.
    *
    * To save space, dart2js normally generates constructors and accessors
    * dynamically. This doesn't work in CSP mode, so dart2js emits them directly
    * when in CSP mode.
    */
   Map<OutputUnit, List<jsAst.Node>> _cspPrecompiledFunctions =
@@ skipping 396 matching lines @@
   }
 
   String namedParametersAsReflectionNames(CallStructure structure) {
     if (structure.isUnnamed) return '';
     String names = structure.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
   jsAst.Statement buildCspPrecompiledFunctionFor(
       OutputUnit outputUnit) {
-    if (compiler.useContentSecurityPolicy) {
+    if (compiler.options.useContentSecurityPolicy) {
       // TODO(ahe): Compute a hash code.
       // TODO(sigurdm): Avoid this precompiled function. Generated
       // constructor-functions and getter/setter functions can be stored in the
       // library-description table. Setting properties on these can be moved to
       // finishClasses.
       return js.statement(r"""
         #precompiled = function ($collectedClasses$) {
           #norename;
           var $desc;
           #functions;
           return #result;
         };""",
         {'norename': new jsAst.Comment("// ::norenaming:: "),
          'precompiled': generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
          'functions': cspPrecompiledFunctionFor(outputUnit),
          'result': new jsAst.ArrayInitializer(
                cspPrecompiledConstructorNamesFor(outputUnit))});
     } else {
       return js.comment("Constructors are generated at runtime.");
     }
   }
 
   void assembleClass(Class cls, ClassBuilder enclosingBuilder,
                      Fragment fragment) {
     ClassElement classElement = cls.element;
     reporter.withCurrentElement(classElement, () {
-      if (compiler.hasIncrementalSupport) {
+      if (compiler.options.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder =
                   new ClassBuilder.forClass(classElement, namer);
               classEmitter.emitClass(cls, builder, fragment);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
@@ skipping 92 matching lines @@
             }
           } else {
             if (#notMinified) {
               #lazy(fieldName, getterName, lazyValue, staticName, fieldHolder);
             } else {
               #lazy(fieldName, getterName, lazyValue, null, fieldHolder);
             }
           }
         }
       })(#laziesInfo)
-      ''', {'notMinified': !compiler.enableMinification,
+      ''', {'notMinified': !compiler.options.enableMinification,
             'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
             'lazy': js(lazyInitializerName),
             'isMainFragment': isMainFragment,
             'isDeferredFragment': !isMainFragment});
     } else {
       return js.comment("No lazy statics.");
     }
   }
 
   List<jsAst.Expression> buildLaziesInfo(
       Iterable<StaticField> lazies, bool isMainFragment) {
     List<jsAst.Expression> laziesInfo = <jsAst.Expression>[];
     for (StaticField field in lazies) {
       laziesInfo.add(js.quoteName(field.name));
       laziesInfo.add(js.quoteName(namer.deriveLazyInitializerName(field.name)));
       laziesInfo.add(field.code);
-      if (!compiler.enableMinification) {
+      if (!compiler.options.enableMinification) {
         laziesInfo.add(js.quoteName(field.name));
       }
       if (!isMainFragment) {
         laziesInfo.add(js('#', field.holder.name));
       }
     }
     return laziesInfo;
   }
 
   // TODO(sra): Remove this unused function.
@@ skipping 14 matching lines @@
       // in new lazy values.
       return js('#(#,#,#,#,#)',
           [js(lazyInitializerName),
            js.quoteName(namer.globalPropertyName(element)),
            js.quoteName(namer.lazyInitializerName(element)),
            code,
            js.string(element.name),
            isolateProperties]);
     }
 
-    if (compiler.enableMinification) {
+    if (compiler.options.enableMinification) {
       return js('#(#,#,#)',
           [js(lazyInitializerName),
            js.quoteName(namer.globalPropertyName(element)),
            js.quoteName(namer.lazyInitializerName(element)),
            code]);
     } else {
       return js('#(#,#,#,#)',
           [js(lazyInitializerName),
            js.quoteName(namer.globalPropertyName(element)),
            js.quoteName(namer.lazyInitializerName(element)),
@@ skipping 21 matching lines @@
     }
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildCompileTimeConstants(List<Constant> constants,
                                            {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return js.comment("No constants in program.");
     List<jsAst.Statement> parts = <jsAst.Statement>[];
-    if (compiler.hasIncrementalSupport && isMainFragment) {
+    if (compiler.options.hasIncrementalSupport && isMainFragment) {
       parts = cachedEmittedConstantsAst;
     }
     for (Constant constant in constants) {
       ConstantValue constantValue = constant.value;
-      if (compiler.hasIncrementalSupport && isMainFragment) {
+      if (compiler.options.hasIncrementalSupport && isMainFragment) {
         if (cachedEmittedConstants.contains(constantValue)) continue;
         cachedEmittedConstants.add(constantValue);
       }
       parts.add(buildConstantInitializer(constantValue));
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildConstantInitializer(ConstantValue constant) {
@@ skipping 196 matching lines @@
             'interceptorsByTag': interceptorsByTagAccess,
             'leafTags': leafTagsAccess,
             'finishedClasses': finishedClassesAccess,
             'needsLazyInitializer': needsLazyInitializer,
             'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
             'isolatePropertiesName': namer.isolatePropertiesName,
             'outputContainsConstantList': outputContainsConstantList,
             'makeConstListProperty': makeConstListProperty,
             'functionThatReturnsNullProperty':
                 backend.rtiEncoder.getFunctionThatReturnsNullName,
-            'hasIncrementalSupport': compiler.hasIncrementalSupport,
+            'hasIncrementalSupport': compiler.options.hasIncrementalSupport,
             'lazyInitializerProperty': lazyInitializerProperty,});
   }
 
   jsAst.Statement buildConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
@@ skipping 25 matching lines @@
       // mode.
       properties.__MAGIC_SLOW_PROPERTY = 1;
       delete properties.__MAGIC_SLOW_PROPERTY;
       return properties;
     }''');
   }
 
   jsAst.Statement buildSupportsDirectProtoAccess() {
     jsAst.Statement supportsDirectProtoAccess;
 
-    if (compiler.hasIncrementalSupport) {
+    if (compiler.options.hasIncrementalSupport) {
       supportsDirectProtoAccess = js.statement(r'''
         var supportsDirectProtoAccess = false;
       ''');
     } else {
       supportsDirectProtoAccess = js.statement(r'''
         var supportsDirectProtoAccess = (function () {
           var cls = function () {};
           cls.prototype = {'p': {}};
           var object = new cls();
           return object.__proto__ &&
                  object.__proto__.p === cls.prototype.p;
          })();
       ''');
     }
 
     return supportsDirectProtoAccess;
   }
 
   jsAst.Expression generateLibraryDescriptor(LibraryElement library,
                                              Fragment fragment) {
     var uri = "";
-    if (!compiler.enableMinification || backend.mustPreserveUris) {
+    if (!compiler.options.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
-      if (uri.scheme == 'file' && compiler.outputUri != null) {
-        uri = relativize(compiler.outputUri, library.canonicalUri, false);
+      if (uri.scheme == 'file' && compiler.options.outputUri != null) {
+        uri = relativize(
+        compiler.options.outputUri, library.canonicalUri, false);
       }
     }
 
-    String libraryName =
-        (!compiler.enableMinification || backend.mustRetainLibraryNames) ?
-        library.libraryName :
-        "";
+    String libraryName = (!compiler.options.enableMinification ||
+        backend.mustRetainLibraryNames) ? library.libraryName : "";
 
     jsAst.Fun metadata = task.metadataCollector.buildMetadataFunction(library);
 
     ClassBuilder descriptor = elementDescriptors[fragment][library];
 
     jsAst.ObjectInitializer initializer;
     if (descriptor == null) {
       // Nothing of the library was emitted.
       // TODO(floitsch): this should not happen. We currently have an example
       // with language/prefix6_negative_test.dart where we have an instance
@@ skipping 216 matching lines @@
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       jsAst.ObjectInitializer map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
 
     return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
-    if (!compiler.hasIncrementalSupport) {
+    if (!compiler.options.hasIncrementalSupport) {
       pendingStatics =
           Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
       pendingStatics.forEach((element) =>
           reporter.reportInfo(
               element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
     }
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
       reporter.internalError(pendingStatics.first,
@@ skipping 66 matching lines @@
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries = descriptors.keys
       .where((Element e) => e is LibraryElement)
       .toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
       for (LibraryElement element in remainingLibraries) {
-        assert(element is LibraryElement || compiler.hasIncrementalSupport);
+        assert(element is LibraryElement ||
+            compiler.options.hasIncrementalSupport);
         if (element is LibraryElement) {
           parts.add(generateLibraryDescriptor(element, mainFragment));
           descriptors.remove(element);
         }
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
@@ skipping 102 matching lines @@
 
        #convertGlobalObjectsToFastObjects;
        #debugFastObjects;
 
        #init;
 
        #main;
     })();
     """, {
       "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
-      "hasIncrementalSupport": compiler.hasIncrementalSupport,
+      "hasIncrementalSupport": compiler.options.hasIncrementalSupport,
       "helper": js('this.#', [namer.incrementalHelperName]),
       "schemaChange": buildSchemaChangeFunction(),
       "addMethod": buildIncrementalAddMethod(),
       "isProgramSplit": isProgramSplit,
       "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
       "globalsHolder": globalsHolder,
       "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
       "isolateName": namer.isolateName,
       "isolatePropertiesName": js(isolatePropertiesName),
       "initName": initName,
@@ skipping 39 matching lines @@
 
     CodeOutput mainOutput =
         new StreamCodeOutput(compiler.outputProvider('', 'js'),
                              codeOutputListeners);
     outputBuffers[mainOutputUnit] = mainOutput;
 
 
     mainOutput.addBuffer(jsAst.createCodeBuffer(
         program, compiler, monitor: compiler.dumpInfoTask));
 
-    if (compiler.deferredMapUri != null) {
+    if (compiler.options.deferredMapUri != null) {
       outputDeferredMap();
     }
 
     if (generateSourceMap) {
-      mainOutput.add(
-          generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
+      mainOutput.add(generateSourceMapTag(
+          compiler.options.sourceMapUri, compiler.options.outputUri));
     }
 
     mainOutput.close();
 
     if (generateSourceMap) {
       outputSourceMap(mainOutput, lineColumnCollector, '',
-          compiler.sourceMapUri, compiler.outputUri);
+          compiler.options.sourceMapUri, compiler.options.outputUri);
     }
   }
 
   /// Used by incremental compilation to patch up the prototype of
   /// [oldConstructor] for use as prototype of [newConstructor].
   jsAst.Fun buildSchemaChangeFunction() {
-    if (!compiler.hasIncrementalSupport) return null;
+    if (!compiler.options.hasIncrementalSupport) return null;
     return js('''
 function(newConstructor, oldConstructor, superclass) {
   // Invariant: newConstructor.prototype has no interesting properties besides
   // generated accessors. These are copied to oldPrototype which will be
   // updated by other incremental changes.
   if (superclass != null) {
     this.inheritFrom(newConstructor, superclass);
   }
   var oldPrototype = oldConstructor.prototype;
   var newPrototype = newConstructor.prototype;
@@ skipping 12 matching lines @@
   }
 
   /// Used by incremental compilation to patch up an object ([holder]) with a
   /// new (or updated) method.  [arrayOrFunction] is either the new method, or
   /// an array containing the method (see
   /// [ContainerBuilder.addMemberMethodFromInfo]). [name] is the name of the
   /// new method. [isStatic] tells if method is static (or
   /// top-level). [globalFunctionsAccess] is a reference to
   /// [embeddedNames.GLOBAL_FUNCTIONS].
   jsAst.Fun buildIncrementalAddMethod() {
-    if (!compiler.hasIncrementalSupport) return null;
+    if (!compiler.options.hasIncrementalSupport) return null;
     return js(r"""
 function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
   var arrayOrFunction = originalDescriptor[name];
   var method;
   if (arrayOrFunction.constructor === Array) {
     var existing = holder[name];
     var array = arrayOrFunction;
 
     // Each method may have a number of stubs associated. For example, if an
     // instance method supports multiple arguments, a stub for each matching
@@ skipping 306 matching lines @@
                              '#globalsHolder.${namer.isolateName};',
                              {'globalsHolder': globalsHolder}));
       String typesAccess =
           generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
       if (libraryDescriptor != null) {
         // The argument to reflectionDataParser is assigned to a temporary
         // 'dart' so that 'dart.' will appear as the prefix to dart methods
         // in stack traces and profile entries.
         body.add(js.statement('var dart = #', libraryDescriptor));
 
-        if (compiler.useContentSecurityPolicy) {
+        if (compiler.options.useContentSecurityPolicy) {
           body.add(buildCspPrecompiledFunctionFor(outputUnit));
         }
         body.add(
             js.statement('$setupProgramName(dart, ${typesAccess}.length);'));
       }
 
       body..add(buildMetadata(program, outputUnit))
           ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
                              '${namer.deferredTypesName});'));
 
@@ skipping 54 matching lines @@
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hasher.getHash();
 
       output.add('$N${deferredInitializers}["$hash"]$_=$_'
                        '${deferredInitializers}.current$N');
 
       if (generateSourceMap) {
         Uri mapUri, partUri;
-        Uri sourceMapUri = compiler.sourceMapUri;
-        Uri outputUri = compiler.outputUri;
+        Uri sourceMapUri = compiler.options.sourceMapUri;
+        Uri outputUri = compiler.options.outputUri;
 
         String partName = "$partPrefix.part";
 
         if (sourceMapUri != null) {
           String mapFileName = partName + ".js.map";
           List<String> mapSegments = sourceMapUri.pathSegments.toList();
           mapSegments[mapSegments.length - 1] = mapFileName;
-          mapUri = compiler.sourceMapUri.replace(pathSegments: mapSegments);
+          mapUri = compiler.options.sourceMapUri
+              .replace(pathSegments: mapSegments);
         }
 
         if (outputUri != null) {
           String partFileName = partName + ".js";
           List<String> partSegments = outputUri.pathSegments.toList();
           partSegments[partSegments.length - 1] = partFileName;
-          partUri = compiler.outputUri.replace(pathSegments: partSegments);
+          partUri = compiler.options.outputUri.replace(
+              pathSegments: partSegments);
         }
 
         output.add(generateSourceMapTag(mapUri, partUri));
         output.close();
         outputSourceMap(output, lineColumnCollector, partName,
                         mapUri, partUri);
       } else {
         output.close();
       }
 
       hunkHashes[outputUnit] = hash;
     }
     return hunkHashes;
   }
 
   jsAst.Comment buildGeneratedBy() {
     List<String> options = [];
     if (compiler.mirrorsLibrary != null) options.add('mirrors');
-    if (compiler.useContentSecurityPolicy) options.add("CSP");
+    if (compiler.options.useContentSecurityPolicy) options.add("CSP");
     return new jsAst.Comment(generatedBy(compiler, flavor: options.join(", ")));
   }
 
   void outputSourceMap(CodeOutput output,
                        LineColumnProvider lineColumnProvider,
                        String name,
                        [Uri sourceMapUri,
                         Uri fileUri]) {
     if (!generateSourceMap) return;
     // Create a source file for the compilation output. This allows using
     // [:getLine:] to transform offsets to line numbers in [SourceMapBuilder].
     SourceMapBuilder sourceMapBuilder =
             new SourceMapBuilder(sourceMapUri, fileUri, lineColumnProvider);
     output.forEachSourceLocation(sourceMapBuilder.addMapping);
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void outputDeferredMap() {
     Map<String, dynamic> mapping = new Map<String, dynamic>();
     // Json does not support comments, so we embed the explanation in the
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
-    compiler.outputProvider(compiler.deferredMapUri.path, 'deferred_map')
+    compiler.outputProvider(
+            compiler.options.deferredMapUri.path, 'deferred_map')
         ..add(const JsonEncoder.withIndent("  ").convert(mapping))
         ..close();
   }
 
   void invalidateCaches() {
-    if (!compiler.hasIncrementalSupport) return;
+    if (!compiler.options.hasIncrementalSupport) return;
     if (cachedElements.isEmpty) return;
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }