Extract NativeClassResolver from NativeResolutionEnqueuer

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 493 matching lines @@
     _target = new JavaScriptBackendTarget(this);
     helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
     impacts = new BackendImpacts(compiler.options, commonElements, helpers);
     _mirrorsData = new MirrorsDataImpl(
         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);
 
     _typeVariableResolutionAnalysis = new TypeVariableResolutionAnalysis(
         compiler.elementEnvironment, impacts, backendUsageBuilder);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     _mirrorsResolutionAnalysis =
         new MirrorsResolutionAnalysisImpl(this, compiler.resolution);
     lookupMapResolutionAnalysis =
         new LookupMapResolutionAnalysis(reporter, compiler.elementEnvironment);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
@@ skipping 283 matching lines @@
     validateInterceptorImplementsAllObjectMethods(helpers.jsNullClass);
   }
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
-    _backendUsage = _backendUsageBuilder.close();
+    _backendUsage = backendUsageBuilder.close();
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
         compiler.types,
         commonElements,
         helpers,
         _backendUsage,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
-    _interceptorData =
-        _interceptorDataBuilder.onResolutionComplete(closedWorld);
+    _interceptorData = interceptorDataBuilder.onResolutionComplete(closedWorld);
     _oneShotInterceptorData =
         new OneShotInterceptorData(interceptorData, helpers);
     mirrorsResolutionAnalysis.onResolutionComplete();
   }
 
   void onTypeInferenceComplete() {
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   /// Register a runtime type variable bound tests between [typeArgument] and
@@ skipping 42 matching lines @@
     return null;
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   ResolutionEnqueuer createResolutionEnqueuer(
       CompilerTask task, Compiler compiler) {
     _nativeBasicData =
         nativeBasicDataBuilder.close(compiler.elementEnvironment);
+    _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(
+        compiler,
+        new NativeClassResolverImpl(
+            compiler.resolution, reporter, helpers, nativeBasicData));
     _nativeData = new NativeDataImpl(nativeBasicData);
     _backendClasses = new JavaScriptBackendClasses(
         compiler.elementEnvironment, helpers, nativeBasicData);
     _customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
         helpers,
         nativeBasicData,
@@ skipping 25 matching lines @@
             : const TreeShakingEnqueuerStrategy(),
         new ResolutionEnqueuerListener(
             kernelTask,
             compiler.options,
             compiler.elementEnvironment,
             commonElements,
             helpers,
             impacts,
             backendClasses,
             nativeBasicData,
-            _interceptorDataBuilder,
-            _backendUsageBuilder,
-            _rtiNeedBuilder,
+            interceptorDataBuilder,
+            backendUsageBuilder,
+            rtiNeedBuilder,
             mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapResolutionAnalysis,
             mirrorsResolutionAnalysis,
             typeVariableResolutionAnalysis,
-            _nativeResolutionEnqueuer),
+            nativeResolutionEnqueuer),
         new ElementResolutionWorldBuilder(
             this, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
     _typeVariableCodegenAnalysis =
         new TypeVariableCodegenAnalysis(this, helpers, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
         reporter,
         constantSystem,
         constants,
         compiler.elementEnvironment,
         commonElements,
         helpers,
         backendClasses,
         lookupMapResolutionAnalysis);
     _mirrorsCodegenAnalysis = mirrorsResolutionAnalysis.close();
     _customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
         helpers,
         nativeBasicData);
+    _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
+        compiler, emitter, _nativeResolutionEnqueuer);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeBasicData, closedWorld, constants, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.elementEnvironment,
             commonElements,
             helpers,
             impacts,
             backendClasses,
             backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
-            _nativeCodegenEnqueuer));
+            nativeCodegenEnqueuer));
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
       DiagnosticMessage message =
           // If there's more than one error, the first is probably most
           // informative, as the following errors may be side-effects of the
           // first error.
           compiler.elementsWithCompileTimeErrors[element].first;
@@ skipping 609 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeBasicData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }