Pass InterceptorData through ResolutionWorldBuilder and access it through ClosedWorld

pkg/compiler/lib/src/ssa/codegen.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.
 
 import 'dart:math' as math;
 import 'dart:collection' show Queue;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../constants/constant_system.dart';
@@ skipping 62 matching lines @@
     return measure(() {
       backend.tracer.traceGraph("codegen", graph);
       SourceInformation sourceInformation = sourceInformationFactory
           .createBuilderForContext(work.resolvedAst)
           .buildDeclaration(work.resolvedAst);
       SsaCodeGenerator codegen = new SsaCodeGenerator(
           backend.compiler.options,
           backend.emitter,
           backend.nativeCodegenEnqueuer,
           backend.checkedModeHelpers,
-          backend.interceptorData,
           backend.oneShotInterceptorData,
           backend.rtiSubstitutions,
           backend.rtiEncoder,
           backend.namer,
           backend.superMemberData,
           closedWorld,
           work);
       codegen.visitGraph(graph);
       return new js.Fun(codegen.parameters, codegen.body)
           .withSourceInformation(sourceInformation);
     });
   }
 
   js.Expression generateMethod(
       CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     return measure(() {
       MethodElement element = work.element;
       if (element.asyncMarker != AsyncMarker.SYNC) {
         work.registry.registerAsyncMarker(element.asyncMarker);
       }
       SsaCodeGenerator codegen = new SsaCodeGenerator(
           backend.compiler.options,
           backend.emitter,
           backend.nativeCodegenEnqueuer,
           backend.checkedModeHelpers,
-          backend.interceptorData,
           backend.oneShotInterceptorData,
           backend.rtiSubstitutions,
           backend.rtiEncoder,
           backend.namer,
           backend.superMemberData,
           closedWorld,
           work);
       codegen.visitGraph(graph);
       backend.tracer.traceGraph("codegen", graph);
       return buildJavaScriptFunction(
@@ skipping 24 matching lines @@
   /**
    * Whether we are currently generating expressions instead of statements.
    * This includes declarations, which are generated as expressions.
    */
   bool isGeneratingExpression = false;
 
   final CompilerOptions _options;
   final CodeEmitterTask _emitter;
   final native.NativeCodegenEnqueuer _nativeEnqueuer;
   final CheckedModeHelpers _checkedModeHelpers;
-  final InterceptorData _interceptorData;
   final OneShotInterceptorData _oneShotInterceptorData;
   final RuntimeTypesSubstitutions _rtiSubstitutions;
   final RuntimeTypesEncoder _rtiEncoder;
   final Namer _namer;
   final SuperMemberData _superMemberData;
   final ClosedWorld _closedWorld;
   final CodegenWorkItem _work;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
@@ skipping 36 matching lines @@
   SubGraph subGraph;
 
   // Pending blocks than need to be visited as part of current subgraph.
   Queue<HBasicBlock> blockQueue;
 
   SsaCodeGenerator(
       this._options,
       this._emitter,
       this._nativeEnqueuer,
       this._checkedModeHelpers,
-      this._interceptorData,
       this._oneShotInterceptorData,
       this._rtiSubstitutions,
       this._rtiEncoder,
       this._namer,
       this._superMemberData,
       this._closedWorld,
       this._work,
       {SourceInformation sourceInformation})
       : declaredLocals = new Set<String>(),
         collectedVariableDeclarations = new Set<String>(),
         currentContainer = new js.Block.empty(),
         parameters = <js.Parameter>[],
         expressionStack = <js.Expression>[],
         oldContainerStack = <js.Block>[],
         generateAtUseSite = new Set<HInstruction>(),
         controlFlowOperators = new Set<HInstruction>(),
         breakAction = new Map<Entity, EntityAction>(),
         continueAction = new Map<Entity, EntityAction>();
 
   CodegenRegistry get _registry => _work.registry;
 
   CommonElements get _commonElements => _closedWorld.commonElements;
 
   ConstantSystem get _constantSystem => _closedWorld.constantSystem;
 
   NativeData get _nativeData => _closedWorld.nativeData;
 
+  InterceptorData get _interceptorData => _closedWorld.interceptorData;
+
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi) {
         if (!phiSet.contains(user)) {
           phiSet.add(user);
           if (hasNonBitOpUser(user, phiSet)) return true;
@@ skipping 2789 matching lines @@
     return _closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
       return !_rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }