Extract CodegenImpactTransformer from ImpactTransformer

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;
 
 import '../common.dart';
 import '../common/backend_api.dart'
-    show BackendClasses, ForeignResolver, NativeRegistry;
+    show BackendClasses, ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
 import '../common/names.dart' show Uris;
 import '../common/resolution.dart'
     show Frontend, Resolution, ResolutionImpact, Target;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 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;
@@ skipping 370 matching lines @@
   MirrorsAnalysis mirrorsAnalysis;
 
   /// Builds kernel representation for the program.
   KernelTask kernelTask;
 
   /// The compiler task responsible for the compilation of constants for both
   /// the frontend and the backend.
   final JavaScriptConstantTask constantCompilerTask;
 
   /// Backend transformation methods for the world impacts.
-  JavaScriptImpactTransformer impactTransformer;
+  ImpactTransformer impactTransformer;
+
+  CodegenImpactTransformer _codegenImpactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   /// The strategy used for collecting and emitting source information.
   SourceInformationStrategy sourceInformationStrategy;
 
   /// Interface for serialization of backend specific data.
   JavaScriptBackendSerialization serialization;
 
   NativeDataImpl _nativeData;
@@ skipping 103 matching lines @@
         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, backendClasses);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
-    impactTransformer = new JavaScriptImpactTransformer(this);
+    impactTransformer = new JavaScriptImpactTransformer(
+        compiler.options,
+        compiler.resolution,
+        compiler.elementEnvironment,
+        commonElements,
+        impacts,
+        nativeClassData,
+        nativeResolutionEnqueuer,
+        backendUsageBuilder,
+        mirrorsData,
+        customElementsResolutionAnalysis,
+        rtiNeedBuilder);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization =
         new JavaScriptBackendSerialization(nativeClassData, nativeData);
     _interceptorDataBuilder = new InterceptorDataBuilderImpl(
         nativeClassData, helpers, commonElements, compiler.resolution);
   }
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
@@ skipping 448 matching lines @@
         ConstantValue initialValue = constants.getConstantValue(constant);
         if (initialValue != null) {
           computeImpactForCompileTimeConstant(
               initialValue, work.registry.worldImpact,
               forResolution: false);
           addCompileTimeConstantForEmission(initialValue);
           // We don't need to generate code for static or top-level
           // variables. For instance variables, we may need to generate
           // the checked setter.
           if (Elements.isStaticOrTopLevel(element)) {
-            return impactTransformer
+            return _codegenImpactTransformer
                 .transformCodegenImpact(work.registry.worldImpact);
           }
         } else {
           assert(invariant(
               variableElement,
               variableElement.isInstanceMember ||
                   constant.isImplicit ||
                   constant.isPotential,
               message: "Constant expression without value: "
                   "${constant.toStructuredText()}."));
         }
       } 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(
             helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
     jsAst.Fun function = functionCompiler.compile(work, _closedWorld);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
-    WorldImpact worldImpact =
-        impactTransformer.transformCodegenImpact(work.registry.worldImpact);
+    WorldImpact worldImpact = _codegenImpactTransformer
+        .transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   native.NativeEnqueuer get nativeResolutionEnqueuer =>
       _nativeResolutionEnqueuer;
 
   native.NativeEnqueuer get nativeCodegenEnqueuer => _nativeCodegenEnqueuer;
 
   ClassElement defaultSuperclass(ClassElement element) {
@@ skipping 171 matching lines @@
     _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;
     _namer = determineNamer(closedWorld, codegenWorldBuilder);
     tracer = new Tracer(closedWorld, namer, compiler);
-    emitter.createEmitter(_namer, closedWorld);
+    emitter.createEmitter(namer, closedWorld);
     _rtiEncoder =
-        _namer.rtiEncoder = new _RuntimeTypesEncoder(_namer, emitter, helpers);
-
+        _namer.rtiEncoder = new _RuntimeTypesEncoder(namer, emitter, helpers);
+    _codegenImpactTransformer = new CodegenImpactTransformer(
+        this,
+        compiler.options,
+        compiler.elementEnvironment,
+        helpers,
+        impacts,
+        checkedModeHelpers,
+        nativeData,
+        rtiNeed,
+        nativeCodegenEnqueuer,
+        namer,
+        mirrorsData,
+        oneShotInterceptorData,
+        lookupMapAnalysis,
+        customElementsCodegenAnalysis);
     lookupMapAnalysis.onCodegenStart(lookupMapLibraryAccess);
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
   }
 
@@ skipping 377 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }