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

pkg/compiler/lib/src/native/behavior.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.
 
 import '../common.dart';
 import '../common/backend_api.dart' show
     ForeignResolver;
 import '../common/resolution.dart' show
     Parsing,
     Resolution;
@@ skipping 688 matching lines @@
     // Note: For dart:html and other internal libraries we maintain, we can
     // trust the return type and use it to limit what we enqueue. We have to
     // be more conservative about JS interop types and assume they can return
     // anything (unless the user provides the experimental flag to trust the
     // type of js-interop APIs). We do restrict the allocation effects and say
     // that interop calls create only interop types (which may be unsound if
     // an interop call returns a DOM type and declares a dynamic return type,
     // but otherwise we would include a lot of code by default).
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
-        !isInterop || compiler.trustJSInteropTypeAnnotations ? returnType
-        : const DynamicType());
+        !isInterop || compiler.options.trustJSInteropTypeAnnotations
+            ? returnType : const DynamicType());
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
       behavior.typesReturned.add(compiler.coreTypes.nullType);
     }
     behavior._capture(type, compiler.resolution,
         isInterop: isInterop, compiler: compiler);
 
     // TODO(sra): Optional arguments are currently missing from the
     // DartType. This should be fixed so the following work-around can be
     // removed.
     method.functionSignature.forEachOptionalParameter(
         (ParameterElement parameter) {
           behavior._escape(parameter.type, compiler.resolution);
         });
 
     behavior._overrideWithAnnotations(method, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldLoad(MemberElement field, Compiler compiler) {
     Resolution resolution = compiler.resolution;
     DartType type = field.computeType(resolution);
     var behavior = new NativeBehavior();
     bool isInterop = compiler.backend.isJsInterop(field);
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
-        !isInterop || compiler.trustJSInteropTypeAnnotations ? type
-        : const DynamicType());
+        !isInterop || compiler.options.trustJSInteropTypeAnnotations
+            ? type : const DynamicType());
     // Declared types are nullable.
     behavior.typesReturned.add(resolution.coreTypes.nullType);
     behavior._capture(type, resolution,
         isInterop: isInterop, compiler: compiler);
     behavior._overrideWithAnnotations(field, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldStore(MemberElement field, Compiler compiler) {
     Resolution resolution = compiler.resolution;
@@ skipping 103 matching lines @@
       JavaScriptBackend backend = compiler?.backend;
       if (!isInterop) {
         typesInstantiated.add(type);
       } else {
         if (type.element != null && backend.isNative(type.element)) {
           // Any declared native or interop type (isNative implies isJsInterop)
           // is assumed to be allocated.
           typesInstantiated.add(type);
         }
 
-        if (!compiler.trustJSInteropTypeAnnotations ||
+        if (!compiler.options.trustJSInteropTypeAnnotations ||
           type.isDynamic || type.isObject) {
           // By saying that only JS-interop types can be created, we prevent
           // pulling in every other native type (e.g. all of dart:html) when a
           // JS interop API returns dynamic or when we don't trust the type
           // annotations. This means that to some degree we still use the return
           // type to decide whether to include native types, even if we don't
           // trust the type annotation.
           ClassElement cls = backend.helpers.jsJavaScriptObjectClass;
           cls.ensureResolved(resolution);
           typesInstantiated.add(cls.thisType);
@@ skipping 38 matching lines @@
         MessageKind.GENERIC,
         {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 
   static _errorNode(locationNodeOrElement, Parsing parsing) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(parsing);
   }
 }