Use index in J/KTypeVariable and fix remaining inequivalence

pkg/compiler/lib/src/kernel/element_map_impl.dart

Index: pkg/compiler/lib/src/kernel/element_map_impl.dart
diff --git a/pkg/compiler/lib/src/kernel/element_map_impl.dart b/pkg/compiler/lib/src/kernel/element_map_impl.dart
index 48e80a593e697554a8f0d530f17410e2c536e657..33080a3801822d79ff58cdc0e61a49a84e77273b 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -74,6 +74,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   List<LibraryEntity> _libraryList = <LibraryEntity>[];
   List<ClassEntity> _classList = <ClassEntity>[];
   List<MemberEntity> _memberList = <MemberEntity>[];
+  List<TypeVariableEntity> _typeVariableList = <TypeVariableEntity>[];
 
   /// List of library environments by `IndexedLibrary.libraryIndex`. This is
   /// used for fast lookup into library classes and members.
@@ -527,11 +528,12 @@ abstract class ElementCreatorMixin {
   List<ClassData> get _classData;
   List<MemberEntity> get _memberList;
   List<MemberData> get _memberData;
+  List<TypeVariableEntity> get _typeVariableList;
 
   Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
   Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
-  Map<ir.TypeParameter, TypeVariableEntity> _typeVariableMap =
-      <ir.TypeParameter, TypeVariableEntity>{};
+  Map<ir.TypeParameter, IndexedTypeVariable> _typeVariableMap =
+      <ir.TypeParameter, IndexedTypeVariable>{};
   Map<ir.Member, IndexedConstructor> _constructorMap =
       <ir.Member, IndexedConstructor>{};
   Map<ir.Procedure, IndexedFunction> _methodMap =
@@ -588,9 +590,13 @@ abstract class ElementCreatorMixin {
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
+        int typeVariableIndex = _typeVariableList.length;
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
-        return createTypeVariable(_getClass(cls), node.name, index);
+        TypeVariableEntity typeVariable = createTypeVariable(
+            typeVariableIndex, _getClass(cls), node.name, index);
+        _typeVariableList.add(typeVariable);
+        return typeVariable;
       }
       if (node.parent is ir.FunctionNode) {
         ir.FunctionNode func = node.parent;
@@ -606,7 +612,11 @@ abstract class ElementCreatorMixin {
             ir.Class cls = procedure.enclosingClass;
             return _getTypeVariable(cls.typeParameters[index]);
           } else {
-            return createTypeVariable(_getMethod(procedure), node.name, index);
+            int typeVariableIndex = _typeVariableList.length;
+            TypeVariableEntity typeVariable = createTypeVariable(
+                typeVariableIndex, _getMethod(procedure), node.name, index);
+            _typeVariableList.add(typeVariable);
+            return typeVariable;
           }
         }
       }
@@ -788,7 +798,7 @@ abstract class ElementCreatorMixin {
       {bool isAbstract});
 
   TypeVariableEntity createTypeVariable(
-      Entity typeDeclaration, String name, int index);
+      int typeVariableIndex, Entity typeDeclaration, String name, int index);
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
@@ -846,8 +856,8 @@ abstract class KElementCreatorMixin implements ElementCreatorMixin {
   }
 
   TypeVariableEntity createTypeVariable(
-      Entity typeDeclaration, String name, int index) {
-    return new KTypeVariable(typeDeclaration, name, index);
+      int typeVariableIndex, Entity typeDeclaration, String name, int index) {
+    return new KTypeVariable(typeVariableIndex, typeDeclaration, name, index);
   }
 
   IndexedConstructor createGenerativeConstructor(
@@ -1688,6 +1698,16 @@ class JsToFrontendMapImpl extends JsToFrontendMapBase
   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
@@ -1758,6 +1778,9 @@ class JsKernelToElementMap extends KernelToElementMapBase
         _methodMap[data.node] = newMember;
       }
     }
+    for (int typeVariableIndex = 0;
+        typeVariableIndex < _elementMap._typeVariableList.length;
+        typeVariableIndex++) {}

[Siggi Cherem (dart-lang), 2017/07/05 21:35:37]

missing body? don't we need to convert the type variables?

[Johnni Winther, 2017/07/06 15:05:46]

Apparently not! Added.

   }
 
   JsToFrontendMap get jsToFrontendMap => _jsToFrontendMap;