Split InterceptorData

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 61 matching lines @@
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_serialization.dart' show JavaScriptBackendSerialization;
 import 'backend_usage.dart';
 import 'checked_mode_helpers.dart';
 import 'constant_handler_javascript.dart';
 import 'custom_elements_analysis.dart';
 import 'enqueuer.dart';
-import 'interceptor_data.dart' show InterceptorData;
+import 'interceptor_data.dart';
 import 'js_interop_analysis.dart' show JsInteropAnalysis;
 import 'lookup_map_analysis.dart' show LookupMapAnalysis;
 import 'mirrors_analysis.dart';
 import 'mirrors_data.dart';
 import 'namer.dart';
 import 'native_data.dart' show NativeData;
 import 'no_such_method_registry.dart';
 import 'patch_resolver.dart';
 import 'type_variable_handler.dart';
 
@@ skipping 339 matching lines @@
   /// Interface for serialization of backend specific data.
   JavaScriptBackendSerialization serialization;
 
   StagedWorldImpactBuilder constantImpactsForResolution =
       new StagedWorldImpactBuilder();
 
   StagedWorldImpactBuilder constantImpactsForCodegen =
       new StagedWorldImpactBuilder();
 
   final NativeData nativeData = new NativeData();
+  InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
+  OneShotInterceptorData _oneShotInterceptorData;
   BackendUsageImpl _backendUsage;
   final MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   ResolutionEnqueuerListener _resolutionEnqueuerListener;
   CodegenEnqueuerListener _codegenEnqueuerListener;
 
   BackendHelpers helpers;
   final BackendImpacts impacts;
 
@@ skipping 34 matching lines @@
     mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(this);
-    _interceptorData = new InterceptorData(nativeData, helpers, commonElements);
+    _interceptorDataBuilder =
+        new InterceptorDataBuilderImpl(nativeData, helpers, commonElements);
     backendClasses = new JavaScriptBackendClasses(
-        compiler.elementEnvironment, helpers, nativeData, _interceptorData);
+        compiler.elementEnvironment, helpers, nativeData);
     _resolutionEnqueuerListener = new ResolutionEnqueuerListener(this);
     _codegenEnqueuerListener = new CodegenEnqueuerListener(this);
   }
 
   /// 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;
 
   Resolution get resolution => compiler.resolution;
 
-  InterceptorData get interceptorData => _interceptorData;
+  InterceptorData get interceptorData {
+    assert(invariant(NO_LOCATION_SPANNABLE, _interceptorData != null,
+        message: "InterceptorData has not been computed yet."));
+    return _interceptorData;
+  }
+
+  OneShotInterceptorData get oneShotInterceptorData {
+    assert(invariant(NO_LOCATION_SPANNABLE, _oneShotInterceptorData != null,
+        message: "OneShotInterceptorData has not been prepared yet."));
+    return _oneShotInterceptorData;
+  }
 
   BackendUsage get backendUsage => _backendUsage;
 
   BackendUsageBuilder get backendUsageBuilder => _backendUsage;
 
   CheckedModeHelpers get checkedModeHelpers => _checkedModeHelpers;
 
   EnqueuerListener get resolutionEnqueuerListener =>
       _resolutionEnqueuerListener;
 
@@ skipping 254 matching lines @@
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsData.computeMembersNeededForReflection(closedWorld);
     rti.computeClassesNeedingRti(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _registeredMetadata.clear();
-    interceptorData.onResolutionComplete(closedWorld);
+    _interceptorData =
+        _interceptorDataBuilder.onResolutionComplete(closedWorld);
+    _oneShotInterceptorData =
+        new OneShotInterceptorData(interceptorData, helpers);
   }
 
   void onTypeInferenceComplete() {
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   /// Called to register that an instantiated generic class has a call method.
   /// Any backend specific [WorldImpact] of this is returned.
   ///
   /// Note: The [callMethod] is registered even thought it doesn't reference
@@ skipping 1317 matching lines @@
           break;
         default:
       }
     }
 
     for (String name in impact.constSymbols) {
       backend.mirrorsData.registerConstSymbol(name);
     }
 
     for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
-      backend.interceptorData
+      backend.oneShotInterceptorData
           .registerSpecializedGetInterceptor(classes, backend.namer);
     }
 
     if (impact.usesInterceptor) {
       if (backend.codegenEnqueuer.nativeEnqueuer.hasInstantiatedNativeClasses) {
         backendUsage.registerBackendImpact(transformed, impacts.interceptorUse);
       }
     }
 
     for (ClassElement element in impact.typeConstants) {
@@ skipping 74 matching lines @@
       // performed.
       resolution.emptyCache();
     }
   }
 }
 
 class JavaScriptBackendClasses implements BackendClasses {
   final ElementEnvironment _env;
   final BackendHelpers helpers;
   final NativeData _nativeData;
-  final InterceptorData _interceptorData;
 
-  JavaScriptBackendClasses(
-      this._env, this.helpers, this._nativeData, this._interceptorData);
+  JavaScriptBackendClasses(this._env, this.helpers, this._nativeData);
 
   ClassElement get intClass => helpers.jsIntClass;
   ClassElement get uint32Class => helpers.jsUInt32Class;
   ClassElement get uint31Class => helpers.jsUInt31Class;
   ClassElement get positiveIntClass => helpers.jsPositiveIntClass;
   ClassElement get doubleClass => helpers.jsDoubleClass;
   ClassElement get numClass => helpers.jsNumberClass;
   ClassElement get stringClass => helpers.jsStringClass;
   ClassElement get listClass => helpers.jsArrayClass;
   ClassElement get mutableListClass => helpers.jsMutableArrayClass;
@@ skipping 18 matching lines @@
 
   bool isDefaultEqualityImplementation(MemberElement element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == helpers.commonElements.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   @override
-  bool isInterceptorClass(ClassElement cls) {
-    return _interceptorData.isInterceptorClass(cls);
-  }
-
-  @override
   bool isNativeClass(ClassElement element) {
     return _nativeData.isNative(element);
   }
 
   @override
   bool isNativeMember(MemberElement element) {
     return _nativeData.isNative(element);
   }
 
   InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
@@ skipping 27 matching lines @@
   EnqueuerListenerBase(this._backend);
 
   // TODO(johnniwinther): Change these to final fields.
   CommonElements get commonElements => _backend.commonElements;
   BackendHelpers get helpers => _backend.helpers;
   BackendImpacts get impacts => _backend.impacts;
   BackendUsageBuilder get backendUsage => _backend.backendUsageBuilder;
   CustomElementsAnalysis get customElementsAnalysis =>
       _backend.customElementsAnalysis;
   NativeData get nativeData => _backend.nativeData;
-  InterceptorData get interceptorData => _backend.interceptorData;
+  InterceptorDataBuilder get interceptorData =>
+      _backend._interceptorDataBuilder;
   RuntimeTypes get rti => _backend.rti;
   TypeVariableHandler get typeVariableHandler => _backend.typeVariableHandler;
   Resolution get resolution => _backend.resolution;
   MirrorsData get mirrorsData => _backend.mirrorsData;
   CompilerOptions get options => _backend.compiler.options;
 
   WorldImpact registerBoundClosure() {
     return backendUsage.createImpactFor(impacts.memberClosure);
   }
 
@@ skipping 364 matching lines @@
   WorldImpact registerInstantiatedClass(ClassEntity cls) {
     WorldImpact worldImpact = _processClass(cls, forResolution: false);
     lookupMapAnalysis.registerInstantiatedClass(cls);
     return worldImpact;
   }
 
   // TODO(johnniwinther): Avoid the need for accessing [_backend].
   bool methodNeedsRti(FunctionElement function) =>
       _backend.methodNeedsRti(function);
 }