Implement JsKernelToElementMap through KernelToElementMapBase

pkg/compiler/lib/src/kernel/element_map_impl.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.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 54 matching lines @@
   final DiagnosticReporter reporter;
   CommonElements _commonElements;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
   KernelConstantEnvironment _constantEnvironment;
   _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
   ProgramEnv _env = new ProgramEnv();
 
+  List<LibraryEntity> _libraryList = <LibraryEntity>[];
+  List<ClassEntity> _classList = <ClassEntity>[];
+  List<MemberEntity> _memberList = <MemberEntity>[];
+
   /// List of library environments by `IndexedLibrary.libraryIndex`. This is
   /// used for fast lookup into library classes and members.
   List<LibraryEnv> _libraryEnvs = <LibraryEnv>[];
 
   /// List of class environments by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<ClassEnv> _classEnvs = <ClassEnv>[];
 
-  /// List of member data by `IndexedMember.classIndex`. This is used for
+  /// List of member data by `IndexedMember.memberIndex`. This is used for
   /// fast lookup into member properties.
-  List<MemberData> _memberList = <MemberData>[];
+  List<MemberData> _memberData = <MemberData>[];
 
   KernelToElementMapBase(this.reporter, Environment environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this, environment);
     _typeConverter = new DartTypeConverter(this);
     _types = new _KernelDartTypes(this);
   }
 
   DartTypes get types => _types;
@@ skipping 15 matching lines @@
   }
 
   Iterable<LibraryEntity> get _libraries;
 
   LibraryEntity lookupLibrary(Uri uri) {
     LibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
-  String _getLibraryName(KLibrary library) {
+  String _getLibraryName(IndexedLibrary library) {
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     return libraryEnv.library.name ?? '';
   }
 
-  MemberEntity lookupLibraryMember(KLibrary library, String name,
+  MemberEntity lookupLibraryMember(IndexedLibrary library, String name,
       {bool setter: false}) {
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
-  void _forEachLibraryMember(KLibrary library, void f(MemberEntity member)) {
+  void _forEachLibraryMember(
+      IndexedLibrary library, void f(MemberEntity member)) {
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     libraryEnv.forEachMember((ir.Member node) {
       f(getMember(node));
     });
   }
 
-  ClassEntity lookupClass(KLibrary library, String name) {
+  ClassEntity lookupClass(IndexedLibrary library, String name) {
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
-  void _forEachClass(KLibrary library, void f(ClassEntity cls)) {
+  void _forEachClass(IndexedLibrary library, void f(ClassEntity cls)) {
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     libraryEnv.forEachClass((ClassEnv classEnv) {
       if (!classEnv.isUnnamedMixinApplication) {
         f(_getClass(classEnv.cls, classEnv));
       }
     });
   }
 
   MemberEntity lookupClassMember(IndexedClass cls, String name,
       {bool setter: false}) {
@@ skipping 231 matching lines @@
     _ensureThisAndRawType(cls, env);
     return env.thisType;
   }
 
   InterfaceType _getRawType(IndexedClass cls) {
     ClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.rawType;
   }
 
-  FunctionType _getFunctionType(IndexedMember function) {
-    FunctionData data = _memberList[function.memberIndex];
+  FunctionType _getFunctionType(IndexedFunction function) {
+    FunctionData data = _memberData[function.memberIndex];
     return data.getFunctionType(this);
   }
 
   ClassEntity _getAppliedMixin(IndexedClass cls) {
     ClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.mixedInType?.element;
   }
 
   bool _isMixinApplication(IndexedClass cls) {
@@ skipping 38 matching lines @@
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     _ensureSupertypes(cls, env);
     if (env.supertype != null) {
       _forEachClassMember(env.supertype.element, f);
     }
   }
 
   ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
-    ConstructorData data = _memberList[constructor.memberIndex];
+    ConstructorData data = _memberData[constructor.memberIndex];
     return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(IndexedField field) {
-    FieldData data = _memberList[field.memberIndex];
+    FieldData data = _memberData[field.memberIndex];
     return data.getFieldConstant(this, field);
   }
 
   InterfaceType _asInstanceOf(InterfaceType type, ClassEntity cls) {
     OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
     InterfaceType supertype =
         orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
     if (supertype != null) {
       supertype = _substByContext(supertype, type);
     }
@@ skipping 16 matching lines @@
     ClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
   ir.Member _getMemberNode(covariant IndexedMember member) {
-    return _memberList[member.memberIndex].node;
+    return _memberData[member.memberIndex].node;
   }
 
   ir.Class _getClassNode(covariant IndexedClass cls) {
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase] by
 /// creating K-model elements.
 abstract class KElementCreatorMixin {
   ProgramEnv get _env;
+  List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
+  List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
-  List<MemberData> get _memberList;
+  List<MemberEntity> get _memberList;
+  List<MemberData> get _memberData;
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
@@ skipping 15 matching lines @@
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv 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);
+      LibraryEntity library =
+          new KLibrary(_libraryMap.length, name, canonicalUri);
+      _libraryList.add(library);
+      return library;
     });
   }
 
   ClassEntity _getClass(ir.Class node, [ClassEnv 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,
+      ClassEntity cls = new KClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
+      _classList.add(cls);
+      return cls;
     });
   }
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         return new KTypeVariable(_getClass(cls), node.name, index);
       }
@@ skipping 14 matching lines @@
             return new KTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   ConstructorEntity _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
-      int memberIndex = _memberList.length;
+      int memberIndex = _memberData.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
 
       ir.FunctionNode functionNode;
       if (node is ir.Constructor) {
         functionNode = node.function;
         constructor = new KGenerativeConstructor(memberIndex, enclosingClass,
             name, _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
       } else if (node is ir.Procedure) {
         functionNode = node.function;
         bool isFromEnvironment = isExternal &&
             name.text == 'fromEnvironment' &&
             const ['int', 'bool', 'String'].contains(enclosingClass.name);
         constructor = new KFactoryConstructor(memberIndex, enclosingClass, name,
             _getParameterStructure(functionNode),
             isExternal: isExternal,
             isConst: node.isConst,
             isFromEnvironmentConstructor: isFromEnvironment);
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
-      _memberList.add(new ConstructorData(node, functionNode));
+      _memberData.add(new ConstructorData(node, functionNode));
+      _memberList.add(constructor);
       return constructor;
     });
   }
 
   FunctionEntity _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
-      int memberIndex = _memberList.length;
+      int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
       }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
@@ skipping 38 matching lines @@
           break;
         case ir.ProcedureKind.Setter:
           assert(asyncMarker == AsyncMarker.SYNC);
           function = new KSetter(
               memberIndex, library, enclosingClass, getName(node.name).setter,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
       }
-      _memberList.add(new FunctionData(node, node.function));
+      _memberData.add(new FunctionData(node, node.function));
+      _memberList.add(function);
       return function;
     });
   }
 
   FieldEntity _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
-      int memberIndex = _memberList.length;
+      int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
       }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
-      _memberList.add(new FieldData(node));
-      return new KField(memberIndex, library, enclosingClass, name,
+      _memberData.add(new FieldData(node));
+      FieldEntity field = new KField(memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
+      _memberList.add(field);
+      return field;
     });
   }
 
   ParameterStructure _getParameterStructure(ir.FunctionNode node) {
     // TODO(johnniwinther): Cache the computed function type.
     int requiredParameters = node.requiredParameterCount;
     int positionalParameters = node.positionalParameters.length;
     List<String> namedParameters =
         node.namedParameters.map((p) => p.name).toList()..sort();
     return new ParameterStructure(
@@ skipping 50 matching lines @@
   /// compilation.
   void addProgram(ir.Program program) {
     _env.addProgram(program);
   }
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder =>
       _nativeBehaviorBuilder ??= new KernelBehaviorBuilder(commonElements);
 
   ResolutionImpact computeWorldImpact(KMember member) {
-    return _memberList[member.memberIndex].getWorldImpact(this);
+    return _memberData[member.memberIndex].getWorldImpact(this);
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
-    return _memberList[method.memberIndex].node;
+    return _memberData[method.memberIndex].node;
   }
 
   Iterable<ConstantValue> _getClassMetadata(KClass cls) {
     return _classEnvs[cls.classIndex].getMetadata(this);
   }
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 // TODO(johnniwinther): Merge this with [KernelToElementMapForImpactImpl] when
@@ skipping 26 matching lines @@
     return getConstantValue(field.initializer,
         requireConstant: field.isConst, implicitNull: !field.isConst);
   }
 
   ir.Library getKernelLibrary(KLibrary entity) =>
       _libraryEnvs[entity.libraryIndex].library;
 
   ir.Class getKernelClass(KClass entity) => _classEnvs[entity.classIndex].cls;
 
   bool hasConstantFieldInitializer(covariant KField field) {
-    FieldData data = _memberList[field.memberIndex];
+    FieldData data = _memberData[field.memberIndex];
     return getFieldConstantValue(data.node) != null;
   }
 
   ConstantValue getConstantFieldInitializer(covariant KField field) {
-    FieldData data = _memberList[field.memberIndex];
+    FieldData data = _memberData[field.memberIndex];
     ConstantValue value = getFieldConstantValue(data.node);
     assert(value != null,
         failedAt(field, "Field $field doesn't have a constant initial value."));
     return value;
   }
 
   void forEachParameter(covariant KFunction function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
-    FunctionData data = _memberList[function.memberIndex];
+    FunctionData data = _memberData[function.memberIndex];
     data.forEachParameter(this, f);
   }
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
   }
 
   @override
   ir.Member getMemberNode(MemberEntity member) {
@@ skipping 81 matching lines @@
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
   @override
   InterfaceType createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
-  FunctionType getFunctionType(covariant KFunction function) {
+  FunctionType getFunctionType(FunctionEntity function) {
     return elementMap._getFunctionType(function);
   }
 
   @override
   FunctionType getLocalFunctionType(covariant KLocalFunction function) {
     return function.functionType;
   }
 
   @override
   DartType getUnaliasedType(DartType type) => type;
@@ skipping 103 matching lines @@
   }
 
   @override
   bool isDeferredLoadLibraryGetter(covariant KMember member) {
     // TODO(redemption): Support these.
     return false;
   }
 
   @override
   Iterable<ConstantValue> getMemberMetadata(covariant KMember member) {
-    MemberData memberData = elementMap._memberList[member.memberIndex];
+    MemberData memberData = elementMap._memberData[member.memberIndex];
     return memberData.getMetadata(elementMap);
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelToElementMapBase elementMap;
   bool topLevel = true;
 
   DartTypeConverter(this.elementMap);
@@ skipping 351 matching lines @@
 
   @override
   ElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
 
   @override
   CommonElements get commonElements => elementMap.commonElements;
 
   @override
   native.NativeBehavior computeNativeFieldStoreBehavior(
       covariant KField field) {
-    ir.Field node = elementMap._memberList[field.memberIndex].node;
+    ir.Field node = elementMap._memberData[field.memberIndex].node;
     return elementMap.getNativeBehaviorForFieldStore(node);
   }
 
   @override
   native.NativeBehavior computeNativeFieldLoadBehavior(covariant KField field,
       {bool isJsInterop}) {
-    ir.Field node = elementMap._memberList[field.memberIndex].node;
+    ir.Field node = elementMap._memberData[field.memberIndex].node;
     return elementMap.getNativeBehaviorForFieldLoad(node,
         isJsInterop: isJsInterop);
   }
 
   @override
   native.NativeBehavior computeNativeMethodBehavior(
       covariant KFunction function,
       {bool isJsInterop}) {
-    ir.Member node = elementMap._memberList[function.memberIndex].node;
+    ir.Member node = elementMap._memberData[function.memberIndex].node;
     return elementMap.getNativeBehaviorForMethod(node,
         isJsInterop: isJsInterop);
   }
 
   @override
   bool isNativeMethod(covariant KFunction function) {
     if (!native.maybeEnableNative(function.library.canonicalUri)) return false;
-    ir.Member node = elementMap._memberList[function.memberIndex].node;
+    ir.Member node = elementMap._memberData[function.memberIndex].node;
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(redemption): Compute this.
     return false;
   }
 }
 
+class JsToFrontendMapImpl extends JsToFrontendMapBase
+    implements JsToFrontendMap {
+  final KernelToElementMapBase _frontend;
+  final KernelToElementMapBase _backend;
+
+  JsToFrontendMapImpl(this._frontend, this._backend);
+
+  LibraryEntity toBackendLibrary(covariant IndexedLibrary library) {
+    return _backend._libraryList[library.libraryIndex];
+  }
+
+  LibraryEntity toFrontendLibrary(covariant IndexedLibrary library) {
+    return _frontend._libraryList[library.libraryIndex];
+  }
+
+  ClassEntity toBackendClass(covariant IndexedClass cls) {
+    return _backend._classList[cls.classIndex];
+  }
+
+  ClassEntity toFrontendClass(covariant IndexedClass cls) {
+    return _frontend._classList[cls.classIndex];
+  }
+
+  MemberEntity toBackendMember(covariant IndexedMember member) {
+    return _backend._memberList[member.memberIndex];
+  }
+
+  MemberEntity toFrontendMember(covariant IndexedMember member) {
+    return _frontend._memberList[member.memberIndex];
+  }
+}
+
 class JsKernelToElementMap extends KernelToElementMapBase
-    with KernelToElementMapForBuildingMixin
+    with KernelToElementMapForBuildingMixin, JsElementCreatorMixin
     implements KernelToWorldBuilder {
-  final JsToFrontendMap _map;
-  final ElementEnvironment _elementEnvironment;
-  final CommonElements _commonElements;
-  final KernelToElementMapForImpactImpl _elementMap;
+  JsToFrontendMap _jsToFrontendMap;
 
-  JsKernelToElementMap(
-      DiagnosticReporter reporter,
-      Environment environment,
-      this._map,
-      this._elementEnvironment,
-      this._commonElements,
-      this._elementMap)
-      : super(reporter, environment);
+  Map<ir.Library, JLibrary> _libraryMap = <ir.Library, JLibrary>{};
+  Map<ir.Class, JClass> _classMap = <ir.Class, JClass>{};
+  Map<ir.TypeParameter, JTypeVariable> _typeVariableMap =
+      <ir.TypeParameter, JTypeVariable>{};
+  Map<ir.Member, JConstructor> _constructorMap = <ir.Member, JConstructor>{};
+  Map<ir.Procedure, JFunction> _methodMap = <ir.Procedure, JFunction>{};
+  Map<ir.Field, JField> _fieldMap = <ir.Field, JField>{};
+
+  JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
+      KernelToElementMapForImpactImpl _elementMap)
+      : super(reporter, environment) {
+    _jsToFrontendMap = new JsToFrontendMapImpl(_elementMap, this);
+    _env = _elementMap._env;
+    for (int libraryIndex = 0;
+        libraryIndex < _elementMap._libraryEnvs.length;
+        libraryIndex++) {
+      LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
+      LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
+      JLibrary newLibrary = createLibrary(oldLibrary);
+      _libraryMap[env.library] = newLibrary;
+      _libraryList.add(newLibrary);
+      _libraryEnvs.add(env);
+    }
+    for (int classIndex = 0;
+        classIndex < _elementMap._classEnvs.length;
+        classIndex++) {
+      ClassEnv env = _elementMap._classEnvs[classIndex];
+      ClassEntity oldClass = _elementMap._classList[classIndex];
+      IndexedLibrary oldLibrary = oldClass.library;
+      JLibrary newLibrary = _libraryList[oldLibrary.libraryIndex];
+      JClass newClass = createClass(newLibrary, oldClass);
+      _classMap[env.cls] = newClass;
+      _classList.add(newClass);
+      _classEnvs.add(env);
+    }
+    for (int memberIndex = 0;
+        memberIndex < _elementMap._memberData.length;
+        memberIndex++) {
+      MemberData data = _elementMap._memberData[memberIndex];
+      MemberEntity oldMember = _elementMap._memberList[memberIndex];
+      IndexedLibrary oldLibrary = oldMember.library;
+      IndexedClass oldClass = oldMember.enclosingClass;
+      JLibrary newLibrary = _libraryList[oldLibrary.libraryIndex];
+      JClass newClass =
+          oldClass != null ? _classList[oldClass.classIndex] : null;
+      JMember newMember = createMember(newLibrary, newClass, oldMember);
+      _memberList.add(newMember);
+      _memberData.add(data);
+      if (newMember.isField) {
+        _fieldMap[data.node] = newMember;
+      } else if (newMember.isConstructor) {
+        _constructorMap[data.node] = newMember;
+      } else {
+        _methodMap[data.node] = newMember;
+      }
+    }
+  }
+
+  JsToFrontendMap get jsToFrontendMap => _jsToFrontendMap;
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
-    return _elementMap._getSpannable(_map.toFrontendMember(member), node);
+    return _getSpannable(member, node);
   }
 
   Iterable<LibraryEntity> get _libraries {
-    return _elementMap._libraries.map(_map.toBackendLibrary);
+    return _libraryMap.values;
   }
 
   @override
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv env]) {
-    return _map.toBackendLibrary(_elementMap.getLibrary(node));
+    LibraryEntity library = _libraryMap[node];
+    assert(library != null, "No library entity for $node");
+    return library;
   }
 
   @override
   Local _getLocalFunction(ir.TreeNode node) {
     throw new UnsupportedError("JsKernelToElementMap.getLocalFunction");
   }
 
   @override
   ClassEntity _getClass(ir.Class node, [ClassEnv env]) {
-    return _map.toBackendClass(_elementMap.getClass(node));
+    ClassEntity cls = _classMap[node];
+    assert(cls != null, "No class entity for $node");
+    return cls;
   }
 
   @override
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     throw new UnsupportedError("JsKernelToElementMap._getTypeVariable");
   }
 
   @override
   FieldEntity _getField(ir.Field node) {
-    return _map.toBackendMember(_elementMap.getField(node));
+    FieldEntity field = _fieldMap[node];
+    assert(field != null, "No field entity for $node");
+    return field;
   }
 
   @override
   FunctionEntity _getMethod(ir.Procedure node) {
-    return _map.toBackendMember(_elementMap.getMethod(node));
+    FunctionEntity function = _methodMap[node];
+    assert(function != null, "No function entity for $node");
+    return function;
   }
 
   @override
   ConstructorEntity _getConstructor(ir.Member node) {
-    return _map.toBackendMember(_elementMap.getConstructor(node));
+    ConstructorEntity constructor = _constructorMap[node];
+    assert(constructor != null, "No constructor entity for $node");
+    return constructor;
   }
 
   @override
   ir.Member getMemberNode(MemberEntity member) {
-    return _elementMap._getMemberNode(_map.toFrontendMember(member));
+    return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
-    return _elementMap._getClassNode(_map.toFrontendClass(cls));
+    return _getClassNode(cls);
   }
 
   @override
-  InterfaceType createInterfaceType(
-      ir.Class cls, List<ir.DartType> typeArguments) {
-    return _map
-        .toBackendType(_elementMap.createInterfaceType(cls, typeArguments));
-  }
-
-  @override
-  InterfaceType getInterfaceType(ir.InterfaceType type) {
-    return _map.toBackendType(_elementMap.getInterfaceType(type));
-  }
-
-  @override
-  List<DartType> getDartTypes(List<ir.DartType> types) {
-    return _elementMap.getDartTypes(types).map(_map.toBackendType).toList();
-  }
-
-  @override
-  FunctionType getFunctionType(ir.FunctionNode node) {
-    return _map.toBackendType(_elementMap.getFunctionType(node));
-  }
-
-  @override
-  DartType getDartType(ir.DartType type) {
-    return _map.toBackendType(_elementMap.getDartType(type));
-  }
-
-  @override
-  ElementEnvironment get elementEnvironment {
-    return _elementEnvironment;
-  }
-
-  @override
-  CommonElements get commonElements {
-    return _commonElements;
-  }
-
-  @override
-  ConstantValue computeConstantValue(ConstantExpression constant,
-      {bool requireConstant: true}) {
-    throw new UnsupportedError("JsKernelToElementMap.computeConstantValue");
-  }
-
-  @override
-  DiagnosticReporter get reporter {
-    return _elementMap.reporter;
-  }
-
-  @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     throw new UnsupportedError("JsKernelToElementMap.getFieldConstantValue");
   }
 
   @override
   void forEachParameter(FunctionEntity function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     throw new UnsupportedError("JsKernelToElementMap.forEachParameter");
   }
 
   @override
   ConstantValue getConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }