Pass InterceptorData through ResolutionWorldBuilder and access it through ClosedWorld

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 '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
@@ skipping 423 matching lines @@
 
   /// Interface for serialization of backend specific data.
   JavaScriptBackendSerialization serialization;
 
   NativeDataBuilderImpl _nativeDataBuilder;
   final NativeBasicDataBuilderImpl _nativeBasicDataBuilder =
       new NativeBasicDataBuilderImpl();
   NativeBasicDataImpl _nativeBasicData;
   NativeDataBuilder get nativeDataBuilder => _nativeDataBuilder;
   final NativeDataResolver _nativeDataResolver;
-  InterceptorDataBuilder _interceptorDataBuilder;
-  InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsDataImpl _mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   final SuperMemberData superMemberData = new SuperMemberData();
 
   native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
   native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
@@ skipping 139 matching lines @@
     return _mirrorsCodegenAnalysis;
   }
 
   /// 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;
-  }
-
   OneShotInterceptorData get oneShotInterceptorData {
     assert(invariant(NO_LOCATION_SPANNABLE, _oneShotInterceptorData != null,
         message: "OneShotInterceptorData has not been prepared yet."));
     return _oneShotInterceptorData;
   }
 
   BackendUsage get backendUsage {
     assert(invariant(NO_LOCATION_SPANNABLE, _backendUsage != null,
         message: "BackendUsage has not been computed yet."));
     return _backendUsage;
@@ skipping 143 matching lines @@
         commonElements.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(commonElements.jsNullClass);
   }
 
   /// Called when the resolution queue has been closed.
   void onResolutionEnd() {
     compiler.frontEndStrategy.annotationProcesser
         .processJsInteropAnnotations(nativeBasicData, nativeDataBuilder);
     _backendUsage = backendUsageBuilder.close();
-    _interceptorData = interceptorDataBuilder.onResolutionComplete();
   }
 
   /// Called when the closed world from resolution has been computed.
   void onResolutionClosedWorld(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (MemberEntity entity
         in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
         compiler.types,
         commonElements,
         _backendUsage,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
-    _oneShotInterceptorData =
-        new OneShotInterceptorData(interceptorData, commonElements);
     mirrorsResolutionAnalysis.onResolutionComplete();
   }
 
   void onTypeInferenceComplete(GlobalTypeInferenceResults results) {
     noSuchMethodRegistry.onTypeInferenceComplete(results);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
@@ skipping 44 matching lines @@
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         nativeBasicData,
         _nativeResolutionEnqueuer,
         backendUsageBuilder,
         mirrorsDataBuilder,
         customElementsResolutionAnalysis,
         rtiNeedBuilder);
-    _interceptorDataBuilder = new InterceptorDataBuilderImpl(
-        nativeBasicData, compiler.elementEnvironment, commonElements);
+    InterceptorDataBuilder interceptorDataBuilder =
+        new InterceptorDataBuilderImpl(
+            nativeBasicData, compiler.elementEnvironment, commonElements);
     return new ResolutionEnqueuer(
         task,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
         new ResolutionEnqueuerListener(
             compiler.options,
             compiler.elementEnvironment,
             commonElements,
             impacts,
             nativeBasicData,
             interceptorDataBuilder,
             backendUsageBuilder,
             rtiNeedBuilder,
             mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapResolutionAnalysis,
             mirrorsResolutionAnalysis,
             typeVariableResolutionAnalysis,
             _nativeResolutionEnqueuer,
             compiler.deferredLoadTask,
             kernelTask),
         compiler.frontEndStrategy.createResolutionWorldBuilder(
-            nativeBasicData, _nativeDataBuilder, const OpenWorldStrategy()),
+            nativeBasicData,
+            _nativeDataBuilder,
+            interceptorDataBuilder,
+            const OpenWorldStrategy()),
         compiler.frontEndStrategy
             .createResolutionWorkItemBuilder(impactTransformer));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
     _typeVariableCodegenAnalysis = new TypeVariableCodegenAnalysis(
         compiler.elementEnvironment, this, commonElements, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
@@ skipping 12 matching lines @@
         commonElements,
         emitter,
         _nativeResolutionEnqueuer,
         closedWorld.nativeData);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeBasicData, closedWorld, constants, const TypeMaskStrategy()),
-        new CodegenWorkItemBuilder(this, compiler.options),
+        new CodegenWorkItemBuilder(this, closedWorld, compiler.options),
         new CodegenEnqueuerListener(
             compiler.elementEnvironment,
             commonElements,
             impacts,
             backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
             nativeCodegenEnqueuer));
   }
 
-  WorldImpact codegen(CodegenWorkItem work) {
+  WorldImpact codegen(CodegenWorkItem work, ClosedWorld closedWorld) {
     MemberElement 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;
       String messageText = message.message.computeMessage();
       jsAst.LiteralString messageLiteral =
           js.escapedString("Compile time error in $element: $messageText");
@@ skipping 37 matching lines @@
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
             commonElements.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
-    jsAst.Fun function = functionCompiler.compile(work, _closedWorld);
+    jsAst.Fun function = functionCompiler.compile(work, closedWorld);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact = _codegenImpactTransformer
         .transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
@@ skipping 110 matching lines @@
       inlineCache.markAsNonInlinable(commonElements.getInterceptorMethod,
           insideLoop: true);
 
       specialOperatorEqClasses
         ..add(commonElements.objectClass)
         ..add(commonElements.jsInterceptorClass)
         ..add(commonElements.jsNullClass);
     }
   }
 
-  // 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;
-  }
-
-  void set _closedWorld(ClosedWorld value) {
-    _closedWorldCache = value;
-  }
-
   /// Called when the compiler starts running the codegen enqueuer. The
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
-    _closedWorld = closedWorld;
+    _oneShotInterceptorData =
+        new OneShotInterceptorData(closedWorld.interceptorData, commonElements);
     _namer = determineNamer(closedWorld, codegenWorldBuilder);
     tracer = new Tracer(closedWorld, namer, compiler);
     _rtiEncoder =
         _namer.rtiEncoder = new _RuntimeTypesEncoder(namer, commonElements);
     emitter.createEmitter(namer, closedWorld, codegenWorldBuilder);
     _codegenImpactTransformer = new CodegenImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         impacts,
@@ skipping 315 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }