Rename KernelWorldBuilder to KernelElementBuilder

pkg/compiler/lib/src/kernel/element_map.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 dart2js.kernel.world_builder;
+library dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
@@ skipping 13 matching lines @@
 import '../universe/world_builder.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_basic_data.dart';
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
 part 'types.dart';
 
-/// World builder used for creating elements and types corresponding to Kernel
+/// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
-// TODO(johnniwinther): Implement [ResolutionWorldBuilder].
-class KernelWorldBuilder extends KernelElementAdapterMixin {
+class KernelToElementMap extends KernelElementAdapterMixin {
   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
   KernelConstantEnvironment _constantEnvironment;
   _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
-  KEnv _env;
+  _KEnv _env;
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
-  List<KLibraryEnv> _libraryEnvs = <KLibraryEnv>[];
+  List<_KLibraryEnv> _libraryEnvs = <_KLibraryEnv>[];
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
-  List<KClassEnv> _classEnvs = <KClassEnv>[];
+  List<_KClassEnv> _classEnvs = <_KClassEnv>[];
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
 
   // TODO(johnniwinther): Change this to a list of 'KMemberData' class if we
   // need more data for members.
   List<ir.Member> _memberList = <ir.Member>[];
 
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
   Map<KConstructor, ConstantConstructor> _constructorConstantMap =
       <KConstructor, ConstantConstructor>{};
 
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
 
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<KField, ConstantExpression> _fieldConstantMap =
       <KField, ConstantExpression>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
-  KernelWorldBuilder(this.reporter, ir.Program program)
-      : _env = new KEnv(program) {
+  KernelToElementMap(this.reporter, ir.Program program)
+      : _env = new _KEnv(program) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
         new KernelBehaviorBuilder(_commonElements, _constantEnvironment);
     _types = new _KernelDartTypes(this);
     _typeConverter = new DartTypeConverter(this);
   }
 
   KMethod get _mainFunction {
     return _env.program.mainMethod != null
         ? _getMethod(_env.program.mainMethod)
         : null;
   }
 
   KLibrary get _mainLibrary {
     return _env.program.mainMethod != null
         ? _getLibrary(_env.program.mainMethod.enclosingLibrary)
         : null;
   }
 
   Iterable<LibraryEntity> get _libraries {
     if (_env.length != _libraryMap.length) {
       // Create a [KLibrary] for each library.
-      _env.forEachLibrary((KLibraryEnv env) {
+      _env.forEachLibrary((_KLibraryEnv env) {
         _getLibrary(env.library, env);
       });
     }
     return _libraryMap.values;
   }
 
   @override
   CommonElements get commonElements => _commonElements;
 
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
   ConstantEnvironment get constantEnvironment => _constantEnvironment;
 
   DartTypes get types => _types;
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
 
   LibraryEntity lookupLibrary(Uri uri) {
-    KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
+    _KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
-  KLibrary _getLibrary(ir.Library node, [KLibraryEnv libraryEnv]) {
+  KLibrary _getLibrary(ir.Library node, [_KLibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       Uri canonicalUri = node.importUri;
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
       String name = node.name;
       if (name == null) {
         // Use the file name as script name.
         String path = canonicalUri.path;
         name = path.substring(path.lastIndexOf('/') + 1);
       }
       return new KLibrary(_libraryMap.length, name, canonicalUri);
     });
   }
 
   MemberEntity lookupLibraryMember(KLibrary library, String name,
       {bool setter: false}) {
-    KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   ClassEntity lookupClass(KLibrary library, String name) {
-    KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
-    KClassEnv classEnv = libraryEnv.lookupClass(name);
+    _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    _KClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
   void _forEachClass(KLibrary library, void f(ClassEntity cls)) {
-    KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
-    libraryEnv.forEachClass((KClassEnv classEnv) {
+    _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    libraryEnv.forEachClass((_KClassEnv classEnv) {
       f(_getClass(classEnv.cls, classEnv));
     });
   }
 
   MemberEntity lookupClassMember(KClass cls, String name,
       {bool setter: false}) {
-    KClassEnv classEnv = _classEnvs[cls.classIndex];
+    _KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   ConstructorEntity lookupConstructor(KClass cls, String name) {
-    KClassEnv classEnv = _classEnvs[cls.classIndex];
+    _KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupConstructor(name);
     return member != null ? getConstructor(member) : null;
   }
 
-  KClass _getClass(ir.Class node, [KClassEnv classEnv]) {
+  KClass _getClass(ir.Class node, [_KClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
       return new KClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
     });
   }
@@ skipping 183 matching lines @@
   List<DartType> getDartTypes(List<ir.DartType> types) {
     // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
     List<DartType> list = /*<DartType>*/ [];
     types.forEach((ir.DartType type) {
       list.add(getDartType(type));
     });
     return list;
   }
 
-  void _ensureThisAndRawType(KClass cls, KClassEnv env) {
+  void _ensureThisAndRawType(KClass cls, _KClassEnv env) {
     if (env.thisType == null) {
       ir.Class node = env.cls;
       // TODO(johnniwinther): Add the type argument to the list literal when we
       // no longer use resolution types.
       if (node.typeParameters.isEmpty) {
         env.thisType =
             env.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
       } else {
         env.thisType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .generate(node.typeParameters.length,
                 (int index) {
               return new TypeVariableType(
                   _getTypeVariable(node.typeParameters[index]));
             }));
         env.rawType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .filled(
                 node.typeParameters.length, const DynamicType()));
       }
     }
   }
 
   InterfaceType _getThisType(KClass cls) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.thisType;
   }
 
   InterfaceType _getRawType(KClass cls) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.rawType;
   }
 
-  void _ensureSupertypes(KClass cls, KClassEnv env) {
+  void _ensureSupertypes(KClass cls, _KClassEnv env) {
     if (env.orderedTypeSet == null) {
       _ensureThisAndRawType(cls, env);
 
       ir.Class node = env.cls;
 
       if (node.supertype == null) {
         env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
           InterfaceType type = _typeConverter.visitSupertype(node);
           KClass superclass = type.element;
-          KClassEnv env = _classEnvs[superclass.classIndex];
+          _KClassEnv env = _classEnvs[superclass.classIndex];
           _ensureSupertypes(superclass, env);
           return type;
         }
 
         env.supertype = processSupertype(node.supertype);
         LinkBuilder<InterfaceType> linkBuilder =
             new LinkBuilder<InterfaceType>();
         if (node.mixedInType != null) {
           linkBuilder.addLast(processSupertype(node.mixedInType));
         }
         node.implementedTypes.forEach((ir.Supertype supertype) {
           linkBuilder.addLast(processSupertype(supertype));
         });
         Link<InterfaceType> interfaces = linkBuilder.toLink();
         OrderedTypeSetBuilder setBuilder =
             new _KernelOrderedTypeSetBuilder(this, cls);
         env.orderedTypeSet =
             setBuilder.createOrderedTypeSet(env.supertype, interfaces);
       }
     }
   }
 
   OrderedTypeSet _getOrderedTypeSet(KClass cls) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.orderedTypeSet;
   }
 
   int _getHierarchyDepth(KClass cls) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.orderedTypeSet.maxDepth;
   }
 
   InterfaceType _substByContext(InterfaceType type, InterfaceType context) {
     return type.subst(
         context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getSuperType(KClass cls) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.supertype;
   }
 
   void _forEachSupertype(KClass cls, void f(InterfaceType supertype)) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     env.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachClassMember(
       KClass cls, void f(ClassEntity cls, MemberEntity member)) {
-    KClassEnv env = _classEnvs[cls.classIndex];
+    _KClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     _ensureSupertypes(cls, env);
     if (env.supertype != null) {
       _forEachClassMember(env.supertype.element, f);
     }
   }
 
   @override
@@ skipping 87 matching lines @@
     });
   }
 
   ResolutionImpact computeWorldImpact(KMember member) {
     ir.Member node = _memberList[member.memberIndex];
     return buildKernelImpact(node, this);
   }
 }
 
 /// Environment for fast lookup of program libraries.
-class KEnv {
+class _KEnv {
   final ir.Program program;
 
-  Map<Uri, KLibraryEnv> _libraryMap;
+  Map<Uri, _KLibraryEnv> _libraryMap;
 
-  KEnv(this.program);
+  _KEnv(this.program);
 
   void _ensureLibraryMap() {
     if (_libraryMap == null) {
-      _libraryMap = <Uri, KLibraryEnv>{};
+      _libraryMap = <Uri, _KLibraryEnv>{};
       for (ir.Library library in program.libraries) {
-        _libraryMap[library.importUri] = new KLibraryEnv(library);
+        _libraryMap[library.importUri] = new _KLibraryEnv(library);
       }
     }
   }
 
-  /// Return the [KLibraryEnv] for the library with the canonical [uri].
-  KLibraryEnv lookupLibrary(Uri uri) {
+  /// Return the [_KLibraryEnv] for the library with the canonical [uri].
+  _KLibraryEnv lookupLibrary(Uri uri) {
     _ensureLibraryMap();
     return _libraryMap[uri];
   }
 
   /// Calls [f] for each library in this environment.
-  void forEachLibrary(void f(KLibraryEnv library)) {
+  void forEachLibrary(void f(_KLibraryEnv library)) {
     _ensureLibraryMap();
     _libraryMap.values.forEach(f);
   }
 
   /// Returns the number of libraries in this environment.
   int get length {
     _ensureLibraryMap();
     return _libraryMap.length;
   }
 }
 
 /// Environment for fast lookup of library classes and members.
-// TODO(johnniwinther): Add member lookup.
-class KLibraryEnv {
+class _KLibraryEnv {
   final ir.Library library;
 
-  Map<String, KClassEnv> _classMap;
+  Map<String, _KClassEnv> _classMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
-  KLibraryEnv(this.library);
+  _KLibraryEnv(this.library);
 
   void _ensureClassMap() {
     if (_classMap == null) {
-      _classMap = <String, KClassEnv>{};
+      _classMap = <String, _KClassEnv>{};
       for (ir.Class cls in library.classes) {
-        _classMap[cls.name] = new KClassEnv(cls);
+        _classMap[cls.name] = new _KClassEnv(cls);
       }
     }
   }
 
-  /// Return the [KClassEnv] for the class [name] in [library].
-  KClassEnv lookupClass(String name) {
+  /// Return the [_KClassEnv] for the class [name] in [library].
+  _KClassEnv lookupClass(String name) {
     _ensureClassMap();
     return _classMap[name];
   }
 
   /// Calls [f] for each class in this library.
-  void forEachClass(void f(KClassEnv cls)) {
+  void forEachClass(void f(_KClassEnv cls)) {
     _ensureClassMap();
     _classMap.values.forEach(f);
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupMember(String name, {bool setter: false}) {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
       for (ir.Member member in library.members) {
@@ skipping 12 matching lines @@
           throw new SpannableAssertionFailure(
               NO_LOCATION_SPANNABLE, "Unexpected library member node: $member");
         }
       }
     }
     return _memberMap[name];
   }
 }
 
 /// Environment for fast lookup of class members.
-// TODO(johnniwinther): Add member lookup.
-class KClassEnv {
+class _KClassEnv {
   final ir.Class cls;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   OrderedTypeSet orderedTypeSet;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
   Iterable<ConstantExpression> _metadata;
 
-  KClassEnv(this.cls);
+  _KClassEnv(this.cls);
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
       for (ir.Member member in cls.members) {
         if (member is ir.Constructor ||
             member is ir.Procedure && member.kind == ir.ProcedureKind.Factory) {
           _constructorMap[member.name.name] = member;
@@ skipping 27 matching lines @@
   ir.Member lookupConstructor(String name) {
     _ensureMaps();
     return _constructorMap[name];
   }
 
   void forEachMember(f(ir.Member member)) {
     _ensureMaps();
     _memberMap.values.forEach(f);
   }
 
-  Iterable<ConstantExpression> getMetadata(KernelWorldBuilder worldBuilder) {
+  Iterable<ConstantExpression> getMetadata(KernelToElementMap worldBuilder) {
     if (_metadata == null) {
       _metadata = worldBuilder.getMetadata(cls.annotations);
     }
     return _metadata;
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
-  final KernelWorldBuilder worldBuilder;
+  final KernelToElementMap elementMap;
 
-  KernelElementEnvironment(this.worldBuilder);
+  KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
-  LibraryEntity get mainLibrary => worldBuilder._mainLibrary;
+  LibraryEntity get mainLibrary => elementMap._mainLibrary;
 
   @override
-  FunctionEntity get mainFunction => worldBuilder._mainFunction;
+  FunctionEntity get mainFunction => elementMap._mainFunction;
 
   @override
-  Iterable<LibraryEntity> get libraries => worldBuilder._libraries;
+  Iterable<LibraryEntity> get libraries => elementMap._libraries;
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
-    return worldBuilder._getThisType(cls);
+    return elementMap._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
-    return worldBuilder._getRawType(cls);
+    return elementMap._getRawType(cls);
   }
 
   @override
   DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
     throw new UnimplementedError(
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
   @override
   InterfaceType createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
   bool isSubtype(DartType a, DartType b) {
-    return worldBuilder.types.isSubtype(a, b);
+    return elementMap.types.isSubtype(a, b);
   }
 
   @override
   FunctionType getFunctionType(KFunction function) {
     throw new UnimplementedError('KernelElementEnvironment.getFunctionType');
   }
 
   @override
   FunctionType getLocalFunctionType(KLocalFunction function) {
     return function.functionType;
   }
 
   @override
   DartType getUnaliasedType(DartType type) => type;
 
   @override
   ConstructorEntity lookupConstructor(ClassEntity cls, String name,
       {bool required: false}) {
-    ConstructorEntity constructor = worldBuilder.lookupConstructor(cls, name);
+    ConstructorEntity constructor = elementMap.lookupConstructor(cls, name);
     if (constructor == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE,
           "The constructor '$name' was not found in class '${cls.name}' "
           "in library ${cls.library.canonicalUri}.");
     }
     return constructor;
   }
 
   @override
   MemberEntity lookupClassMember(ClassEntity cls, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
-        worldBuilder.lookupClassMember(cls, name, setter: setter);
+        elementMap.lookupClassMember(cls, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '$name' was not found in ${cls.name}.");
     }
     return member;
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    return worldBuilder._getSuperType(cls)?.element;
+    return elementMap._getSuperType(cls)?.element;
   }
 
   @override
   void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
-    worldBuilder._forEachSupertype(cls, f);
+    elementMap._forEachSupertype(cls, f);
   }
 
   @override
   void forEachMixin(ClassEntity cls, void f(ClassEntity mixin)) {
     throw new UnimplementedError('KernelElementEnvironment.forEachMixin');
   }
 
   @override
   void forEachClassMember(
       ClassEntity cls, void f(ClassEntity declarer, MemberEntity member)) {
-    worldBuilder._forEachClassMember(cls, f);
+    elementMap._forEachClassMember(cls, f);
   }
 
   @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
-        worldBuilder.lookupLibraryMember(library, name, setter: setter);
+        elementMap.lookupLibraryMember(library, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '${name}' was not found in library '${library.name}'.");
     }
     return member;
   }
 
   @override
   ClassEntity lookupClass(LibraryEntity library, String name,
       {bool required: false}) {
-    ClassEntity cls = worldBuilder.lookupClass(library, name);
+    ClassEntity cls = elementMap.lookupClass(library, name);
     if (cls == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The class '$name'  was not found in library '${library.name}'.");
     }
     return cls;
   }
 
   @override
   void forEachClass(KLibrary library, void f(ClassEntity cls)) {
-    worldBuilder._forEachClass(library, f);
+    elementMap._forEachClass(library, f);
   }
 
   @override
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
-    LibraryEntity library = worldBuilder.lookupLibrary(uri);
+    LibraryEntity library = elementMap.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
 
   @override
   CallStructure getCallStructure(KFunction function) {
-    ir.Member member = worldBuilder._memberList[function.memberIndex];
+    ir.Member member = elementMap._memberList[function.memberIndex];
     ir.FunctionNode functionNode;
     if (member is ir.Procedure) {
       functionNode = member.function;
     } else if (member is ir.Constructor) {
       functionNode = member.function;
     } else {
       throw new SpannableAssertionFailure(
           function, "Unexpected function node ${member} for $function.");
     }
     return new CallStructure(
         functionNode.positionalParameters.length +
             functionNode.namedParameters.length,
         functionNode.namedParameters.map((d) => d.name).toList());
   }
 
   @override
   bool isDeferredLoadLibraryGetter(KMember member) {
     // TODO(johnniwinther): Support these.
     return false;
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
-  final KernelWorldBuilder elementAdapter;
+  final KernelToElementMap elementAdapter;
   bool topLevel = true;
 
   DartTypeConverter(this.elementAdapter);
 
   DartType convert(ir.DartType type) {
     topLevel = true;
     return type.accept(this);
   }
 
   /// Visit a inner type.
@@ skipping 82 matching lines @@
 
   @override
   NativeData get nativeData {
     throw new UnimplementedError("KernelNativeBehaviorComputer.nativeData");
   }
 }
 
 /// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
 /// [_EvaluationEnvironment] for the evaluation.
 class KernelConstantEnvironment implements ConstantEnvironment {
-  KernelWorldBuilder _worldBuilder;
+  KernelToElementMap _worldBuilder;
   Map<ConstantExpression, ConstantValue> _valueMap =
       <ConstantExpression, ConstantValue>{};
 
   KernelConstantEnvironment(this._worldBuilder);
 
   @override
   ConstantSystem get constantSystem => const JavaScriptConstantSystem();
 
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
@@ skipping 11 matching lines @@
 
   @override
   bool hasConstantValue(ConstantExpression expression) {
     throw new UnimplementedError("KernelConstantEnvironment.hasConstantValue");
   }
 }
 
 /// Evaluation environment used for computing [ConstantValue]s for
 /// kernel based [ConstantExpression]s.
 class _EvaluationEnvironment implements Environment {
-  final KernelWorldBuilder _worldBuilder;
+  final KernelToElementMap _worldBuilder;
 
   _EvaluationEnvironment(this._worldBuilder);
 
   @override
   CommonElements get commonElements {
     throw new UnimplementedError("_EvaluationEnvironment.commonElements");
   }
 
   @override
   InterfaceType substByContext(InterfaceType base, InterfaceType target) {
@@ skipping 18 matching lines @@
     throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
   }
 
   @override
   String readFromEnvironment(String name) {
     throw new UnimplementedError("_EvaluationEnvironment.readFromEnvironment");
   }
 }
 
 class KernelResolutionWorldBuilder extends KernelResolutionWorldBuilderBase {
-  final KernelWorldBuilder worldBuilder;
+  final KernelToElementMap elementMap;
 
-  KernelResolutionWorldBuilder(
-      this.worldBuilder,
-      NativeBasicData nativeBasicData,
+  KernelResolutionWorldBuilder(this.elementMap, NativeBasicData nativeBasicData,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
-      : super(worldBuilder.elementEnvironment, worldBuilder.commonElements,
+      : super(elementMap.elementEnvironment, elementMap.commonElements,
             nativeBasicData, selectorConstraintsStrategy);
 
   @override
   Iterable<InterfaceType> getSupertypes(ClassEntity cls) {
-    return worldBuilder._getOrderedTypeSet(cls).supertypes;
+    return elementMap._getOrderedTypeSet(cls).supertypes;
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    return worldBuilder._getSuperType(cls)?.element;
+    return elementMap._getSuperType(cls)?.element;
   }
 
   @override
   bool implementsFunction(ClassEntity cls) {
     // TODO(johnniwinther): Implement this.
     return false;
   }
 
   @override
   int getHierarchyDepth(ClassEntity cls) {
-    return worldBuilder._getHierarchyDepth(cls);
+    return elementMap._getHierarchyDepth(cls);
   }
 
   @override
   ClassEntity getAppliedMixin(ClassEntity cls) {
     // TODO(johnniwinther): Implement this.
     return null;
   }
 
   @override
   bool validateClass(ClassEntity cls) => true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
-  final KernelWorldBuilder builder;
+  final KernelToElementMap builder;
 
   WorldDeconstructionForTesting(this.builder);
 
   Uri getLibraryUri(KLibrary library) {
     return builder._libraryEnvs[library.libraryIndex].library.importUri;
   }
 
   KLibrary getLibraryForClass(KClass cls) {
-    KClassEnv env = builder._classEnvs[cls.classIndex];
+    _KClassEnv env = builder._classEnvs[cls.classIndex];
     return builder.getLibrary(env.cls.enclosingLibrary);
   }
 
   KLibrary _getLibrary<E>(E member, Map<ir.Member, E> map) {
     ir.Library library;
     map.forEach((ir.Member node, E other) {
       if (library == null && member == other) {
         library = node.enclosingLibrary;
       }
     });
     if (library == null) {
       throw new ArgumentError("No library found for $member");
     }
     return builder._getLibrary(library);
   }
 
   KLibrary getLibraryForFunction(KFunction function) =>
       _getLibrary(function, builder._methodMap);
 
   KLibrary getLibraryForField(KField field) =>
       _getLibrary(field, builder._fieldMap);
 
   KClass getSuperclassForClass(KClass cls) {
-    KClassEnv env = builder._classEnvs[cls.classIndex];
+    _KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype supertype = env.cls.supertype;
     if (supertype == null) return null;
     return builder.getClass(supertype.classNode);
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
-    KClassEnv env = builder._classEnvs[cls.classIndex];
+    _KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }