Use index in J/KTypeVariable and fix remaining inequivalence

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 56 matching lines @@
   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<TypeVariableEntity> _typeVariableList = <TypeVariableEntity>[];
 
   /// 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 class data by `IndexedClass.classIndex`. This is used for
@@ skipping 433 matching lines @@
 /// creating K-model elements.
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
   List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
   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 =
       <ir.Procedure, IndexedFunction>{};
   Map<ir.Field, IndexedField> _fieldMap = <ir.Field, IndexedField>{};
   Map<ir.TreeNode, Local> _localFunctionMap = <ir.TreeNode, Local>{};
 
   Name getName(ir.Name node);
   FunctionType getFunctionType(ir.FunctionNode node);
   MemberEntity getMember(ir.Member node);
@@ skipping 36 matching lines @@
       ClassEntity cls = createClass(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) {
+        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;
         int index = func.typeParameters.indexOf(node);
         if (func.parent is ir.Constructor) {
           ir.Constructor constructor = func.parent;
           ir.Class cls = constructor.enclosingClass;
           return _getTypeVariable(cls.typeParameters[index]);
         }
         if (func.parent is ir.Procedure) {
           ir.Procedure procedure = func.parent;
           if (procedure.kind == ir.ProcedureKind.Factory) {
             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;
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   ConstructorEntity _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
@@ skipping 161 matching lines @@
           name, memberContext, executableContext, functionType);
     });
   }
 
   IndexedLibrary createLibrary(int libraryIndex, String name, Uri canonicalUri);
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract});
 
   TypeVariableEntity createTypeVariable(
-      Entity typeDeclaration, String name, int index);
+      int typeVariableIndex, Entity typeDeclaration, String name, int index);
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
       {bool isExternal,
       bool isConst});
 
   IndexedConstructor createFactoryConstructor(
@@ skipping 37 matching lines @@
       int libraryIndex, String name, Uri canonicalUri) {
     return new KLibrary(libraryIndex, name, canonicalUri);
   }
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract}) {
     return new KClass(library, classIndex, name, isAbstract: isAbstract);
   }
 
   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(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
       {bool isExternal,
       bool isConst}) {
     return new KGenerativeConstructor(
@@ skipping 820 matching lines @@
     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,
         KernelToElementMapForBuildingFromBaseMixin,
         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.
@@ skipping 50 matching lines @@
       _memberList.add(newMember);
       _memberData.add(data.copy());
       if (newMember.isField) {
         _fieldMap[data.node] = newMember;
       } else if (newMember.isConstructor) {
         _constructorMap[data.node] = newMember;
       } else {
         _methodMap[data.node] = newMember;
       }
     }
+    for (int typeVariableIndex = 0;
+        typeVariableIndex < _elementMap._typeVariableList.length;
+        typeVariableIndex++) {
+      TypeVariableEntity oldTypeVariable =
+          _elementMap._typeVariableList[typeVariableIndex];
+      Entity newTypeDeclaration;
+      if (oldTypeVariable.typeDeclaration is ClassEntity) {
+        IndexedClass cls = oldTypeVariable.typeDeclaration;
+        newTypeDeclaration = _classList[cls.classIndex];
+      } else {
+        IndexedMember member = oldTypeVariable.typeDeclaration;
+        newTypeDeclaration = _memberList[member.memberIndex];
+      }
+      TypeVariableEntity newTypeVariable = createTypeVariable(typeVariableIndex,
+          newTypeDeclaration, oldTypeVariable.name, oldTypeVariable.index);
+      _typeVariableList.add(newTypeVariable);
+    }
   }
 
   JsToFrontendMap get jsToFrontendMap => _jsToFrontendMap;
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
   }
 
   Iterable<LibraryEntity> get _libraries {
@@ skipping 45 matching lines @@
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
 }