Prepare for late creation of ResolutionEnqueuer

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 11 matching lines @@
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../enqueue.dart'
     show
+        DirectEnqueuerStrategy,
         Enqueuer,
         EnqueuerListener,
         EnqueueTask,
         ResolutionEnqueuer,
+        ResolutionWorkItemBuilder,
         TreeShakingEnqueuerStrategy;
 import '../io/multi_information.dart' show MultiSourceInformationStrategy;
 import '../io/position_information.dart' show PositionSourceInformationStrategy;
 import '../io/source_information.dart' show SourceInformationStrategy;
 import '../io/start_end_information.dart'
     show StartEndSourceInformationStrategy;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js/js_source_mapping.dart' show JavaScriptSourceInformationStrategy;
 import '../js/rewrite_async.dart';
@@ skipping 391 matching lines @@
   NativeDataBuilder get nativeDataBuilder => _nativeData;
   final NativeDataResolver _nativeDataResolver;
   InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
-  ResolutionEnqueuerListener _resolutionEnqueuerListener;
-
   native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
   native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
 
   BackendHelpers helpers;
   BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
 
   /// Backend access to the front-end.
@@ skipping 85 matching lines @@
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(nativeData);
     _interceptorDataBuilder = new InterceptorDataBuilderImpl(
         nativeClassData, helpers, commonElements, compiler.resolution);
-    _resolutionEnqueuerListener = new ResolutionEnqueuerListener(
-        kernelTask,
-        compiler.options,
-        compiler.elementEnvironment,
-        commonElements,
-        helpers,
-        impacts,
-        nativeClassData,
-        _interceptorDataBuilder,
-        _backendUsageBuilder,
-        _rtiNeedBuilder,
-        mirrorsData,
-        noSuchMethodRegistry,
-        customElementsResolutionAnalysis,
-        lookupMapLibraryAccess,
-        mirrorsAnalysis,
-        typeVariableAnalysis,
-        _nativeResolutionEnqueuer);
   }
 
   /// 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 58 matching lines @@
   RuntimeTypesSubstitutions get rtiSubstitutions => _rti;
 
   RuntimeTypesEncoder get rtiEncoder {
     assert(invariant(NO_LOCATION_SPANNABLE, _rtiEncoder != null,
         message: "RuntimeTypesEncoder has not been created."));
     return _rtiEncoder;
   }
 
   CheckedModeHelpers get checkedModeHelpers => _checkedModeHelpers;
 
-  EnqueuerListener get resolutionEnqueuerListener =>
-      _resolutionEnqueuerListener;
-
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   bool isDefaultNoSuchMethod(MethodElement element) {
     return noSuchMethodRegistry.isDefaultNoSuchMethodImplementation(element);
   }
 
@@ skipping 259 matching lines @@
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
+  ResolutionEnqueuer createResolutionEnqueuer(
+      CompilerTask task, Compiler compiler) {
+    return new ResolutionEnqueuer(
+        task,
+        compiler.options,
+        compiler.reporter,
+        compiler.options.analyzeOnly && compiler.options.analyzeMain
+            ? const DirectEnqueuerStrategy()
+            : const TreeShakingEnqueuerStrategy(),
+        new ResolutionEnqueuerListener(
+            kernelTask,
+            compiler.options,
+            compiler.elementEnvironment,
+            commonElements,
+            helpers,
+            impacts,
+            nativeClassData,
+            _interceptorDataBuilder,
+            _backendUsageBuilder,
+            _rtiNeedBuilder,
+            mirrorsData,
+            noSuchMethodRegistry,
+            customElementsResolutionAnalysis,
+            lookupMapLibraryAccess,
+            mirrorsAnalysis,
+            typeVariableAnalysis,
+            _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) {
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeClassData, closedWorld, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
@@ skipping 670 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }