Remove Compiler access from ResolutionEnqueuer

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 '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/registry.dart' show Registry;
 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 '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Element,
         Elements,
         Entity,
         FunctionElement,
         LibraryElement,
         Member,
         MemberElement,
         MethodElement,
         Name,
         TypedElement,
         TypedefElement;
 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;
+    show ImpactUseCase, ImpactStrategy, WorldImpact, WorldImpactVisitor;
 import '../util/util.dart' show Setlet;
 import '../world.dart';
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer implements Enqueuer {
   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;
-  EnqueueTask task;
-  native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
-
+  final CompilerTask task;
+  final native.NativeEnqueuer nativeEnqueuer;
 
   WorldImpactVisitor impactVisitor;
 
-  CodegenEnqueuer(Compiler compiler, this.strategy)
+  CodegenEnqueuer(this.task, Compiler compiler, this.strategy)
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         newlySeenSelectors = compiler.cacheStrategy.newSet(),
+        nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(),
         this.name = 'codegen enqueuer',
         this._compiler = compiler {
     impactVisitor = new _EnqueuerImpactVisitor(this);
   }
 
   CodegenWorldBuilder get universe => _universe;
 
   Backend get backend => _compiler.backend;
 
   CompilerOptions get options => _compiler.options;
@@ skipping 29 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(_compiler, element));
-    if (options.dumpInfo) {
-      // TODO(sigmund): add other missing dependencies (internals, selectors
-      // enqueued after allocations), also enable only for the codegen enqueuer.
-      _compiler.dumpInfoTask
-          .registerDependency(_compiler.currentElement, element);
-    }
+    // TODO(sigmund): add other missing dependencies (internals, selectors
+    // enqueued after allocations).
+    _compiler.dumpInfoTask
+        .registerDependency(_compiler.currentElement, element);
   }
 
-  void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
-    _compiler.impactStrategy
-        .visitImpact(impactSource, worldImpact, impactVisitor, impactUse);
+  void applyImpact(ImpactStrategy impactStrategy, WorldImpact worldImpact,
+      {Element impactSource}) {
+    impactStrategy.visitImpact(
+        impactSource, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     _registerInstantiatedType(type);
   }
 
   void _registerInstantiatedType(InterfaceType type,
       {bool mirrorUsage: false, bool nativeUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
@@ skipping 269 matching lines @@
         if (options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
-    type = _universe.registerIsCheck(type, _compiler);
+    type = _universe.registerIsCheck(type, _compiler.resolution);
     // 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) {
     backend.registerCallMethodWithFreeTypeVariables(element, this);
   }
 
@@ skipping 62 matching lines @@
     if (!enabledNoSuchMethod && backend.enabledNoSuchMethod) {
       backend.enableNoSuchMethod(this);
       enabledNoSuchMethod = true;
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 
-  void forgetElement(Element element) {
+  void forgetElement(Element element, Compiler compiler) {
     _forgetElement(element);
     generatedCode.remove(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         generatedCode.remove(closure);
         removeFromSet(instanceMembersByName, closure);
         removeFromSet(instanceFunctionsByName, closure);
       }
     }
   }
@@ skipping 31 matching lines @@
   @override
   void visitStaticUse(StaticUse staticUse) {
     enqueuer.registerStaticUse(staticUse);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.registerTypeUse(typeUse);
   }
 }