Split MirrorsData

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;
@@ skipping 26 matching lines @@
 
 class JavaScriptImpactTransformer extends ImpactTransformer {
   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 MirrorsDataBuilder _mirrorsDataBuilder;
   final CustomElementsResolutionAnalysis _customElementsResolutionAnalysis;
   final RuntimeTypesNeedBuilder _rtiNeedBuilder;
 
   JavaScriptImpactTransformer(
       this._options,
       this._resolution,
       this._elementEnvironment,
       this._commonElements,
       this._impacts,
       this._nativeClassData,
       this._nativeResolutionEnqueuer,
       this._backendUsageBuider,
-      this._mirrorsData,
+      this._mirrorsDataBuilder,
       this._customElementsResolutionAnalysis,
       this._rtiNeedBuilder);
 
   @override
   WorldImpact transformResolutionImpact(
       ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
 
     void registerImpact(BackendImpact impact) {
@@ skipping 148 matching lines @@
       // 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);
       for (String constSymbolName in worldImpact.constSymbolNames) {
-        _mirrorsData.registerConstSymbol(constSymbolName);
+        _mirrorsDataBuilder.registerConstSymbol(constSymbolName);
       }
     }
 
     for (StaticUse staticUse in worldImpact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
           registerImpact(_impacts.closure);
           LocalFunctionElement closure = staticUse.element;
           if (closure.type.containsTypeVariables) {
             registerImpact(_impacts.computeSignature);
@@ skipping 97 matching lines @@
   final CompilerOptions _options;
   final ElementEnvironment _elementEnvironment;
   final BackendHelpers _helpers;
   final BackendImpacts _impacts;
   final CheckedModeHelpers _checkedModeHelpers;
   final NativeData _nativeData;
   final BackendUsage _backendUsage;
   final RuntimeTypesNeed _rtiNeed;
   final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
   final Namer _namer;
-  final MirrorsData _mirrorsData;
   final OneShotInterceptorData _oneShotInterceptorData;
   final LookupMapAnalysis _lookupMapAnalysis;
   final RuntimeTypesChecksBuilder _rtiChecksBuilder;
 
   CodegenImpactTransformer(
       this._options,
       this._elementEnvironment,
       this._helpers,
       this._impacts,
       this._checkedModeHelpers,
       this._nativeData,
       this._backendUsage,
       this._rtiNeed,
       this._nativeCodegenEnqueuer,
       this._namer,
-      this._mirrorsData,
       this._oneShotInterceptorData,
       this._lookupMapAnalysis,
       this._rtiChecksBuilder);
 
   void onIsCheckForCodegen(
       ResolutionDartType type, TransformedWorldImpact transformed) {
     if (type.isDynamic) return;
     type = type.unaliased;
     _impacts.typeCheck.registerImpact(transformed, _elementEnvironment);
 
@@ skipping 63 matching lines @@
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
           _lookupMapAnalysis.registerInstantiatedType(staticUse.type);
           break;
         default:
       }
     }
 
-    for (String name in impact.constSymbols) {
-      _mirrorsData.registerConstSymbol(name);
-    }
-
     for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
       _oneShotInterceptorData.registerSpecializedGetInterceptor(
           classes, _namer);
     }
 
     if (impact.usesInterceptor) {
       if (_nativeCodegenEnqueuer.hasInstantiatedNativeClasses) {
         _impacts.interceptorUse
             .registerImpact(transformed, _elementEnvironment);
         // TODO(johnniwinther): Avoid these workarounds.
@@ skipping 15 matching lines @@
           _impacts.asyncStarBody
               .registerImpact(transformed, _elementEnvironment);
           break;
       }
     }
 
     // TODO(johnniwinther): Remove eager registration.
     return transformed;
   }
 }