Extract CodegenImpactTransformer from ImpactTransformer

pkg/compiler/lib/src/js_backend/impact_transformer.dart

 // Copyright (c) 2017, 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.impact_transformer;
 
 import '../common.dart';
+import '../common_elements.dart';
 import '../common/backend_api.dart' show ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact;
-import '../common/resolution.dart' show ResolutionImpact;
+import '../common/resolution.dart' show Resolution, ResolutionImpact;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show ElementEnvironment;
 import '../elements/elements.dart';
 import '../elements/resolution_types.dart';
 import '../enqueue.dart' show ResolutionEnqueuer;
+import '../native/enqueue.dart';
 import '../native/native.dart' as native;
+import '../options.dart';
 import '../universe/feature.dart';
 import '../universe/use.dart'
     show StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import '../universe/world_impact.dart' show TransformedWorldImpact, WorldImpact;
 import '../util/util.dart';
 import 'backend.dart';
+import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_usage.dart';
 import 'checked_mode_helpers.dart';
+import 'custom_elements_analysis.dart';
+import 'interceptor_data.dart';
+import 'lookup_map_analysis.dart';
+import 'mirrors_data.dart';
+import 'namer.dart';
+import 'native_data.dart';
 
 class JavaScriptImpactTransformer extends ImpactTransformer {
-  final JavaScriptBackend backend;
+  final CompilerOptions _options;
+  final Resolution _resolution;
+  final ElementEnvironment _elementEnvironment;
+  final CommonElements _commonElements;
+  final BackendImpacts _impacts;
+  final NativeClassData _nativeClassData;
+  final NativeResolutionEnqueuer _nativeResolutionEnqueuer;
+  final BackendUsageBuilder _backendUsageBuider;
+  final MirrorsData _mirrorsData;
+  final CustomElementsResolutionAnalysis _customElementsResolutionAnalysis;
+  final RuntimeTypesNeedBuilder _rtiNeedBuilder;
 
-  JavaScriptImpactTransformer(this.backend);
-
-  BackendImpacts get impacts => backend.impacts;
-
-  ElementEnvironment get elementEnvironment =>
-      backend.compiler.elementEnvironment;
+  JavaScriptImpactTransformer(
+      this._options,
+      this._resolution,
+      this._elementEnvironment,
+      this._commonElements,
+      this._impacts,
+      this._nativeClassData,
+      this._nativeResolutionEnqueuer,
+      this._backendUsageBuider,
+      this._mirrorsData,
+      this._customElementsResolutionAnalysis,
+      this._rtiNeedBuilder);
 
   @override
   WorldImpact transformResolutionImpact(
       ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
-    BackendUsageBuilder backendUsage = backend.backendUsageBuilder;
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
 
     void registerImpact(BackendImpact impact) {
-      impact.registerImpact(transformed, elementEnvironment);
-      backendUsage.processBackendImpact(impact);
+      impact.registerImpact(transformed, _elementEnvironment);
+      _backendUsageBuider.processBackendImpact(impact);
     }
 
     for (Feature feature in worldImpact.features) {
       switch (feature) {
         case Feature.ABSTRACT_CLASS_INSTANTIATION:
-          registerImpact(impacts.abstractClassInstantiation);
+          registerImpact(_impacts.abstractClassInstantiation);
           break;
         case Feature.ASSERT:
-          registerImpact(impacts.assertWithoutMessage);
+          registerImpact(_impacts.assertWithoutMessage);
           break;
         case Feature.ASSERT_WITH_MESSAGE:
-          registerImpact(impacts.assertWithMessage);
+          registerImpact(_impacts.assertWithMessage);
           break;
         case Feature.ASYNC:
-          registerImpact(impacts.asyncBody);
+          registerImpact(_impacts.asyncBody);
           break;
         case Feature.ASYNC_FOR_IN:
-          registerImpact(impacts.asyncForIn);
+          registerImpact(_impacts.asyncForIn);
           break;
         case Feature.ASYNC_STAR:
-          registerImpact(impacts.asyncStarBody);
+          registerImpact(_impacts.asyncStarBody);
           break;
         case Feature.CATCH_STATEMENT:
-          registerImpact(impacts.catchStatement);
+          registerImpact(_impacts.catchStatement);
           break;
         case Feature.COMPILE_TIME_ERROR:
-          if (backend.compiler.options.generateCodeWithCompileTimeErrors) {
+          if (_options.generateCodeWithCompileTimeErrors) {
             // TODO(johnniwinther): This should have its own uncatchable error.
-            registerImpact(impacts.throwRuntimeError);
+            registerImpact(_impacts.throwRuntimeError);
           }
           break;
         case Feature.FALL_THROUGH_ERROR:
-          registerImpact(impacts.fallThroughError);
+          registerImpact(_impacts.fallThroughError);
           break;
         case Feature.FIELD_WITHOUT_INITIALIZER:
         case Feature.LOCAL_WITHOUT_INITIALIZER:
           transformed.registerTypeUse(
-              new TypeUse.instantiation(backend.commonElements.nullType));
-          registerImpact(impacts.nullLiteral);
+              new TypeUse.instantiation(_commonElements.nullType));
+          registerImpact(_impacts.nullLiteral);
           break;
         case Feature.LAZY_FIELD:
-          registerImpact(impacts.lazyField);
+          registerImpact(_impacts.lazyField);
           break;
         case Feature.STACK_TRACE_IN_CATCH:
-          registerImpact(impacts.stackTraceInCatch);
+          registerImpact(_impacts.stackTraceInCatch);
           break;
         case Feature.STRING_INTERPOLATION:
-          registerImpact(impacts.stringInterpolation);
+          registerImpact(_impacts.stringInterpolation);
           break;
         case Feature.STRING_JUXTAPOSITION:
-          registerImpact(impacts.stringJuxtaposition);
+          registerImpact(_impacts.stringJuxtaposition);
           break;
         case Feature.SUPER_NO_SUCH_METHOD:
-          registerImpact(impacts.superNoSuchMethod);
+          registerImpact(_impacts.superNoSuchMethod);
           break;
         case Feature.SYMBOL_CONSTRUCTOR:
-          registerImpact(impacts.symbolConstructor);
+          registerImpact(_impacts.symbolConstructor);
           break;
         case Feature.SYNC_FOR_IN:
-          registerImpact(impacts.syncForIn);
+          registerImpact(_impacts.syncForIn);
           break;
         case Feature.SYNC_STAR:
-          registerImpact(impacts.syncStarBody);
+          registerImpact(_impacts.syncStarBody);
           break;
         case Feature.THROW_EXPRESSION:
-          registerImpact(impacts.throwExpression);
+          registerImpact(_impacts.throwExpression);
           break;
         case Feature.THROW_NO_SUCH_METHOD:
-          registerImpact(impacts.throwNoSuchMethod);
+          registerImpact(_impacts.throwNoSuchMethod);
           break;
         case Feature.THROW_RUNTIME_ERROR:
-          registerImpact(impacts.throwRuntimeError);
+          registerImpact(_impacts.throwRuntimeError);
           break;
         case Feature.TYPE_VARIABLE_BOUNDS_CHECK:
-          registerImpact(impacts.typeVariableBoundCheck);
+          registerImpact(_impacts.typeVariableBoundCheck);
           break;
       }
     }
 
     bool hasAsCast = false;
     bool hasTypeLiteral = false;
     for (TypeUse typeUse in worldImpact.typeUses) {
       ResolutionDartType type = typeUse.type;
       switch (typeUse.kind) {
         case TypeUseKind.INSTANTIATION:
         case TypeUseKind.MIRROR_INSTANTIATION:
         case TypeUseKind.NATIVE_INSTANTIATION:
           registerRequiredType(type);
           break;
         case TypeUseKind.IS_CHECK:
           onIsCheck(type, transformed);
           break;
         case TypeUseKind.AS_CAST:
           onIsCheck(type, transformed);
           hasAsCast = true;
           break;
         case TypeUseKind.CHECKED_MODE_CHECK:
-          if (backend.compiler.options.enableTypeAssertions) {
+          if (_options.enableTypeAssertions) {
             onIsCheck(type, transformed);
           }
           break;
         case TypeUseKind.CATCH_TYPE:
           onIsCheck(type, transformed);
           break;
         case TypeUseKind.TYPE_LITERAL:
-          backend.customElementsResolutionAnalysis.registerTypeLiteral(type);
+          _customElementsResolutionAnalysis.registerTypeLiteral(type);
           if (type.isTypeVariable && type is! MethodTypeVariableType) {
             // GENERIC_METHODS: The `is!` test above filters away method type
             // variables, because they have the value `dynamic` with the
             // incomplete support for generic methods offered with
             // '--generic-method-syntax'. This must be revised in order to
             // support generic methods fully.
             ClassElement cls = type.element.enclosingClass;
-            backend.rtiNeedBuilder
-                .registerClassUsingTypeVariableExpression(cls);
-            registerImpact(impacts.typeVariableExpression);
+            _rtiNeedBuilder.registerClassUsingTypeVariableExpression(cls);
+            registerImpact(_impacts.typeVariableExpression);
           }
           hasTypeLiteral = true;
           break;
       }
     }
 
     if (hasAsCast) {
-      registerImpact(impacts.asCheck);
+      registerImpact(_impacts.asCheck);
     }
 
     if (hasTypeLiteral) {
-      transformed.registerTypeUse(
-          new TypeUse.instantiation(backend.compiler.commonElements.typeType));
-      registerImpact(impacts.typeLiteral);
+      transformed
+          .registerTypeUse(new TypeUse.instantiation(_commonElements.typeType));
+      registerImpact(_impacts.typeLiteral);
     }
 
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
       if (mapLiteralUse.isConstant) {
-        registerImpact(impacts.constantMapLiteral);
+        registerImpact(_impacts.constantMapLiteral);
       } else {
         transformed
             .registerTypeUse(new TypeUse.instantiation(mapLiteralUse.type));
       }
       ResolutionInterfaceType type = mapLiteralUse.type;
       registerRequiredType(type);
     }
 
     for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
       // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
       // factory constructors are registered directly.
       transformed
           .registerTypeUse(new TypeUse.instantiation(listLiteralUse.type));
       ResolutionInterfaceType type = listLiteralUse.type;
       registerRequiredType(type);
     }
 
     if (worldImpact.constSymbolNames.isNotEmpty) {
-      registerImpact(impacts.constSymbol);
+      registerImpact(_impacts.constSymbol);
       for (String constSymbolName in worldImpact.constSymbolNames) {
-        backend.mirrorsData.registerConstSymbol(constSymbolName);
+        _mirrorsData.registerConstSymbol(constSymbolName);
       }
     }
 
     for (StaticUse staticUse in worldImpact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
-          registerImpact(impacts.closure);
+          registerImpact(_impacts.closure);
           LocalFunctionElement closure = staticUse.element;
           if (closure.type.containsTypeVariables) {
-            registerImpact(impacts.computeSignature);
+            registerImpact(_impacts.computeSignature);
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
           registerRequiredType(staticUse.type);
           break;
         default:
       }
     }
 
     for (ConstantExpression constant in worldImpact.constantLiterals) {
       switch (constant.kind) {
         case ConstantExpressionKind.NULL:
-          registerImpact(impacts.nullLiteral);
+          registerImpact(_impacts.nullLiteral);
           break;
         case ConstantExpressionKind.BOOL:
-          registerImpact(impacts.boolLiteral);
+          registerImpact(_impacts.boolLiteral);
           break;
         case ConstantExpressionKind.INT:
-          registerImpact(impacts.intLiteral);
+          registerImpact(_impacts.intLiteral);
           break;
         case ConstantExpressionKind.DOUBLE:
-          registerImpact(impacts.doubleLiteral);
+          registerImpact(_impacts.doubleLiteral);
           break;
         case ConstantExpressionKind.STRING:
-          registerImpact(impacts.stringLiteral);
+          registerImpact(_impacts.stringLiteral);
           break;
         default:
           assert(invariant(NO_LOCATION_SPANNABLE, false,
               message: "Unexpected constant literal: ${constant.kind}."));
       }
     }
 
     for (native.NativeBehavior behavior in worldImpact.nativeData) {
-      backend.nativeResolutionEnqueuer
-          .registerNativeBehavior(transformed, behavior, worldImpact);
+      _nativeResolutionEnqueuer.registerNativeBehavior(
+          transformed, behavior, worldImpact);
     }
 
     return transformed;
   }
 
   /// Register [type] as required for the runtime type information system.
   void registerRequiredType(ResolutionDartType type) {
     if (!type.isInterfaceType) return;
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
     // defined (that is the enclosing class of the current element being
     // resolved) and the class of [type]. If the class of [type] requires RTI,
     // then the class of the type variable does too.
     ClassElement contextClass = Types.getClassContext(type);
     if (contextClass != null) {
-      backend.rtiNeedBuilder.registerRtiDependency(type.element, contextClass);
+      _rtiNeedBuilder.registerRtiDependency(type.element, contextClass);
     }
   }
 
   // TODO(johnniwinther): Maybe split this into [onAssertType] and [onTestType].
   void onIsCheck(ResolutionDartType type, TransformedWorldImpact transformed) {
-    BackendUsageBuilder backendUsage = backend.backendUsageBuilder;
-
     void registerImpact(BackendImpact impact) {
-      impact.registerImpact(transformed, elementEnvironment);
-      backendUsage.processBackendImpact(impact);
+      impact.registerImpact(transformed, _elementEnvironment);
+      _backendUsageBuider.processBackendImpact(impact);
     }
 
     registerRequiredType(type);
-    type.computeUnaliased(backend.resolution);
+    type.computeUnaliased(_resolution);
     type = type.unaliased;
-    registerImpact(impacts.typeCheck);
+    registerImpact(_impacts.typeCheck);
 
-    bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
+    bool inCheckedMode = _options.enableTypeAssertions;
     if (inCheckedMode) {
-      registerImpact(impacts.checkedModeTypeCheck);
+      registerImpact(_impacts.checkedModeTypeCheck);
     }
     if (type.isMalformed) {
-      registerImpact(impacts.malformedTypeCheck);
+      registerImpact(_impacts.malformedTypeCheck);
     }
     if (!type.treatAsRaw || type.containsTypeVariables || type.isFunctionType) {
-      registerImpact(impacts.genericTypeCheck);
+      registerImpact(_impacts.genericTypeCheck);
       if (inCheckedMode) {
-        registerImpact(impacts.genericCheckedModeTypeCheck);
+        registerImpact(_impacts.genericCheckedModeTypeCheck);
       }
       if (type.isTypeVariable) {
-        registerImpact(impacts.typeVariableTypeCheck);
+        registerImpact(_impacts.typeVariableTypeCheck);
         if (inCheckedMode) {
-          registerImpact(impacts.typeVariableCheckedModeTypeCheck);
+          registerImpact(_impacts.typeVariableCheckedModeTypeCheck);
         }
       }
     }
     if (type is ResolutionFunctionType) {
-      registerImpact(impacts.functionTypeCheck);
+      registerImpact(_impacts.functionTypeCheck);
     }
     if (type is ResolutionInterfaceType &&
-        backend.nativeClassData.isNativeClass(type.element)) {
-      registerImpact(impacts.nativeTypeCheck);
+        _nativeClassData.isNativeClass(type.element)) {
+      registerImpact(_impacts.nativeTypeCheck);
     }
   }
+}
+
+class CodegenImpactTransformer {
+  // TODO(johnniwinther): Remove the need for this.
+  final JavaScriptBackend _backend;
+
+  final CompilerOptions _options;
+  final ElementEnvironment _elementEnvironment;
+  final BackendHelpers _helpers;
+  final BackendImpacts _impacts;
+  final CheckedModeHelpers _checkedModeHelpers;
+  final NativeData _nativeData;
+  final RuntimeTypesNeed _rtiNeed;
+  final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
+  final Namer _namer;
+  final MirrorsData _mirrorsData;
+  final OneShotInterceptorData _oneShotInterceptorData;
+  final LookupMapAnalysis _lookupMapAnalysis;
+  final CustomElementsCodegenAnalysis _customElementsCodegenAnalysis;
+
+  CodegenImpactTransformer(
+      this._backend,
+      this._options,
+      this._elementEnvironment,
+      this._helpers,
+      this._impacts,
+      this._checkedModeHelpers,
+      this._nativeData,
+      this._rtiNeed,
+      this._nativeCodegenEnqueuer,
+      this._namer,
+      this._mirrorsData,
+      this._oneShotInterceptorData,
+      this._lookupMapAnalysis,
+      this._customElementsCodegenAnalysis);
 
   void onIsCheckForCodegen(
       ResolutionDartType type, TransformedWorldImpact transformed) {
     if (type.isDynamic) return;
     type = type.unaliased;
-    impacts.typeCheck.registerImpact(transformed, elementEnvironment);
+    _impacts.typeCheck.registerImpact(transformed, _elementEnvironment);
 
-    bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
+    bool inCheckedMode = _options.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       // All helpers are added to resolution queue in enqueueHelpers. These
       // calls to [enqueue] with the resolution enqueuer serve as assertions
       // that the helper was in fact added.
       // TODO(13155): Find a way to enqueue helpers lazily.
-      CheckedModeHelper helper = backend.checkedModeHelpers
-          .getCheckedModeHelper(type, typeCast: false);
+      CheckedModeHelper helper =
+          _checkedModeHelpers.getCheckedModeHelper(type, typeCast: false);
       if (helper != null) {
-        StaticUse staticUse = helper.getStaticUse(backend.helpers);
+        StaticUse staticUse = helper.getStaticUse(_helpers);
         transformed.registerStaticUse(staticUse);
       }
       // We also need the native variant of the check (for DOM types).
-      helper = backend.checkedModeHelpers
-          .getNativeCheckedModeHelper(type, typeCast: false);
+      helper =
+          _checkedModeHelpers.getNativeCheckedModeHelper(type, typeCast: false);
       if (helper != null) {
-        StaticUse staticUse = helper.getStaticUse(backend.helpers);
+        StaticUse staticUse = helper.getStaticUse(_helpers);
         transformed.registerStaticUse(staticUse);
       }
     }
     if (!type.treatAsRaw || type.containsTypeVariables) {
-      impacts.genericIsCheck.registerImpact(transformed, elementEnvironment);
+      _impacts.genericIsCheck.registerImpact(transformed, _elementEnvironment);
     }
     if (type is ResolutionInterfaceType &&
-        backend.nativeData.isNativeClass(type.element)) {
+        _nativeData.isNativeClass(type.element)) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
-      impacts.nativeTypeCheck.registerImpact(transformed, elementEnvironment);
+      _impacts.nativeTypeCheck.registerImpact(transformed, _elementEnvironment);
     }
   }
 
   @override
   WorldImpact transformCodegenImpact(CodegenImpact impact) {
     TransformedWorldImpact transformed = new TransformedWorldImpact(impact);
 
     for (TypeUse typeUse in impact.typeUses) {
       ResolutionDartType type = typeUse.type;
       switch (typeUse.kind) {
         case TypeUseKind.INSTANTIATION:
-          backend.lookupMapAnalysis.registerInstantiatedType(type);
+          _lookupMapAnalysis.registerInstantiatedType(type);
           break;
         case TypeUseKind.IS_CHECK:
           onIsCheckForCodegen(type, transformed);
           break;
         default:
       }
     }
 
     for (ConstantValue constant in impact.compileTimeConstants) {
-      backend.computeImpactForCompileTimeConstant(constant, transformed,
+      _backend.computeImpactForCompileTimeConstant(constant, transformed,
           forResolution: false);
-      backend.addCompileTimeConstantForEmission(constant);
+      _backend.addCompileTimeConstantForEmission(constant);
     }
 
     for (Pair<ResolutionDartType, ResolutionDartType> check
         in impact.typeVariableBoundsSubtypeChecks) {
-      backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
+      _backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
     }
 
     for (StaticUse staticUse in impact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
           LocalFunctionElement closure = staticUse.element;
-          if (backend.rtiNeed.localFunctionNeedsRti(closure)) {
-            impacts.computeSignature
-                .registerImpact(transformed, elementEnvironment);
+          if (_rtiNeed.localFunctionNeedsRti(closure)) {
+            _impacts.computeSignature
+                .registerImpact(transformed, _elementEnvironment);
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
-          backend.lookupMapAnalysis.registerInstantiatedType(staticUse.type);
+          _lookupMapAnalysis.registerInstantiatedType(staticUse.type);
           break;
         default:
       }
     }
 
     for (String name in impact.constSymbols) {
-      backend.mirrorsData.registerConstSymbol(name);
+      _mirrorsData.registerConstSymbol(name);
     }
 
     for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
-      backend.oneShotInterceptorData
-          .registerSpecializedGetInterceptor(classes, backend.namer);
+      _oneShotInterceptorData.registerSpecializedGetInterceptor(
+          classes, _namer);
     }
 
     if (impact.usesInterceptor) {
-      if (backend.nativeCodegenEnqueuer.hasInstantiatedNativeClasses) {
-        impacts.interceptorUse.registerImpact(transformed, elementEnvironment);
+      if (_nativeCodegenEnqueuer.hasInstantiatedNativeClasses) {
+        _impacts.interceptorUse
+            .registerImpact(transformed, _elementEnvironment);
       }
     }
 
     for (ClassElement element in impact.typeConstants) {
-      backend.customElementsCodegenAnalysis.registerTypeConstant(element);
-      backend.lookupMapAnalysis.registerTypeConstant(element);
+      _customElementsCodegenAnalysis.registerTypeConstant(element);
+      _lookupMapAnalysis.registerTypeConstant(element);
     }
 
     for (FunctionElement element in impact.asyncMarkers) {
       switch (element.asyncMarker) {
         case AsyncMarker.ASYNC:
-          impacts.asyncBody.registerImpact(transformed, elementEnvironment);
+          _impacts.asyncBody.registerImpact(transformed, _elementEnvironment);
           break;
         case AsyncMarker.SYNC_STAR:
-          impacts.syncStarBody.registerImpact(transformed, elementEnvironment);
+          _impacts.syncStarBody
+              .registerImpact(transformed, _elementEnvironment);
           break;
         case AsyncMarker.ASYNC_STAR:
-          impacts.asyncStarBody.registerImpact(transformed, elementEnvironment);
+          _impacts.asyncStarBody
+              .registerImpact(transformed, _elementEnvironment);
           break;
       }
     }
 
     // TODO(johnniwinther): Remove eager registration.
     return transformed;
   }
 }