Create LookupMapAnalysis late.

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 379 matching lines @@
   CustomElementsResolutionAnalysis customElementsResolutionAnalysis;
 
   /// Codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsCodegenAnalysis customElementsCodegenAnalysis;
 
   /// Resolution support for tree-shaking entries of `LookupMap`.
   LookupMapLibraryAccess lookupMapLibraryAccess;
 
   /// Codegen support for tree-shaking entries of `LookupMap`.
-  LookupMapAnalysis lookupMapAnalysis;
+  LookupMapAnalysis _lookupMapAnalysis;
 
   /// Codegen support for typed JavaScript interop.
   JsInteropAnalysis jsInteropAnalysis;
 
   /// Support for classifying `noSuchMethod` implementations.
   NoSuchMethodRegistry noSuchMethodRegistry;
 
   /// Resolution and codegen support for computing reflectable elements.
   MirrorsAnalysis mirrorsAnalysis;
 
@@ skipping 119 matching lines @@
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
         helpers,
         nativeClassData);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
     lookupMapLibraryAccess =
         new LookupMapLibraryAccess(reporter, compiler.elementEnvironment);
-    lookupMapAnalysis = new LookupMapAnalysis(this, compiler.options, reporter,
-        compiler.elementEnvironment, commonElements, helpers, backendClasses);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(
         compiler.options,
         compiler.resolution,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         nativeClassData,
@@ skipping 16 matching lines @@
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
   Resolution get resolution => compiler.resolution;
 
   Target get target => _target;
 
+  /// Codegen support for tree-shaking entries of `LookupMap`.
+  LookupMapAnalysis get lookupMapAnalysis {
+    assert(invariant(NO_LOCATION_SPANNABLE, _lookupMapAnalysis != null,
+        message: "LookupMapAnalysis has not been created yet."));
+    return _lookupMapAnalysis;
+  }
+
   InterceptorData get interceptorData {
     assert(invariant(NO_LOCATION_SPANNABLE, _interceptorData != null,
         message: "InterceptorData has not been computed yet."));
     return _interceptorData;
   }
 
   InterceptorDataBuilder get interceptorDataBuilder {
     assert(invariant(NO_LOCATION_SPANNABLE, _interceptorData == null,
         message: "InterceptorData has already been computed."));
     return _interceptorDataBuilder;
@@ skipping 289 matching lines @@
             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) {
+    _lookupMapAnalysis = new LookupMapAnalysis(
+        reporter,
+        constantSystem,
+        constants,
+        compiler.elementEnvironment,
+        commonElements,
+        helpers,
+        backendClasses,
+        lookupMapLibraryAccess);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeClassData, closedWorld, constants, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.dumpInfoTask,
             compiler.elementEnvironment,
@@ skipping 237 matching lines @@
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
     MethodElement helper = helpers.isJsIndexable;
     jsAst.Expression helperExpression = emitter.staticFunctionAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
 
   /// Called after the queue is closed. [onQueueEmpty] may be called multiple
   /// times, but [onQueueClosed] is only called once.
   void onQueueClosed() {
-    lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
 
   // TODO(johnniwinther): Create a CodegenPhase object for the backend to hold
   // data only available during code generation.
   ClosedWorld _closedWorldCache;
   ClosedWorld get _closedWorld {
     assert(invariant(NO_LOCATION_SPANNABLE, _closedWorldCache != null,
         message: "ClosedWorld has not be set yet."));
     return _closedWorldCache;
@@ skipping 21 matching lines @@
         checkedModeHelpers,
         nativeData,
         rtiNeed,
         nativeCodegenEnqueuer,
         namer,
         mirrorsData,
         oneShotInterceptorData,
         lookupMapAnalysis,
         customElementsCodegenAnalysis,
         rtiChecksBuilder);
-    lookupMapAnalysis.onCodegenStart(lookupMapLibraryAccess);
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
   }
 
   // Does this element belong in the output
@@ skipping 376 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }