Remove backend reference from ResolutionEnqueuerListener.

pkg/compiler/lib/src/js_backend/resolution_listener.dart

 // Copyright (c) 2017, 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 js_backend.backend.resolution_listener;
 
 import '../common/names.dart' show Identifiers, Uris;
-import '../common/resolution.dart' show Resolution;
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../enqueue.dart' show Enqueuer, EnqueuerListener;
 import '../kernel/task.dart';
 import '../native/enqueue.dart';
 import '../options.dart' show CompilerOptions;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/world_impact.dart'
     show WorldImpact, WorldImpactBuilder, WorldImpactBuilderImpl;
 import 'backend.dart';
 import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_usage.dart';
 import 'checked_mode_helpers.dart';
 import 'custom_elements_analysis.dart';
 import 'interceptor_data.dart';
 import 'lookup_map_analysis.dart' show LookupMapLibraryAccess;
 import 'mirrors_analysis.dart';
 import 'mirrors_data.dart';
 import 'native_data.dart' show NativeData;
 import 'no_such_method_registry.dart';
 import 'type_variable_handler.dart';
 
 class ResolutionEnqueuerListener extends EnqueuerListener {
-  // TODO(johnniwinther): Avoid the need for accessing through [_backend].
-  final JavaScriptBackend _backend;
+  // TODO(johnniwinther): Avoid the need for this.
+  final KernelTask _kernelTask;
 
   final CompilerOptions _options;
   final CommonElements _commonElements;
   final BackendHelpers _helpers;
   final BackendImpacts _impacts;
   final ElementEnvironment _elementEnvironment;
 
   final NativeData _nativeData;
   final InterceptorDataBuilder _interceptorData;
   final BackendUsageBuilder _backendUsage;
   final RuntimeTypesNeedBuilder _rtiNeedBuilder;
   final MirrorsData _mirrorsData;
 
   final NoSuchMethodRegistry _noSuchMethodRegistry;
   final CustomElementsResolutionAnalysis _customElementsAnalysis;
   final LookupMapLibraryAccess _lookupMapLibraryAccess;
   final MirrorsAnalysis _mirrorsAnalysis;
+  final TypeVariableAnalysis _typeVariableAnalysis;
 
   final NativeResolutionEnqueuer _nativeEnqueuer;
 
   /// True when we enqueue the loadLibrary code.
   bool _isLoadLibraryFunctionResolved = false;
+
   ResolutionEnqueuerListener(
-      this._backend,
+      this._kernelTask,
       this._options,
       this._elementEnvironment,
       this._commonElements,
       this._helpers,
       this._impacts,
       this._nativeData,
       this._interceptorData,
       this._backendUsage,
       this._rtiNeedBuilder,
       this._mirrorsData,
       this._noSuchMethodRegistry,
       this._customElementsAnalysis,
       this._lookupMapLibraryAccess,
       this._mirrorsAnalysis,
+      this._typeVariableAnalysis,
       this._nativeEnqueuer);
 
-  // TODO(johnniwinther): Avoid the need for these.
-  Resolution get _resolution => _backend.resolution;
-  KernelTask get _kernelTask => _backend.kernelTask;
-
-  // TODO(johnniwinther): Change this to a final field. Currently breaks
-  // `kernel/closed_world_test`.
-  TypeVariableAnalysis get _typeVariableAnalysis =>
-      _backend.typeVariableAnalysis;
-
   void _registerBackendImpact(
       WorldImpactBuilder builder, BackendImpact impact) {
     impact.registerImpact(builder, _elementEnvironment);
     _backendUsage.processBackendImpact(impact);
   }
 
   void _addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder) {
-    cls.ensureResolved(_resolution);
     _interceptorData.addInterceptors(cls);
     impactBuilder.registerTypeUse(new TypeUse.instantiation(cls.rawType));
     _backendUsage.registerBackendClassUse(cls);
   }
 
   @override
   WorldImpact registerClosurizedMember(MemberElement element) {
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     _backendUsage.processBackendImpact(_impacts.memberClosure);
     impactBuilder
@@ skipping 255 matching lines @@
       _addInterceptors(_helpers.jsNumberClass, impactBuilder);
     } else if (cls == _helpers.jsJavaScriptObjectClass) {
       _addInterceptors(_helpers.jsJavaScriptObjectClass, impactBuilder);
     } else if (cls == _helpers.jsPlainJavaScriptObjectClass) {
       _addInterceptors(_helpers.jsPlainJavaScriptObjectClass, impactBuilder);
     } else if (cls == _helpers.jsUnknownJavaScriptObjectClass) {
       _addInterceptors(_helpers.jsUnknownJavaScriptObjectClass, impactBuilder);
     } else if (cls == _helpers.jsJavaScriptFunctionClass) {
       _addInterceptors(_helpers.jsJavaScriptFunctionClass, impactBuilder);
     } else if (_nativeData.isNativeOrExtendsNative(cls)) {
-      _addInterceptorsForNativeClassMembers(cls);
+      _interceptorData.addInterceptorsForNativeClassMembers(cls);
     } else if (cls == _helpers.jsIndexingBehaviorInterface) {
       _registerBackendImpact(impactBuilder, _impacts.jsIndexingBehavior);
     }
 
     _customElementsAnalysis.registerInstantiatedClass(cls);
     return impactBuilder;
   }
 
-  void _addInterceptorsForNativeClassMembers(ClassElement cls) {
-    cls.ensureResolved(_resolution);
-    _interceptorData.addInterceptorsForNativeClassMembers(cls);
-  }
-
   @override
   WorldImpact registerImplementedClass(ClassEntity cls) {
     return _processClass(cls);
   }
 
   @override
   WorldImpact registerInstantiatedClass(ClassEntity cls) {
     return _processClass(cls);
   }
 
@@ skipping 12 matching lines @@
 
     if (JavaScriptBackend.TRACE_CALLS) {
       _registerBackendImpact(impactBuilder, _impacts.traceHelper);
     }
     _registerBackendImpact(impactBuilder, _impacts.assertUnreachable);
     _registerCheckedModeHelpers(impactBuilder);
     return impactBuilder;
   }
 
   void _registerCheckedModeHelpers(WorldImpactBuilder impactBuilder) {
-    // We register all the _helpers in the _resolution queue.
+    // We register all the _helpers in the resolution queue.
     // TODO(13155): Find a way to register fewer _helpers.
     List<FunctionEntity> staticUses = <FunctionEntity>[];
     for (CheckedModeHelper helper in CheckedModeHelpers.helpers) {
       staticUses.add(helper.getStaticUse(_helpers).element);
     }
     _registerBackendImpact(
         impactBuilder, new BackendImpact(globalUses: staticUses));
   }
 
   void logSummary(void log(String message)) {
     _nativeEnqueuer.logSummary(log);
   }
 }