Use index in J/KTypeVariable and fix remaining inequivalence

pkg/compiler/lib/src/js_model/elements.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.js_model.elements;
 
 import '../common_elements.dart';
 import '../constants/constant_system.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
@@ skipping 43 matching lines @@
   }
 
   Entity _toFrontendEntity(Entity entity) {
     if (entity is ClassEntity) return toFrontendClass(entity);
     assert(entity is TypeVariableEntity);
     TypeVariableEntity typeVariable = toFrontendTypeVariable(entity);
     assert(typeVariable != null, "No front end type variable for $entity");
     return typeVariable;
   }
 
-  final Map<TypeVariableEntity, TypeVariableEntity> _toBackendTypeVariableMap =
-      <TypeVariableEntity, TypeVariableEntity>{};
-
-  final Map<TypeVariableEntity, TypeVariableEntity> _toFrontendTypeVariableMap =
-      <TypeVariableEntity, TypeVariableEntity>{};
-
-  TypeVariableEntity toBackendTypeVariable(TypeVariableEntity typeVariable) {
-    return _toBackendTypeVariableMap.putIfAbsent(typeVariable, () {
-      Entity typeDeclaration;
-      if (typeVariable.typeDeclaration is ClassEntity) {
-        typeDeclaration = toBackendClass(typeVariable.typeDeclaration);
-      } else {
-        typeDeclaration = toBackendMember(typeVariable.typeDeclaration);
-      }
-      TypeVariableEntity newTypeVariable =
-          createTypeVariable(typeDeclaration, typeVariable);
-      _toFrontendTypeVariableMap[newTypeVariable] = typeVariable;
-      return newTypeVariable;
-    });
-  }
-
-  TypeVariableEntity toFrontendTypeVariable(TypeVariableEntity typeVariable) {
-    return _toFrontendTypeVariableMap[typeVariable];
-  }
-
-  TypeVariableEntity createTypeVariable(
-      Entity typeDeclaration, TypeVariableEntity typeVariable) {
-    return new JTypeVariable(
-        typeDeclaration, typeVariable.name, typeVariable.index);
-  }
+  TypeVariableEntity toBackendTypeVariable(TypeVariableEntity typeVariable);
+  TypeVariableEntity toFrontendTypeVariable(TypeVariableEntity typeVariable);
 }
 
 class JsElementCreatorMixin {
   IndexedLibrary createLibrary(
       int libraryIndex, String name, Uri canonicalUri) {
     return new JLibrary(libraryIndex, name, canonicalUri);
   }
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract}) {
     return new JClass(library, classIndex, name, isAbstract: isAbstract);
   }
 
   TypeVariableEntity createTypeVariable(
-      Entity typeDeclaration, String name, int index) {
-    return new JTypeVariable(typeDeclaration, name, index);
+      int typeVariableIndex, Entity typeDeclaration, String name, int index) {
+    return new JTypeVariable(typeVariableIndex, typeDeclaration, name, index);
   }
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
       {bool isExternal,
       bool isConst}) {
     return new JGenerativeConstructor(
@@ skipping 380 matching lines @@
       {bool isStatic, this.isAssignable, this.isConst})
       : super(memberIndex, library, enclosingClass, name, isStatic: isStatic);
 
   @override
   bool get isField => true;
 
   String get _kind => 'field';
 }
 
 class JTypeVariable implements TypeVariableEntity, IndexedTypeVariable {
+  final int typeVariableIndex;
   final Entity typeDeclaration;
   final String name;
   final int index;
 
-  JTypeVariable(this.typeDeclaration, this.name, this.index);
+  JTypeVariable(
+      this.typeVariableIndex, this.typeDeclaration, this.name, this.index);
 
   String toString() =>
       '${jsElementPrefix}type_variable(${typeDeclaration.name}.$name)';
 }
 
 class JsClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
   final JsKernelToElementMap elementMap;
 
   JsClosedWorld(this.elementMap,
       {ElementEnvironment elementEnvironment,
@@ skipping 195 matching lines @@
 
   @override
   bool get isFunctionApplyUsed => _backendUsage.isFunctionApplyUsed;
 
   @override
   bool get isMirrorsUsed => _backendUsage.isMirrorsUsed;
 
   @override
   bool get isNoSuchMethodUsed => _backendUsage.isNoSuchMethodUsed;
 }