Split MirrorsData

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 362 matching lines @@
   RuntimeTypesNeed _rtiNeed;
   final _RuntimeTypes _rti;
   RuntimeTypesChecks _rtiChecks;
 
   RuntimeTypesEncoder _rtiEncoder;
 
   /// True if the html library has been loaded.
   bool htmlLibraryIsLoaded = false;
 
   /// Resolution analysis for tracking reflective access to type variables.
-  TypeVariableAnalysis typeVariableAnalysis;
+  TypeVariableAnalysis _typeVariableAnalysis;
 
   /// Codegen handler for reflective access to type variables.
-  TypeVariableHandler typeVariableHandler;
+  TypeVariableHandler _typeVariableHandler;
 
   /// Resolution support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsResolutionAnalysis customElementsResolutionAnalysis;
 
   /// Codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsCodegenAnalysis customElementsCodegenAnalysis;
 
   /// Resolution support for tree-shaking entries of `LookupMap`.
@@ skipping 36 matching lines @@
   NativeClassData get nativeClassData => _nativeClassData;
   NativeData get nativeData => _nativeData;
   NativeClassDataBuilder get nativeClassDataBuilder => _nativeClassData;
   NativeDataBuilder get nativeDataBuilder => _nativeData;
   final NativeDataResolver _nativeDataResolver;
   InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
-  MirrorsData mirrorsData;
+  MirrorsDataImpl _mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
   native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
 
   BackendHelpers helpers;
   BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
@@ skipping 43 matching lines @@
             useNewSourceInfo: useNewSourceInfo),
         frontend = new JSFrontendAccess(compiler),
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         _nativeDataResolver = new NativeDataResolverImpl(compiler) {
     _nativeData = new NativeDataImpl(nativeClassData);
     _target = new JavaScriptBackendTarget(this);
     helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
     impacts = new BackendImpacts(compiler.options, commonElements, helpers);
     backendClasses = new JavaScriptBackendClasses(
         compiler.elementEnvironment, helpers, nativeClassData);
-    mirrorsData = new MirrorsData(
+    _mirrorsData = new MirrorsDataImpl(
         compiler, compiler.options, commonElements, helpers, constants);
     _backendUsageBuilder = new BackendUsageBuilderImpl(
         compiler.elementEnvironment, commonElements, helpers);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
     _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(compiler);
     _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
         compiler, emitter, _nativeResolutionEnqueuer);
 
-    typeVariableAnalysis = new TypeVariableAnalysis(
+    _typeVariableAnalysis = new TypeVariableAnalysis(
         compiler.elementEnvironment, impacts, backendUsageBuilder);
-    typeVariableHandler = new TypeVariableHandler(this, helpers, mirrorsData);
     customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
         helpers,
         nativeClassData,
         backendUsageBuilder);
     customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
         compiler.resolution,
@@ skipping 11 matching lines @@
     kernelTask = new KernelTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(
         compiler.options,
         compiler.resolution,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         nativeClassData,
         nativeResolutionEnqueuer,
         backendUsageBuilder,
-        mirrorsData,
+        mirrorsDataBuilder,
         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
   /// backend.
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
   Resolution get resolution => compiler.resolution;
 
   Target get target => _target;
 
+  /// Resolution analysis for tracking reflective access to type variables.
+  TypeVariableAnalysis get typeVariableAnalysis {
+    assert(invariant(NO_LOCATION_SPANNABLE, _typeVariableHandler == null,
+        message: "TypeVariableHandler has already been created."));
+    return _typeVariableAnalysis;
+  }
+
+  /// Codegen handler for reflective access to type variables.
+  TypeVariableHandler get typeVariableHandler {
+    assert(invariant(NO_LOCATION_SPANNABLE, _typeVariableHandler != null,
+        message: "TypeVariableHandler has not been created yet."));
+    return _typeVariableHandler;
+  }
+
+  MirrorsData get mirrorsData => _mirrorsData;
+
+  MirrorsDataBuilder get mirrorsDataBuilder => _mirrorsData;
+
   /// Codegen support for tree-shaking entries of `LookupMap`.
   LookupMapAnalysis get lookupMapAnalysis {
     assert(invariant(NO_LOCATION_SPANNABLE, _lookupMapAnalysis != null,
         message: "LookupMapAnalysis has not been created yet."));
     return _lookupMapAnalysis;
   }
 
   InterceptorData get interceptorData {
     assert(invariant(NO_LOCATION_SPANNABLE, _interceptorData != null,
         message: "InterceptorData has not been computed yet."));
@@ skipping 188 matching lines @@
     validateInterceptorImplementsAllObjectMethods(helpers.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(helpers.jsNullClass);
   }
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
-    mirrorsData.computeMembersNeededForReflection(
+    mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _backendUsage = _backendUsageBuilder.close();
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
         compiler.types,
         commonElements,
         helpers,
         _backendUsage,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
@@ skipping 72 matching lines @@
             compiler.options,
             compiler.elementEnvironment,
             commonElements,
             helpers,
             impacts,
             backendClasses,
             nativeClassData,
             _interceptorDataBuilder,
             _backendUsageBuilder,
             _rtiNeedBuilder,
-            mirrorsData,
+            mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapLibraryAccess,
             mirrorsAnalysis,
             typeVariableAnalysis,
             _nativeResolutionEnqueuer),
         new ElementResolutionWorldBuilder(
             this, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
+    _typeVariableHandler = new TypeVariableHandler(this, helpers, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
         reporter,
         constantSystem,
         constants,
         compiler.elementEnvironment,
         commonElements,
         helpers,
         backendClasses,
         lookupMapLibraryAccess);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeClassData, closedWorld, constants, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.dumpInfoTask,
             compiler.elementEnvironment,
             commonElements,
             helpers,
             impacts,
             backendClasses,
             backendUsage,
             rtiNeed,
-            mirrorsData,
             customElementsCodegenAnalysis,
             typeVariableHandler,
             lookupMapAnalysis,
             mirrorsAnalysis,
             _nativeCodegenEnqueuer));
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
@@ skipping 256 matching lines @@
     _codegenImpactTransformer = new CodegenImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
         helpers,
         impacts,
         checkedModeHelpers,
         nativeData,
         rtiNeed,
         nativeCodegenEnqueuer,
         namer,
-        mirrorsData,
         oneShotInterceptorData,
         lookupMapAnalysis,
         rtiChecksBuilder);
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
@@ skipping 379 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }