Convert data objects eagerly from K to J

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 1674 matching lines @@
 
   @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);
+  JsToFrontendMapImpl(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];
-  }
-
   TypeVariableEntity toBackendTypeVariable(
       covariant IndexedTypeVariable typeVariable) {
     return _backend._typeVariableList[typeVariable.typeVariableIndex];
   }
-
-  TypeVariableEntity toFrontendTypeVariable(
-      covariant IndexedTypeVariable typeVariable) {
-    return _frontend._typeVariableList[typeVariable.typeVariableIndex];
-  }
 }
 
 class JsKernelToElementMap extends KernelToElementMapBase
     with
         KernelToElementMapForBuildingMixin,
         JsElementCreatorMixin,
         // TODO(johnniwinther): Avoid mixin in [ElementCreatorMixin]. The
         // codegen world should be a strict subset of the resolution world and
         // creating elements for IR nodes should therefore not be needed.
         // Currently some are created purely for testing (like
         // `element == commonElements.foo`, where 'foo' might not be live).
         // Others are created because we do a
         // `elementEnvironment.forEachLibraryMember(...)` call on each emitted
         // library.
         ElementCreatorMixin
     implements
         KernelToWorldBuilder {
-  JsToFrontendMap _jsToFrontendMap;
-
   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];
       LibraryEntity newLibrary = convertLibrary(oldLibrary);
       _libraryMap[env.library] = newLibrary;
       _libraryList.add(newLibrary);
       _libraryEnvs.add(env);
@@ skipping 54 matching lines @@
 
   @override
   bool checkFamily(Entity entity) {
     assert(
         '$entity'.startsWith(jsElementPrefix),
         failedAt(entity,
             "Unexpected entity $entity, expected family $jsElementPrefix."));
     return true;
   }
 
-  JsToFrontendMap get jsToFrontendMap => _jsToFrontendMap;
-
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
   }
 
   Iterable<LibraryEntity> get _libraries {
     return _libraryMap.values;
   }
 
   @override
@@ skipping 102 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }