Rename KernelWorldBuilder to KernelElementBuilder

pkg/compiler/lib/src/kernel/element_builder.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_builder;
 
 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';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/native_data.dart' show NativeData;
 import '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/call_structure.dart';
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.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 KernelElementBuilder extends KernelElementAdapterMixin {

[Siggi Cherem (dart-lang), 2017/04/20 22:39:39]

as we discuss in the meeting, I think we can drop "builder", ideas:
 - KernelElements
 - KernelToElementMap
 

[Johnni Winther, 2017/04/24 15:24:01]

Changed to KernelToElementMap

   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
 
   /// 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) {
+  KernelElementBuilder(this.reporter, ir.Program program)
+      : _env = new _KEnv(program) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     ConstantEnvironment constants = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
         new KernelBehaviorBuilder(_commonElements, constants);
     _typeConverter = new DartTypeConverter(this);
   }
 
   KMethod get _mainFunction {
     return _env.program.mainMethod != null
@@ skipping 10 matching lines @@
   @override
   CommonElements get commonElements => _commonElements;
 
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
   @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;
   }
 
   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 179 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.supertypes == null) {
       _ensureThisAndRawType(cls, env);
 
       ir.Class node = env.cls;
 
       Set<InterfaceType> supertypes = new Set<InterfaceType>();
 
       InterfaceType addSupertype(ir.Supertype node) {
         if (node == null) return null;
         InterfaceType type = _typeConverter.visitSupertype(node);
         KClass superclass = type.element;
-        KClassEnv env = _classEnvs[superclass.classIndex];
+        _KClassEnv env = _classEnvs[superclass.classIndex];
         _ensureSupertypes(superclass, env);
         for (InterfaceType supertype in env.supertypes) {
           supertypes.add(
               supertype.subst(type.typeArguments, env.thisType.typeArguments));
         }
         return type;
       }
 
       env.supertype = addSupertype(node.supertype);
       addSupertype(node.mixedInType);
       node.implementedTypes.forEach(addSupertype);
 
       env.supertypes = supertypes.toList();
     }
   }
 
   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.supertypes.forEach(f);
   }
 
   @override
   FunctionType getFunctionType(ir.FunctionNode node) {
     DartType returnType = getDartType(node.returnType);
     List<DartType> parameterTypes = /*<DartType>*/ [];
     List<DartType> optionalParameterTypes = /*<DartType>*/ [];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
@@ skipping 82 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);
 
-  /// 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) {
     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 _libraryMap[uri];
   }
 }
 
 /// 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;
 
-  KLibraryEnv(this.library);
+  _KLibraryEnv(this.library);
 
-  /// 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) {
     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 _classMap[name];
   }
 
   /// 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>{};
       for (ir.Member member in library.members) {
         // TODO(johnniwinther): Support setter vs. getter.
         _memberMap[member.name.name] = 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;
   List<InterfaceType> supertypes;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
 
-  KClassEnv(this.cls);
+  _KClassEnv(this.cls);
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
       for (ir.Member member in cls.members) {
         if (member is ir.Procedure && member.kind == ir.ProcedureKind.Factory) {
           _constructorMap[member.name.name] = member;
         } else {
           // TODO(johnniwinther): Support setter vs. getter.
@@ skipping 13 matching lines @@
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupConstructor(String name, {bool setter: false}) {
     _ensureMaps();
     return _constructorMap[name];
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
-  final KernelWorldBuilder worldBuilder;
+  final KernelElementBuilder elementBuilder;
 
-  KernelElementEnvironment(this.worldBuilder);
+  KernelElementEnvironment(this.elementBuilder);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
-  LibraryEntity get mainLibrary => worldBuilder._mainLibrary;
+  LibraryEntity get mainLibrary => elementBuilder._mainLibrary;
 
   @override
-  FunctionEntity get mainFunction => worldBuilder._mainFunction;
+  FunctionEntity get mainFunction => elementBuilder._mainFunction;
 
   @override
-  Iterable<LibraryEntity> get libraries => worldBuilder._libraryMap.values;
+  Iterable<LibraryEntity> get libraries => elementBuilder._libraryMap.values;
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
-    return worldBuilder._getThisType(cls);
+    return elementBuilder._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
-    return worldBuilder._getRawType(cls);
+    return elementBuilder._getRawType(cls);
   }
 
   @override
   DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
     throw new UnimplementedError(
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
   @override
   InterfaceType createInterfaceType(
@@ skipping 16 matching lines @@
   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 = elementBuilder.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);
+        elementBuilder.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 elementBuilder._getSuperType(cls)?.element;
   }
 
   @override
   void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
-    worldBuilder._forEachSupertype(cls, f);
+    elementBuilder._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)) {
     // TODO(johnniwinther): Implement this.
   }
 
   @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
-        worldBuilder.lookupLibraryMember(library, name, setter: setter);
+        elementBuilder.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 = elementBuilder.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
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
-    LibraryEntity library = worldBuilder.lookupLibrary(uri);
+    LibraryEntity library = elementBuilder.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 = elementBuilder._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 KernelElementBuilder 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;
+  KernelElementBuilder _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 KernelElementBuilder _worldBuilder;
 
   _EvaluationEnvironment(this._worldBuilder);
 
   @override
   CommonElements get commonElements {
     throw new UnimplementedError("_EvaluationEnvironment.commonElements");
   }
 
   @override
   InterfaceType substByContext(InterfaceType base, InterfaceType target) {
@@ skipping 19 matching lines @@
   }
 
   @override
   String readFromEnvironment(String name) {
     throw new UnimplementedError("_EvaluationEnvironment.readFromEnvironment");
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
-  final KernelWorldBuilder builder;
+  final KernelElementBuilder 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);
   }
 }