Remove Enqueuer.nativeEnqueuer

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 426 matching lines @@
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   ResolutionEnqueuerListener _resolutionEnqueuerListener;
   CodegenEnqueuerListener _codegenEnqueuerListener;
 
+  native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
+  native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
+
   BackendHelpers helpers;
   BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
 
   /// Backend access to the front-end.
   final JSFrontendAccess frontend;
 
   Target _target;
@@ skipping 44 matching lines @@
     impacts = new BackendImpacts(compiler.options, commonElements, helpers);
     backendClasses = new JavaScriptBackendClasses(
         compiler.elementEnvironment, helpers, nativeData);
     mirrorsData = new MirrorsData(
         compiler, compiler.options, commonElements, helpers, constants);
     _backendUsageBuilder = new BackendUsageBuilderImpl(
         compiler.elementEnvironment, commonElements, helpers);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
+    _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(compiler);
+    _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
+        compiler, emitter, _nativeResolutionEnqueuer);
+
     typeVariableAnalysis = new TypeVariableAnalysis(
         compiler.elementEnvironment, impacts, backendUsageBuilder);
     typeVariableHandler = new TypeVariableHandler(this, helpers, mirrorsData);
     customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         this,
         compiler.resolution,
         commonElements,
         backendClasses,
         helpers,
         nativeData,
@@ skipping 29 matching lines @@
         helpers,
         impacts,
         nativeData,
         _interceptorDataBuilder,
         _backendUsageBuilder,
         _rtiNeedBuilder,
         mirrorsData,
         noSuchMethodRegistry,
         customElementsResolutionAnalysis,
         lookupMapLibraryAccess,
-        mirrorsAnalysis);
+        mirrorsAnalysis,
+        _nativeResolutionEnqueuer);
     _codegenEnqueuerListener = new CodegenEnqueuerListener(
         this,
         compiler.elementEnvironment,
         commonElements,
         helpers,
         impacts,
         mirrorsData,
         customElementsCodegenAnalysis,
         typeVariableHandler,
         lookupMapAnalysis,
-        mirrorsAnalysis);
+        mirrorsAnalysis,
+        _nativeCodegenEnqueuer);
   }
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
@@ skipping 153 matching lines @@
    */
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
   void resolveNativeElement(MemberElement element, NativeRegistry registry) {
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
-      compiler.enqueuer.resolution.nativeEnqueuer
-          .handleMethodAnnotations(element);
+      _nativeResolutionEnqueuer.handleMethodAnnotations(element);
       if (nativeData.isNativeMember(element)) {
         native.NativeBehavior behavior =
             native.NativeBehavior.ofMethodElement(element, compiler);
         nativeDataBuilder.setNativeMethodBehavior(element, behavior);
         registry.registerNativeData(behavior);
       }
     } else if (element.isField) {
-      compiler.enqueuer.resolution.nativeEnqueuer
-          .handleFieldAnnotations(element);
+      _nativeResolutionEnqueuer.handleFieldAnnotations(element);
       if (nativeData.isNativeMember(element)) {
         native.NativeBehavior fieldLoadBehavior =
             native.NativeBehavior.ofFieldElementLoad(element, compiler);
         native.NativeBehavior fieldStoreBehavior =
             native.NativeBehavior.ofFieldElementStore(element, compiler);
         nativeDataBuilder.setNativeFieldLoadBehavior(
             element, fieldLoadBehavior);
         nativeDataBuilder.setNativeFieldStoreBehavior(
             element, fieldStoreBehavior);
 
@@ skipping 153 matching lines @@
 
   /// Returns the [WorldImpact] of enabling deferred loading.
   WorldImpact computeDeferredLoadingImpact() {
     backendUsageBuilder.processBackendImpact(impacts.deferredLoading);
     return impacts.deferredLoading.createImpact(compiler.elementEnvironment);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
-    native.NativeResolutionEnqueuer nativeEnqueuer =
-        compiler.enqueuer.resolution.nativeEnqueuer;
     if (element.name == BackendHelpers.JS) {
-      return nativeEnqueuer.resolveJsCall(node, resolver);
+      return _nativeResolutionEnqueuer.resolveJsCall(node, resolver);
     } else if (element.name == BackendHelpers.JS_EMBEDDED_GLOBAL) {
-      return nativeEnqueuer.resolveJsEmbeddedGlobalCall(node, resolver);
+      return _nativeResolutionEnqueuer.resolveJsEmbeddedGlobalCall(
+          node, resolver);
     } else if (element.name == BackendHelpers.JS_BUILTIN) {
-      return nativeEnqueuer.resolveJsBuiltinCall(node, resolver);
+      return _nativeResolutionEnqueuer.resolveJsBuiltinCall(node, resolver);
     } else if (element.name == BackendHelpers.JS_INTERCEPTOR_CONSTANT) {
       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
       // a class that will be instantiated outside the program by attaching a
       // native class dispatch record referencing the interceptor.
       if (!node.argumentsNode.isEmpty) {
         Node argument = node.argumentsNode.nodes.head;
         ConstantExpression constant = resolver.getConstant(argument);
         if (constant != null && constant.kind == ConstantExpressionKind.TYPE) {
           TypeConstantExpression typeConstant = constant;
           if (typeConstant.type is ResolutionInterfaceType) {
@@ skipping 86 matching lines @@
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact =
         impactTransformer.transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
-  native.NativeEnqueuer nativeResolutionEnqueuer() {
-    return new native.NativeResolutionEnqueuer(compiler);
-  }
+  native.NativeEnqueuer get nativeResolutionEnqueuer =>
+      _nativeResolutionEnqueuer;
 
-  native.NativeEnqueuer nativeCodegenEnqueuer() {
-    return new native.NativeCodegenEnqueuer(compiler, emitter);
-  }
+  native.NativeEnqueuer get nativeCodegenEnqueuer => _nativeCodegenEnqueuer;
 
   ClassElement defaultSuperclass(ClassElement element) {
     if (nativeData.isJsInterop(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
     return nativeData.isNativeClass(element)
         ? helpers.jsInterceptorClass
         : commonElements.objectClass;
   }
@@ skipping 591 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }