Remove CodegenEnqueuer.compiler

pkg/compiler/lib/src/js_backend/enqueuer.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 dart2js.js.enqueue;
 
 import 'dart:collection' show Queue;
 
+import '../cache_strategy.dart' show CacheStrategy;
 import '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/names.dart' show Identifiers;
 import '../common/tasks.dart' show CompilerTask;
 import '../common/work.dart' show WorkItem;
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart' show DartType, InterfaceType;
+import '../dump_info.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         Entity,
         FunctionElement,
         MemberElement,
         MethodElement,
         TypedElement;
 import '../elements/entities.dart';
 import '../enqueue.dart';
 import '../js/js.dart' as js;
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../types/types.dart' show TypeMaskStrategy;
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import '../universe/world_impact.dart'
     show ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import '../util/util.dart' show Setlet;
 import '../world.dart';
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends EnqueuerImpl {
   final String name;
-  @deprecated
-  final Compiler _compiler; // TODO(ahe): Remove this dependency.
   final EnqueuerStrategy strategy;
   final Map<String, Set<Element>> _instanceMembersByName =
       new Map<String, Set<Element>>();
   final Map<String, Set<Element>> _instanceFunctionsByName =
       new Map<String, Set<Element>>();
   final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> _recentClasses = new Setlet<ClassElement>();
   final CodegenWorldBuilderImpl _universe =
       new CodegenWorldBuilderImpl(const TypeMaskStrategy());
 
   bool queueIsClosed = false;
   final CompilerTask task;
   final native.NativeEnqueuer nativeEnqueuer;
+  final Backend _backend;
+  final CompilerOptions _options;
 
   WorldImpactVisitor _impactVisitor;
 
-  final Queue<WorkItem> queue = new Queue<WorkItem>();
+  final Queue<WorkItem> _queue = new Queue<WorkItem>();
   final Map<Element, js.Expression> generatedCode = <Element, js.Expression>{};
 
   final Set<Element> newlyEnqueuedElements;
 
   final Set<DynamicUse> newlySeenSelectors;
 
   bool _enabledNoSuchMethod = false;
 
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('CodegenEnqueuer');
 
-  CodegenEnqueuer(this.task, Compiler compiler, this.strategy)
-      : newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
-        newlySeenSelectors = compiler.cacheStrategy.newSet(),
-        nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(),
-        this.name = 'codegen enqueuer',
-        this._compiler = compiler {
+  CodegenEnqueuer(this.task, CacheStrategy cacheStrategy, Backend backend,
+      this._options, this.strategy)
+      : newlyEnqueuedElements = cacheStrategy.newSet(),
+        newlySeenSelectors = cacheStrategy.newSet(),
+        nativeEnqueuer = backend.nativeCodegenEnqueuer(),
+        this._backend = backend,
+        this.name = 'codegen enqueuer' {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   CodegenWorldBuilder get universe => _universe;
 
-  Backend get _backend => _compiler.backend;
+  // TODO(johnniwinther): Remove these hacks:
+  ClosedWorld get _world => _backend.compiler.closedWorld;
+  DumpInfoTask get _dumpInfoTask => _backend.compiler.dumpInfoTask;
 
-  CompilerOptions get _options => _compiler.options;
-
-  ClosedWorld get _world => _compiler.closedWorld;
-
-  bool get queueIsEmpty => queue.isEmpty;
+  bool get queueIsEmpty => _queue.isEmpty;
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void _addToWorkList(Element element) {
@@ skipping 11 matching lines @@
     }
 
     if (_options.hasIncrementalSupport && !isProcessed(element)) {
       newlyEnqueuedElements.add(element);
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element, "Codegen work list is closed. Trying to add $element");
     }
-    queue.add(new CodegenWorkItem(_backend, element));
+    _queue.add(new CodegenWorkItem(_backend, element));
     // TODO(sigmund): add other missing dependencies (internals, selectors
     // enqueued after allocations).
-    _compiler.dumpInfoTask
-        .registerDependency(_compiler.currentElement, element);
+    _dumpInfoTask.registerDependency(element);
   }
 
   void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
   void _registerInstantiatedType(InterfaceType type,
       {bool mirrorUsage: false, bool nativeUsage: false}) {
@@ skipping 263 matching lines @@
         if (_options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
-    type = _universe.registerIsCheck(type, _compiler.resolution);
+    type = _universe.registerIsCheck(type);
     // 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.
     assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
   }
 
   void _registerCallMethodWithFreeTypeVariables(Element element) {
     applyImpact(_backend.registerCallMethodWithFreeTypeVariables(element,
         forResolution: false));
   }
 
   void _registerClosurizedMember(TypedElement element) {
     assert(element.isInstanceMember);
     if (element.type.containsTypeVariables) {
       applyImpact(_backend.registerClosureWithFreeTypeVariables(element,
           forResolution: false));
     }
     applyImpact(_backend.registerBoundClosure());
   }
 
   void forEach(void f(WorkItem work)) {
     do {
-      while (queue.isNotEmpty) {
+      while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
-        WorkItem work = queue.removeLast();
+        WorkItem work = _queue.removeLast();
         if (!isProcessed(work.element)) {
           strategy.processWorkItem(f, work);
           // TODO(johnniwinther): Register the processed element here. This
           // is currently a side-effect of calling `work.run`.
         }
       }
       List recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       if (!_onQueueEmpty(recents)) _recentClasses.addAll(recents);
-    } while (queue.isNotEmpty || _recentClasses.isNotEmpty);
+    } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
   }
 
   /// [_onQueueEmpty] is called whenever the queue is drained. [recentClasses]
   /// contains the set of all classes seen for the first time since
   /// [_onQueueEmpty] was called last. A return value of [true] indicates that
   /// the [recentClasses] have been processed and may be cleared. If [false] is
   /// returned, [_onQueueEmpty] will be called once the queue is empty again (or
   /// still empty) and [recentClasses] will be a superset of the current value.
   bool _onQueueEmpty(Iterable<ClassElement> recentClasses) {
     return _backend.onQueueEmpty(this, recentClasses);
@@ skipping 12 matching lines @@
       member.isAbstract || generatedCode.containsKey(member);
 
   void _registerNoSuchMethod(Element element) {
     if (!_enabledNoSuchMethod && _backend.enabledNoSuchMethod) {
       applyImpact(_backend.enableNoSuchMethod());
       _enabledNoSuchMethod = true;
     }
   }
 
   void forgetEntity(Element element, Compiler compiler) {
-    _universe.forgetElement(element, _compiler);
+    _universe.forgetElement(element, compiler);
     _processedClasses.remove(element);
     _instanceMembersByName[element.name]?.remove(element);
     _instanceFunctionsByName[element.name]?.remove(element);
     generatedCode.remove(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         generatedCode.remove(closure);
         removeFromSet(_instanceMembersByName, closure);
         removeFromSet(_instanceFunctionsByName, closure);
       }
     }
   }
 
   @override
   Iterable<Entity> get processedEntities => generatedCode.keys;
 
   @override
   Iterable<ClassEntity> get processedClasses => _processedClasses;
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }