Add ClosedWorld.elementEnvironment and remove Compiler.elementEnvironment

pkg/compiler/lib/src/world.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 dart2js.world;
 
 import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'constants/constant_system.dart';
-import 'common_elements.dart' show CommonElements;
+import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
         MixinApplicationElement,
         TypedefElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
@@ skipping 20 matching lines @@
 /// JavaScript types are touched, what language features are used, and so on.
 /// This precise knowledge about what's live in the program is later used in
 /// optimizations and other compiler decisions during code generation.
 abstract class ClosedWorld implements World {
   BackendUsage get backendUsage;
 
   NativeData get nativeData;
 
   InterceptorData get interceptorData;
 
+  ElementEnvironment get elementEnvironment;
+
   CommonElements get commonElements;
 
   CommonMasks get commonMasks;
 
   ConstantSystem get constantSystem;
 
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassEntity cls);
 
   /// Returns `true` if [cls] is directly instantiated. This means that at
@@ skipping 361 matching lines @@
   final Map<Entity, SideEffects> _sideEffects = new Map<Entity, SideEffects>();
 
   final Set<Entity> _sideEffectsFreeElements = new Set<Entity>();
 
   final Set<Entity> _elementsThatCannotThrow = new Set<Entity>();
 
   final Set<Entity> _functionsThatMightBePassedToApply = new Set<Entity>();
 
   CommonMasks _commonMasks;
 
+  final ElementEnvironment elementEnvironment;
   final CommonElements commonElements;
 
   // TODO(johnniwinther): Avoid this.
   final ResolutionWorldBuilder _resolverWorld;
 
   // TODO(johnniwinther): Can this be derived from [ClassSet]s?
   final Set<ClassEntity> _implementedClasses;
 
   ClosedWorldBase(
-      {this.commonElements,
+      {this.elementEnvironment,
+      this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
@@ skipping 697 matching lines @@
       sb.write("Instantiated classes in the closed world:\n");
     }
     getClassHierarchyNode(commonElements.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 }
 
 class ClosedWorldImpl extends ClosedWorldBase {
   ClosedWorldImpl(
-      {CommonElements commonElements,
+      {ElementEnvironment elementEnvironment,
+      CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
+            elementEnvironment: elementEnvironment,
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
             implementedClasses: implementedClasses,
             functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
@@ skipping 108 matching lines @@
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return super.getSideEffectsOfElement(element);
   }
 }