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

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1187 matching lines @@
     node.accept(this);
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   Element get sourceElement => sourceElementStack.last;
 
-  bool get _checkOrTrustTypes =>
-      compiler.enableTypeAssertions || compiler.trustTypeAnnotations;
+  bool get _checkOrTrustTypes => compiler.options.enableTypeAssertions ||
+      compiler.options.trustTypeAnnotations;
 
   /// Build the graph for [target].
   HGraph build() {
     assert(invariant(target, target.isImplementation));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
       result = buildFactory(target);
     } else if (target.isGenerativeConstructorBody ||
                target.isFactoryConstructor ||
                target.isFunction ||
                target.isGetter ||
                target.isSetter) {
       result = buildMethod(target);
     } else if (target.isField) {
       if (target.isInstanceMember) {
-        assert(compiler.enableTypeAssertions);
+        assert(compiler.options.enableTypeAssertions);
         result = buildCheckedSetter(target);
       } else {
         result = buildLazyInitializer(target);
       }
     } else {
       reporter.internalError(target, 'Unexpected element kind $target.');
     }
     assert(result.isValid());
     return result;
   }
@@ skipping 180 matching lines @@
     FunctionElement function = element;
     bool insideLoop = loopNesting > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
-      if (compiler.disableInlining) return false;
+      if (compiler.options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : element,
           selector != null ||
           Elements.isStaticOrTopLevel(element) ||
           element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
       if (selector != null) {
         if (!selector.applies(function, compiler.world)) return false;
         if (mask != null && !mask.canHit(function, selector, compiler.world)) {
@@ skipping 30 matching lines @@
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
       return InlineWeeder.canBeInlined(function, 1, true,
-          enableUserAssertions: compiler.enableUserAssertions);
+          enableUserAssertions: compiler.options.enableUserAssertions);
     }
 
     bool reductiveHeuristic() {
       // The call is on a path which is executed rarely, so inline only if it
       // does not make the program larger.
       if (isCalledOnce(element)) {
         return InlineWeeder.canBeInlined(function, -1, false,
-            enableUserAssertions: compiler.enableUserAssertions);
+            enableUserAssertions: compiler.options.enableUserAssertions);
       }
       // TODO(sra): Measure if inlining would 'reduce' the size.  One desirable
       // case we miss by doing nothing is inlining very simple constructors
       // where all fields are initialized with values from the arguments at this
       // call site.  The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but
       // that usually means the factory constructor is left unused and not
       // emitted.
       // We at least inline bodies that are empty (and thus have a size of 1).
       return doesNotContainCode();
     }
@@ skipping 18 matching lines @@
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
 
       if (cachedCanBeInlined == true) {
         // We may have forced the inlining of some methods. Therefore check
         // if we can inline this method regardless of size.
         assert(InlineWeeder.canBeInlined(function, -1, false,
                 allowLoops: true,
-                enableUserAssertions: compiler.enableUserAssertions));
+                enableUserAssertions: compiler.options.enableUserAssertions));
         return true;
       }
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       bool useMaxInliningNodes = true;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
       if (isCalledOnce(element)) {
         useMaxInliningNodes = false;
       }
       bool canInline;
       canInline = InlineWeeder.canBeInlined(
           function, maxInliningNodes, useMaxInliningNodes,
-          enableUserAssertions: compiler.enableUserAssertions);
+          enableUserAssertions: compiler.options.enableUserAssertions);
       if (canInline) {
         backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop);
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
@@ skipping 1073 matching lines @@
           null,
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
   HInstruction _trustType(HInstruction original, DartType type) {
-    assert(compiler.trustTypeAnnotations);
+    assert(compiler.options.trustTypeAnnotations);
     assert(type != null);
     type = localsHandler.substInContext(type);
     type = type.unaliased;
     if (type.isDynamic) return original;
     if (!type.isInterfaceType) return original;
     if (type.isObject) return original;
     // The type element is either a class or the void element.
     Element element = type.element;
     TypeMask mask = new TypeMask.subtype(element, compiler.world);
     return new HTypeKnown.pinned(mask, original);
   }
 
   HInstruction _checkType(HInstruction original, DartType type, int kind) {
-    assert(compiler.enableTypeAssertions);
+    assert(compiler.options.enableTypeAssertions);
     assert(type != null);
     type = localsHandler.substInContext(type);
     HInstruction other = buildTypeConversion(original, type, kind);
     registry?.registerTypeUse(new TypeUse.isCheck(type));
     return other;
   }
 
   HInstruction potentiallyCheckOrTrustType(HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (type == null) return original;
     HInstruction checkedOrTrusted = original;
-    if (compiler.trustTypeAnnotations) {
+    if (compiler.options.trustTypeAnnotations) {
       checkedOrTrusted = _trustType(original, type);
-    } else if (compiler.enableTypeAssertions) {
+    } else if (compiler.options.enableTypeAssertions) {
       checkedOrTrusted = _checkType(original, type, kind);
     }
     if (checkedOrTrusted == original) return original;
     add(checkedOrTrusted);
     return checkedOrTrusted;
   }
 
   void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype,
                        String message) {
     HInstruction subtypeInstruction =
@@ skipping 59 matching lines @@
     if (node != null) node.accept(this);
   }
 
   /// Visit [node] and pop the resulting [HInstruction].
   HInstruction visitAndPop(ast.Node node) {
     node.accept(this);
     return pop();
   }
 
   visitAssert(ast.Assert node) {
-    if (!compiler.enableUserAssertions) return;
+    if (!compiler.options.enableUserAssertions) return;
 
     if (!node.hasMessage) {
       // Generate:
       //
       //     assertHelper(condition);
       //
       visit(node.condition);
       pushInvokeStatic(node, helpers.assertHelper, [pop()]);
       pop();
       return;
@@ skipping 1549 matching lines @@
            argument, MessageKind.GENERIC,
            {'text': 'Error: Expected a literal string.'});
      }
      String name = string.dartString.slowToString();
      bool value = false;
      switch (name) {
        case 'MUST_RETAIN_METADATA':
          value = backend.mustRetainMetadata;
          break;
        case 'USE_CONTENT_SECURITY_POLICY':
-         value = compiler.useContentSecurityPolicy;
+         value = compiler.options.useContentSecurityPolicy;
          break;
        default:
          reporter.reportErrorMessage(
              node, MessageKind.GENERIC,
              {'text': 'Error: Unknown internal flag "$name".'});
      }
      stack.add(graph.addConstantBool(value, compiler));
   }
 
   void handleForeignJsGetName(ast.Send node) {
@@ skipping 1012 matching lines @@
         cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(
           argument, sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
-    if (!compiler.enableTypeAssertions) return false;
+    if (!compiler.options.enableTypeAssertions) return false;
 
     Map<DartType, Set<DartType>> seenChecksMap =
         new Map<DartType, Set<DartType>>();
     bool definitelyFails = false;
 
     addTypeVariableBoundCheck(GenericType instance,
                               DartType typeArgument,
                               TypeVariableType typeVariable,
                               DartType bound) {
       if (definitelyFails) return;
@@ skipping 619 matching lines @@
           parameterNameMap[parameter.name] =
               new js.InterpolatedExpression(positions++);
         }
         i++;
       });
       var codeTemplate = new js.Template(null,
           js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
-      if (compiler.trustJSInteropTypeAnnotations) {
+      if (compiler.options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
           codeTemplate,
           backend.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
     var target = new HForeignCode(js.js.parseForeignJS(
             "${backend.namer.fixedBackendPath(element)}."
@@ skipping 10 matching lines @@
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
     DartType type = element.isConstructor ?
         element.enclosingClass.thisType : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
     nativeBehavior.typesReturned.add(
-        compiler.trustJSInteropTypeAnnotations ? type : const DynamicType());
+        compiler.options.trustJSInteropTypeAnnotations
+            ? type : const DynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
-    if (!compiler.trustJSInteropTypeAnnotations || type.isObject ||
+    if (!compiler.options.trustJSInteropTypeAnnotations || type.isObject ||
         type.isDynamic) {
       nativeBehavior.typesInstantiated.add(
           backend.helpers.jsJavaScriptObjectClass.thisType);
     }
 
     String code;
     if (element.isGetter) {
       code = "#";
     } else if (element.isSetter) {
       code = "# = #";
@@ skipping 1278 matching lines @@
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
       if (isBuildingAsyncFunction) {
-        if (compiler.enableTypeAssertions &&
+        if (compiler.options.enableTypeAssertions &&
             !isValidAsyncReturnType(returnType)) {
           String message =
                 "Async function returned a Future, "
                 "was declared to return a $returnType.";
           generateTypeError(node, message);
           pop();
           return;
         }
       } else {
         value = potentiallyCheckOrTrustType(value, returnType);
@@ skipping 1976 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }