Add ClosedWorld.elementEnvironment and remove Compiler.elementEnvironment

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 '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/names.dart' show Uris;
 import '../common/resolution.dart' show Resolution, 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;
+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/names.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../enqueue.dart'
     show
         DirectEnqueuerStrategy,
@@ skipping 416 matching lines @@
 
   Tracer tracer;
 
   JavaScriptBackend(this.compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useMultiSourceInfo: false,
       bool useNewSourceInfo: false,
       bool useKernel: false})
       : _rti = new RuntimeTypesImpl(
-            compiler.elementEnvironment, compiler.frontendStrategy.dartTypes),
-        optimizerHints = new OptimizerHintsForTests(compiler.elementEnvironment,
+            compiler.frontendStrategy.elementEnvironment,
+            compiler.frontendStrategy.dartTypes),
+        optimizerHints = new OptimizerHintsForTests(
+            compiler.frontendStrategy.elementEnvironment,
             compiler.frontendStrategy.commonElements),
         this.sourceInformationStrategy =
             compiler.backendStrategy.sourceInformationStrategy,
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         _nativeDataResolver = new NativeDataResolverImpl(compiler),
         _rtiNeedBuilder =
             compiler.frontendStrategy.createRuntimeTypesNeedBuilder() {
     CommonElements commonElements = compiler.frontendStrategy.commonElements;
     _target = new JavaScriptBackendTarget(this);
     impacts = new BackendImpacts(compiler.options, commonElements);
     _mirrorsData = compiler.frontendStrategy.createMirrorsDataBuilder();
     _backendUsageBuilder = new BackendUsageBuilderImpl(commonElements);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
 
     _typeVariableResolutionAnalysis = new TypeVariableResolutionAnalysis(
-        compiler.elementEnvironment, impacts, _backendUsageBuilder);
+        compiler.frontendStrategy.elementEnvironment,
+        impacts,
+        _backendUsageBuilder);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     _mirrorsResolutionAnalysis =
         compiler.frontendStrategy.createMirrorsResolutionAnalysis(this);
-    lookupMapResolutionAnalysis =
-        new LookupMapResolutionAnalysis(reporter, compiler.elementEnvironment);
+    lookupMapResolutionAnalysis = new LookupMapResolutionAnalysis(
+        reporter, compiler.frontendStrategy.elementEnvironment);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(
         commonElements, compiler.frontendStrategy.createNoSuchMethodResolver());
     kernelTask = new KernelTask(compiler);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = new SsaFunctionCompiler(
         this, compiler.measurer, sourceInformationStrategy);
     serialization = new JavaScriptBackendSerialization(this);
   }
 
@@ skipping 235 matching lines @@
   void onResolutionEnd() {
     frontendStrategy.annotationProcesser
         .processJsInteropAnnotations(nativeBasicData, nativeDataBuilder);
   }
 
   /// Called when the closed world from resolution has been computed.
   void onResolutionClosedWorld(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (MemberEntity entity
         in compiler.enqueuer.resolution.processedEntities) {
-      processAnnotations(
+      processAnnotations(closedWorld.elementEnvironment,
           closedWorld.commonElements, entity, closedWorldRefiner);
     }
     mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder, closedWorld, compiler.types,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
     mirrorsResolutionAnalysis.onResolutionComplete();
   }
 
@@ skipping 28 matching lines @@
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   ResolutionEnqueuer createResolutionEnqueuer(
       CompilerTask task, Compiler compiler) {
+    ElementEnvironment elementEnvironment =
+        compiler.frontendStrategy.elementEnvironment;
     CommonElements commonElements = compiler.frontendStrategy.commonElements;
-    _nativeBasicData =
-        nativeBasicDataBuilder.close(compiler.elementEnvironment);
+    _nativeBasicData = nativeBasicDataBuilder.close(elementEnvironment);
     _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(
         compiler.options,
-        compiler.elementEnvironment,
+        elementEnvironment,
         commonElements,
         compiler.frontendStrategy.dartTypes,
         _backendUsageBuilder,
         compiler.frontendStrategy.createNativeClassFinder(nativeBasicData));
     _nativeDataBuilder = new NativeDataBuilderImpl(nativeBasicData);
     _customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         constantSystem,
-        compiler.elementEnvironment,
+        elementEnvironment,
         commonElements,
         nativeBasicData,
         _backendUsageBuilder);
     impactTransformer = new JavaScriptImpactTransformer(
         compiler.options,
-        compiler.elementEnvironment,
+        elementEnvironment,
         commonElements,
         impacts,
         nativeBasicData,
         _nativeResolutionEnqueuer,
         _backendUsageBuilder,
         mirrorsDataBuilder,
         customElementsResolutionAnalysis,
         rtiNeedBuilder);
     InterceptorDataBuilder interceptorDataBuilder =
         new InterceptorDataBuilderImpl(
-            nativeBasicData, compiler.elementEnvironment, commonElements);
+            nativeBasicData, elementEnvironment, commonElements);
     return new ResolutionEnqueuer(
         task,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
         new ResolutionEnqueuerListener(
             compiler.options,
-            compiler.elementEnvironment,
+            elementEnvironment,
             commonElements,
             impacts,
             nativeBasicData,
             interceptorDataBuilder,
             _backendUsageBuilder,
             rtiNeedBuilder,
             mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapResolutionAnalysis,
             mirrorsResolutionAnalysis,
             typeVariableResolutionAnalysis,
             _nativeResolutionEnqueuer,
             compiler.deferredLoadTask,
             kernelTask),
         compiler.frontendStrategy.createResolutionWorldBuilder(
             nativeBasicData,
             _nativeDataBuilder,
             interceptorDataBuilder,
             _backendUsageBuilder,
             const OpenWorldStrategy()),
         compiler.frontendStrategy.createResolutionWorkItemBuilder(
             nativeBasicData, _nativeDataBuilder, impactTransformer));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
+    ElementEnvironment elementEnvironment = closedWorld.elementEnvironment;
     CommonElements commonElements = closedWorld.commonElements;
     _typeVariableCodegenAnalysis = new TypeVariableCodegenAnalysis(
-        compiler.elementEnvironment, this, commonElements, mirrorsData);
+        closedWorld.elementEnvironment, this, commonElements, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
         reporter,
         constantSystem,
         constants,
-        compiler.elementEnvironment,
+        elementEnvironment,
         commonElements,
         lookupMapResolutionAnalysis);
     _mirrorsCodegenAnalysis = mirrorsResolutionAnalysis.close();
     _customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
-        constantSystem,
-        commonElements,
-        compiler.elementEnvironment,
-        nativeBasicData);
+        constantSystem, commonElements, elementEnvironment, nativeBasicData);
     _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
         compiler.options,
-        compiler.elementEnvironment,
+        elementEnvironment,
         commonElements,
         compiler.frontendStrategy.dartTypes,
         emitter,
         _nativeResolutionEnqueuer,
         closedWorld.nativeData);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         compiler.backendStrategy.createCodegenWorldBuilder(
             nativeBasicData, closedWorld, const TypeMaskStrategy()),
         compiler.backendStrategy.createCodegenWorkItemBuilder(closedWorld),
         new CodegenEnqueuerListener(
-            compiler.elementEnvironment,
+            elementEnvironment,
             commonElements,
             impacts,
             closedWorld.backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
             nativeCodegenEnqueuer));
   }
@@ skipping 160 matching lines @@
 
   /// Called when the compiler starts running the codegen enqueuer. The
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
     _oneShotInterceptorData = new OneShotInterceptorData(
         closedWorld.interceptorData, closedWorld.commonElements);
     _namer = determineNamer(closedWorld, codegenWorldBuilder);
     tracer = new Tracer(closedWorld, namer, compiler);
     _rtiEncoder = _namer.rtiEncoder = new RuntimeTypesEncoderImpl(
-        namer, compiler.elementEnvironment, closedWorld.commonElements);
+        namer, closedWorld.elementEnvironment, closedWorld.commonElements);
     emitter.createEmitter(namer, closedWorld, codegenWorldBuilder);
     _codegenImpactTransformer = new CodegenImpactTransformer(
         compiler.options,
-        compiler.elementEnvironment,
+        closedWorld.elementEnvironment,
         closedWorld.commonElements,
         impacts,
         checkedModeHelpers,
         closedWorld.nativeData,
         closedWorld.backendUsage,
         rtiNeed,
         nativeCodegenEnqueuer,
         namer,
         oneShotInterceptorData,
         lookupMapAnalysis,
@@ skipping 21 matching lines @@
     if (canonicalUri == Uris.dart__js_helper ||
         canonicalUri == Uris.dart__interceptors) {
       return true;
     }
     return false;
   }
 
   /// Process backend specific annotations.
   // TODO(johnniwinther): Merge this with [AnnotationProcessor] and use
   // [ElementEnvironment.getMemberMetadata] in [AnnotationProcessor].
-  void processAnnotations(CommonElements commonElements, MemberEntity element,
+  void processAnnotations(
+      ElementEnvironment elementEnvironment,
+      CommonElements commonElements,
+      MemberEntity element,
       ClosedWorldRefiner closedWorldRefiner) {
     if (element is MemberElement && element.isMalformed) {
       // Elements that are marked as malformed during parsing or resolution
       // might be registered here. These should just be ignored.
       return;
     }
 
     if (element.isFunction || element.isConstructor) {
       if (optimizerHints.noInline(element)) {
         inlineCache.markAsNonInlinable(element);
       }
     }
     if (element.isField) return;
     FunctionEntity method = element;
 
     LibraryEntity library = method.library;
     if (library.canonicalUri.scheme != 'dart' &&
         !canLibraryUseNative(library)) {
       return;
     }
     bool hasNoInline = false;
     bool hasForceInline = false;
     bool hasNoThrows = false;
     bool hasNoSideEffects = false;
     for (ConstantValue constantValue
-        in compiler.elementEnvironment.getMemberMetadata(method)) {
+        in elementEnvironment.getMemberMetadata(method)) {
       if (!constantValue.isConstructedObject) continue;
       ObjectConstantValue value = constantValue;
       ClassEntity cls = value.type.element;
       if (cls == commonElements.forceInlineClass) {
         hasForceInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               method, MessageKind.GENERIC, {'text': "Must inline"});
         }
         inlineCache.markAsMustInline(method);
@@ skipping 238 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }