Remove Compiler access from ResolutionEnqueuer

pkg/compiler/lib/src/universe/world_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.
 
 library universe;
 
 import 'dart:collection';
 
+import '../cache_strategy.dart';
 import '../common.dart';
+import '../common/backend_api.dart' show Backend;
+import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
+import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
 import '../elements/elements.dart';
+import '../types/masks.dart' show CommonMasks;
 import '../universe/class_set.dart' show Instantiation;
 import '../util/enumset.dart';
 import '../util/util.dart';
-import '../world.dart' show World, ClosedWorld, OpenWorld;
+import '../world.dart' show World, ClosedWorld, OpenWorld, WorldImpl;
 import 'selector.dart' show Selector;
 import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
 /// The known constraint on receiver for a dynamic call site.
 ///
 /// This can for instance be used to constrain this dynamic call to `foo` to
 /// 'receivers of the exact instance `Bar`':
 ///
 ///     class Bar {
 ///        void foo() {}
@@ skipping 86 matching lines @@
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses;
 
   /// All types that are checked either through is, as or checked mode checks.
   Iterable<DartType> get isChecks;
 
   /// Registers that [type] is checked in this universe. The unaliased type is
   /// returned.
-  DartType registerIsCheck(DartType type, Compiler compiler);
+  DartType registerIsCheck(DartType type, Resolution resolution);
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<DartType> get instantiatedTypes;
 
   /// Returns `true` if [member] is invoked as a setter.
   bool hasInvokedSetter(Element member, World world);
 }
 
@@ skipping 21 matching lines @@
   /// subtypes. The latter case only contains spurious information from
   /// instantiations through factory constructors and mixins.
   bool isImplemented(ClassElement cls);
 
   /// Set of all fields that are statically known to be written to.
   Iterable<Element> get fieldSetters;
 
   /// Call [f] for all directly or abstractly instantiated classes.
   void forEachInstantiatedClass(
       f(ClassElement cls, EnumSet<Instantiation> instantiations));
+
+  /// `true` of `Object.runtimeType` is supported.
+  bool get hasRuntimeTypeSupport;
+
+  /// `true` of use of the `dart:isolate` library is supported.
+  bool get hasIsolateSupport;
+
+  /// `true` of `Function.apply` is supported.
+  bool get hasFunctionApplySupport;
+
+  /// The [OpenWorld] being created by this world builder.
+  // TODO(johnniwinther): Merge this with [ResolutionWorldBuilder].
+  OpenWorld get openWorld;
 }
 
 class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
@@ skipping 54 matching lines @@
   final Set<LocalFunctionElement> allClosures = new Set<LocalFunctionElement>();
 
   /**
    * Set of methods in instantiated classes that are potentially
    * closurized.
    */
   final Set<Element> closurizedMembers = new Set<Element>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
-  ResolutionWorldBuilderImpl(this.selectorConstraintsStrategy);
+  bool hasRuntimeTypeSupport = false;
+  bool hasIsolateSupport = false;
+  bool hasFunctionApplySupport = false;
+
+  OpenWorld _openWorld;
+
+  ResolutionWorldBuilderImpl(Backend backend, CoreClasses coreClasses,
+      CacheStrategy cacheStrategy, this.selectorConstraintsStrategy) {
+    _openWorld = new WorldImpl(this, backend, coreClasses, cacheStrategy);
+  }
+
+  OpenWorld get openWorld => _openWorld;
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses.keys;
   }
 
   /// All directly instantiated types, that is, the types of the directly
@@ skipping 108 matching lines @@
     ReceiverConstraint mask = dynamicUse.mask;
     Map<Selector, SelectorConstraints> selectors = selectorMap.putIfAbsent(
         name, () => new Maplet<Selector, SelectorConstraints>());
     UniverseSelectorConstraints constraints =
         selectors.putIfAbsent(selector, () {
       return selectorConstraintsStrategy.createSelectorConstraints(selector);
     });
     return constraints.addReceiverConstraint(mask);
   }
 
-  DartType registerIsCheck(DartType type, Compiler compiler) {
-    type.computeUnaliased(compiler.resolution);
+  DartType registerIsCheck(DartType type, Resolution resolution) {
+    type.computeUnaliased(resolution);
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
   }
 
   void registerStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
@@ skipping 257 matching lines @@
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedGetters.forEach(f);
   }
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedSetters.forEach(f);
   }
 
-  DartType registerIsCheck(DartType type, Compiler compiler) {
-    type.computeUnaliased(compiler.resolution);
+  DartType registerIsCheck(DartType type, Resolution resolution) {
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
   }
 
   void registerStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
@@ skipping 21 matching lines @@
 
   void forgetElement(Element element, Compiler compiler) {
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
       assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
       _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 }