Encapsulate the index based maps for entities.

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 59 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<TypeVariableEntity> _typeVariableList = <TypeVariableEntity>[];
-  List<TypedefEntity> _typedefList = <TypedefEntity>[];
-
-  /// List of library environments by `IndexedLibrary.libraryIndex`. This is
-  /// used for fast lookup into library classes and members.
-  List<LibraryEnv> _libraryEnvs = <LibraryEnv>[];
-
-  /// List of library data by `IndexedLibrary.libraryIndex`. This is used for
-  /// fast lookup into library properties.
-  List<LibraryData> _libraryData = <LibraryData>[];
-
-  /// 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
-  /// fast lookup into class properties.
-  List<ClassData> _classData = <ClassData>[];
-
-  /// List of member data by `IndexedMember.memberIndex`. This is used for
-  /// fast lookup into member properties.
-  List<MemberData> _memberData = <MemberData>[];
-
-  /// List of typedef data by `IndexedTypedef.typedefIndex`. This is used for
-  /// fast lookup into typedef properties.
-  List<TypedefData> _typedefData = <TypedefData>[];
+  final EntityDataEnvMap<IndexedLibrary, LibraryData, LibraryEnv> _libraries =
+      new EntityDataEnvMap<IndexedLibrary, LibraryData, LibraryEnv>();
+  final EntityDataEnvMap<IndexedClass, ClassData, ClassEnv> _classes =
+      new EntityDataEnvMap<IndexedClass, ClassData, ClassEnv>();
+  final EntityDataMap<IndexedMember, MemberData> _members =
+      new EntityDataMap<IndexedMember, MemberData>();
+  final EntityMap<IndexedTypeVariable> _typeVariables =
+      new EntityMap<IndexedTypeVariable>();
+  final EntityDataMap<IndexedTypedef, TypedefData> _typedefs =
+      new EntityDataMap<IndexedTypedef, TypedefData>();
 
   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);
   }
 
   bool checkFamily(Entity entity);
@@ skipping 12 matching lines @@
   FunctionEntity get _mainFunction {
     return _env.mainMethod != null ? _getMethod(_env.mainMethod) : null;
   }
 
   LibraryEntity get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
-  Iterable<LibraryEntity> get _libraries;
+  Iterable<LibraryEntity> get _libraryList;
 
   SourceSpan getSourceSpan(Spannable spannable, Entity currentElement) {
     SourceSpan fromSpannable(Spannable spannable) {
       if (spannable is IndexedLibrary &&
-          spannable.libraryIndex < _libraryEnvs.length) {
-        LibraryEnv env = _libraryEnvs[spannable.libraryIndex];
+          spannable.libraryIndex < _libraries.length) {
+        LibraryEnv env = _libraries.getEnv(spannable.libraryIndex);
         return computeSourceSpanFromTreeNode(env.library);
       } else if (spannable is IndexedClass &&
-          spannable.classIndex < _classEnvs.length) {
-        ClassData data = _classData[spannable.classIndex];
+          spannable.classIndex < _classes.length) {
+        ClassData data = _classes.getData(spannable.classIndex);
         return data.definition.location;
       } else if (spannable is IndexedMember &&
-          spannable.memberIndex < _memberData.length) {
-        MemberData data = _memberData[spannable.memberIndex];
+          spannable.memberIndex < _members.length) {
+        MemberData data = _members.getData(spannable.memberIndex);
         return data.definition.location;
       }
       return null;
     }
 
     SourceSpan sourceSpan = fromSpannable(spannable);
     sourceSpan ??= fromSpannable(currentElement);
     return sourceSpan;
   }
 
   LibraryEntity lookupLibrary(Uri uri) {
     LibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   String _getLibraryName(IndexedLibrary library) {
     assert(checkFamily(library));
-    LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    LibraryEnv libraryEnv = _libraries.getEnv(library.libraryIndex);
     return libraryEnv.library.name ?? '';
   }
 
   MemberEntity lookupLibraryMember(IndexedLibrary library, String name,
       {bool setter: false}) {
     assert(checkFamily(library));
-    LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    LibraryEnv libraryEnv = _libraries.getEnv(library.libraryIndex);
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   void _forEachLibraryMember(
       IndexedLibrary library, void f(MemberEntity member)) {
     assert(checkFamily(library));
-    LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    LibraryEnv libraryEnv = _libraries.getEnv(library.libraryIndex);
     libraryEnv.forEachMember((ir.Member node) {
       f(getMember(node));
     });
   }
 
   ClassEntity lookupClass(IndexedLibrary library, String name) {
     assert(checkFamily(library));
-    LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    LibraryEnv libraryEnv = _libraries.getEnv(library.libraryIndex);
     ClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
   void _forEachClass(IndexedLibrary library, void f(ClassEntity cls)) {
     assert(checkFamily(library));
-    LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    LibraryEnv libraryEnv = _libraries.getEnv(library.libraryIndex);
     libraryEnv.forEachClass((ClassEnv classEnv) {
       if (!classEnv.isUnnamedMixinApplication) {
         f(_getClass(classEnv.cls, classEnv));
       }
     });
   }
 
   MemberEntity lookupClassMember(IndexedClass cls, String name,
       {bool setter: false}) {
     assert(checkFamily(cls));
-    ClassEnv classEnv = _classEnvs[cls.classIndex];
+    ClassEnv classEnv = _classes.getEnv(cls.classIndex);
     return classEnv.lookupMember(this, name, setter: setter);
   }
 
   ConstructorEntity lookupConstructor(IndexedClass cls, String name) {
     assert(checkFamily(cls));
-    ClassEnv classEnv = _classEnvs[cls.classIndex];
+    ClassEnv classEnv = _classes.getEnv(cls.classIndex);
     return classEnv.lookupConstructor(this, name);
   }
 
   @override
   InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
   }
 
   LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
 
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv libraryEnv]);
 
   @override
   ClassEntity getClass(ir.Class node) => _getClass(node);
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]);
 
   InterfaceType _getSuperType(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.supertype;
   }
 
   void _ensureThisAndRawType(ClassEntity cls, ClassData data) {
     assert(checkFamily(cls));
     if (data.thisType == null) {
       ir.Class node = data.cls;
       if (node.typeParameters.isEmpty) {
         data.thisType =
@@ skipping 27 matching lines @@
       ir.Class node = data.cls;
 
       if (node.supertype == null) {
         data.orderedTypeSet = new OrderedTypeSet.singleton(data.thisType);
         data.isMixinApplication = false;
         data.interfaces = const <InterfaceType>[];
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
           InterfaceType supertype = _typeConverter.visitSupertype(node);
           IndexedClass superclass = supertype.element;
-          ClassData superdata = _classData[superclass.classIndex];
+          ClassData superdata = _classes.getData(superclass.classIndex);
           _ensureSupertypes(superclass, superdata);
           return supertype;
         }
 
         InterfaceType supertype = processSupertype(node.supertype);
         if (supertype == _commonElements.objectType) {
           ClassEntity defaultSuperclass =
               _commonElements.getDefaultSuperclass(cls, nativeBasicData);
           data.supertype = _elementEnvironment.getRawType(defaultSuperclass);
         } else {
@@ skipping 17 matching lines @@
         data.orderedTypeSet = setBuilder.createOrderedTypeSet(
             data.supertype, interfaces.reverse());
         data.interfaces = new List<InterfaceType>.from(interfaces.toList());
       }
     }
   }
 
   @override
   TypedefType getTypedefType(ir.Typedef node) {
     IndexedTypedef typedef = _getTypedef(node);
-    return _typedefData[typedef.typedefIndex].rawType;
+    return _typedefs.getData(typedef.typedefIndex).rawType;
   }
 
   TypedefEntity _getTypedef(ir.Typedef node);
 
   @override
   MemberEntity getMember(ir.Member node) {
     if (node is ir.Field) {
       return _getField(node);
     } else if (node is ir.Constructor) {
       return _getConstructor(node);
     } else if (node is ir.Procedure) {
       if (node.kind == ir.ProcedureKind.Factory) {
         return _getConstructor(node);
       } else {
         return _getMethod(node);
       }
     }
     throw new UnsupportedError("Unexpected member: $node");
   }
 
   MemberEntity getSuperMember(ir.Member context, ir.Name name, ir.Member target,
       {bool setter: false}) {
     if (target != null) {
       return getMember(target);
     }
     ClassEntity cls = getMember(context).enclosingClass;
     IndexedClass superclass = _getSuperType(cls)?.element;
     while (superclass != null) {
-      ClassEnv env = _classEnvs[superclass.classIndex];
+      ClassEnv env = _classes.getEnv(superclass.classIndex);
       MemberEntity superMember =
           env.lookupMember(this, name.name, setter: setter);
       if (superMember != null) {
         return superMember;
       }
       superclass = _getSuperType(superclass)?.element;
     }
     throw failedAt(cls, "No super method member found for ${name} in $cls.");
   }
 
   @override
   ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstructorEntity _getConstructor(ir.Member node);
 
   ConstructorEntity getSuperConstructor(
       ir.Constructor sourceNode, ir.Member targetNode) {
     ConstructorEntity source = getConstructor(sourceNode);
     ClassEntity sourceClass = source.enclosingClass;
     ConstructorEntity target = getConstructor(targetNode);
     ClassEntity targetClass = target.enclosingClass;
     IndexedClass superClass = _getSuperType(sourceClass)?.element;
     if (superClass == targetClass) {
       return target;
     }
-    ClassEnv env = _classEnvs[superClass.classIndex];
+    ClassEnv env = _classes.getEnv(superClass.classIndex);
     ConstructorEntity constructor = env.lookupConstructor(this, target.name);
     if (constructor != null) {
       return constructor;
     }
     throw failedAt(source, "Super constructor for $source not found.");
   }
 
   @override
   FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
 
@@ skipping 186 matching lines @@
   }
 
   /// Returns the type of the `call` method on 'type'.
   ///
   /// If [type] doesn't have a `call` member `null` is returned. If [type] has
   /// an invalid `call` member (non-method or a synthesized method with both
   /// optional and named parameters) a [DynamicType] is returned.
   DartType _getCallType(InterfaceType type) {
     IndexedClass cls = type.element;
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureCallType(cls, data);
     if (data.callType != null) {
       return _substByContext(data.callType, type);
     }
     return null;
   }
 
   InterfaceType _getThisType(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureThisAndRawType(cls, data);
     return data.thisType;
   }
 
   InterfaceType _getRawType(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureThisAndRawType(cls, data);
     return data.rawType;
   }
 
   FunctionType _getFunctionType(IndexedFunction function) {
     assert(checkFamily(function));
-    FunctionData data = _memberData[function.memberIndex];
+    FunctionData data = _members.getData(function.memberIndex);
     return data.getFunctionType(this);
   }
 
   DartType _getFieldType(IndexedField field) {
     assert(checkFamily(field));
-    FieldData data = _memberData[field.memberIndex];
+    FieldData data = _members.getData(field.memberIndex);
     return data.getFieldType(this);
   }
 
   ClassEntity _getAppliedMixin(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.mixedInType?.element;
   }
 
   bool _isMixinApplication(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.isMixinApplication;
   }
 
   bool _isUnnamedMixinApplication(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassEnv env = _classEnvs[cls.classIndex];
+    ClassEnv env = _classes.getEnv(cls.classIndex);
     return env.isUnnamedMixinApplication;
   }
 
   void _forEachSupertype(IndexedClass cls, void f(InterfaceType supertype)) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     data.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachMixin(IndexedClass cls, void f(ClassEntity mixin)) {
     assert(checkFamily(cls));
     while (cls != null) {
-      ClassData data = _classData[cls.classIndex];
+      ClassData data = _classes.getData(cls.classIndex);
       _ensureSupertypes(cls, data);
       if (data.mixedInType != null) {
         f(data.mixedInType.element);
       }
       cls = data.supertype?.element;
     }
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
     assert(checkFamily(cls));
-    ClassEnv env = _classEnvs[cls.classIndex];
+    ClassEnv env = _classes.getEnv(cls.classIndex);
     env.forEachConstructor(this, f);
   }
 
   void _forEachConstructorBody(
       IndexedClass cls, void f(ConstructorBodyEntity member)) {
     throw new UnsupportedError(
         'KernelToElementMapBase._forEachConstructorBody');
   }
 
   void _forEachClassMember(
       IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
     assert(checkFamily(cls));
-    ClassEnv env = _classEnvs[cls.classIndex];
+    ClassEnv env = _classes.getEnv(cls.classIndex);
     env.forEachMember(this, (MemberEntity member) {
       f(cls, member);
     });
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     if (data.supertype != null) {
       _forEachClassMember(data.supertype.element, f);
     }
   }
 
   ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
     assert(checkFamily(constructor));
-    ConstructorData data = _memberData[constructor.memberIndex];
+    ConstructorData data = _members.getData(constructor.memberIndex);
     return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(IndexedField field) {
     assert(checkFamily(field));
-    FieldData data = _memberData[field.memberIndex];
+    FieldData data = _members.getData(field.memberIndex);
     return data.getFieldConstant(this, field);
   }
 
   InterfaceType _asInstanceOf(InterfaceType type, ClassEntity cls) {
     assert(checkFamily(cls));
     OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
     InterfaceType supertype =
         orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
     if (supertype != null) {
       supertype = _substByContext(supertype, type);
     }
     return supertype;
   }
 
   OrderedTypeSet _getOrderedTypeSet(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.orderedTypeSet;
   }
 
   int _getHierarchyDepth(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.orderedTypeSet.maxDepth;
   }
 
   Iterable<InterfaceType> _getInterfaces(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     SourceSpan sourceSpan;
     if (node is ir.TreeNode) {
       sourceSpan = computeSourceSpanFromTreeNode(node);
     }
     sourceSpan ??= getSourceSpan(member, null);
     return sourceSpan;
   }
 
   MemberDefinition _getMemberDefinition(covariant IndexedMember member) {
     assert(checkFamily(member));
-    return _memberData[member.memberIndex].definition;
+    return _members.getData(member.memberIndex).definition;
   }
 
   ClassDefinition _getClassDefinition(covariant IndexedClass cls) {
     assert(checkFamily(cls));
-    return _classData[cls.classIndex].definition;
+    return _classes.getData(cls.classIndex).definition;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase].
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
-  List<LibraryEntity> get _libraryList;
-  List<LibraryEnv> get _libraryEnvs;
-  List<LibraryData> get _libraryData;
-  List<ClassEntity> get _classList;
-  List<ClassEnv> get _classEnvs;
-  List<ClassData> get _classData;
-  List<MemberEntity> get _memberList;
-  List<MemberData> get _memberData;
-  List<TypeVariableEntity> get _typeVariableList;
-  List<TypedefEntity> get _typedefList;
-  List<TypedefData> get _typedefData;
+  EntityDataEnvMap<IndexedLibrary, LibraryData, LibraryEnv> get _libraries;
+  EntityDataEnvMap<IndexedClass, ClassData, ClassEnv> get _classes;
+  EntityDataMap<IndexedMember, MemberData> get _members;
+  EntityMap<IndexedTypeVariable> get _typeVariables;
+  EntityDataMap<IndexedTypedef, TypedefData> get _typedefs;
 
   Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
   Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
   Map<ir.Typedef, IndexedTypedef> _typedefMap = <ir.Typedef, IndexedTypedef>{};
   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);
 
-  Iterable<LibraryEntity> get _libraries {
+  Iterable<LibraryEntity> get _libraryList {
     if (_env.length != _libraryMap.length) {
       // Create a [KLibrary] for each library.
       _env.forEachLibrary((LibraryEnv env) {
         _getLibrary(env.library, env);
       });
     }
     return _libraryMap.values;
   }
 
   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);
-      }
-      LibraryEntity library =
-          createLibrary(_libraryMap.length, name, canonicalUri);
-      _libraryList.add(library);
-      _libraryData.add(new LibraryData(node));
-      return library;
+      return _libraries.register((int libraryIndex) {
+        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 createLibrary(_libraryMap.length, name, canonicalUri);
+      }, (IndexedLibrary library) {
+        return new LibraryData(node);
+      }, (IndexedLibrary library) {
+        return libraryEnv ?? _env.lookupLibrary(canonicalUri);
+      });
     });
   }
 
   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);
-      ClassEntity cls = createClass(library, _classList.length, node.name,
-          isAbstract: node.isAbstract);
-      _classData
-          .add(new ClassData(node, new RegularClassDefinition(cls, node)));
-      _classList.add(cls);
-      return cls;
+      return _classes.register((int classIndex) {
+        KLibrary library = _getLibrary(node.enclosingLibrary);
+        if (classEnv == null) {
+          classEnv =
+              _libraries.getEnv(library.libraryIndex).lookupClass(node.name);
+        }
+        return createClass(library, classIndex, node.name,
+            isAbstract: node.isAbstract);
+      }, (IndexedClass cls) {
+        return new ClassData(node, new RegularClassDefinition(cls, node));
+      }, (IndexedClass cls) {
+        return classEnv;
+      });
     });
   }
 
   TypedefEntity _getTypedef(ir.Typedef node) {
     return _typedefMap.putIfAbsent(node, () {
-      IndexedLibrary library = _getLibrary(node.enclosingLibrary);
-      TypedefEntity typedef =
-          createTypedef(library, _typedefList.length, node.name);
-      TypedefType typedefType = new TypedefType(
-          typedef,
-          new List<DartType>.filled(
-              node.typeParameters.length, const DynamicType()));
-      _typedefData.add(new TypedefData(node, typedef, typedefType));
-      _typedefList.add(typedef);
-      return typedef;
+      return _typedefs.register((int typedefIndex) {
+        IndexedLibrary library = _getLibrary(node.enclosingLibrary);
+        return createTypedef(library, typedefIndex, node.name);
+      }, (IndexedTypedef typedef) {
+        TypedefType typedefType = new TypedefType(
+            typedef,
+            new List<DartType>.filled(
+                node.typeParameters.length, const DynamicType()));
+        return new TypedefData(node, typedef, typedefType);
+      });
     });
   }
 
   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);
-        TypeVariableEntity typeVariable = createTypeVariable(
-            typeVariableIndex, _getClass(cls), node.name, index);
-        _typeVariableList.add(typeVariable);
-        return typeVariable;
+        return _typeVariables.register((int typeVariableIndex) {
+          ir.Class cls = node.parent;
+          int index = cls.typeParameters.indexOf(node);
+          return createTypeVariable(
+              typeVariableIndex, _getClass(cls), node.name, index);
+        });
       }
       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 {
-            int typeVariableIndex = _typeVariableList.length;
-            TypeVariableEntity typeVariable = createTypeVariable(
-                typeVariableIndex, _getMethod(procedure), node.name, index);
-            _typeVariableList.add(typeVariable);
-            return typeVariable;
+            return _typeVariables.register((int typeVariableIndex) {
+              return createTypeVariable(
+                  typeVariableIndex, _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 = _memberData.length;
-      ConstructorEntity constructor;
-      ClassEntity enclosingClass = _getClass(node.enclosingClass);
-      Name name = getName(node.name);
-      bool isExternal = node.isExternal;
+      MemberDefinition definition;
+      ir.FunctionNode functionNode;
+      return _members.register<IndexedConstructor, ConstructorData>(
+          (int memberIndex) {
+        ClassEntity enclosingClass = _getClass(node.enclosingClass);
+        Name name = getName(node.name);
+        bool isExternal = node.isExternal;
 
-      ir.FunctionNode functionNode;
-      MemberDefinition definition;
-      if (node is ir.Constructor) {
-        functionNode = node.function;
-        constructor = createGenerativeConstructor(memberIndex, enclosingClass,
-            name, _getParameterStructure(functionNode),
-            isExternal: isExternal, isConst: node.isConst);
-        definition = new SpecialMemberDefinition(
-            constructor, node, MemberKind.constructor);
-      } else if (node is ir.Procedure) {
-        functionNode = node.function;
-        bool isFromEnvironment = isExternal &&
-            name.text == 'fromEnvironment' &&
-            const ['int', 'bool', 'String'].contains(enclosingClass.name);
-        constructor = createFactoryConstructor(memberIndex, enclosingClass,
-            name, _getParameterStructure(functionNode),
-            isExternal: isExternal,
-            isConst: node.isConst,
-            isFromEnvironmentConstructor: isFromEnvironment);
-        definition = new RegularMemberDefinition(constructor, node);
-      } else {
-        // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
-        throw failedAt(
-            NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
-      }
-      _memberData.add(new ConstructorDataImpl(node, functionNode, definition));
-      _memberList.add(constructor);
-      return constructor;
+        IndexedConstructor constructor;
+        if (node is ir.Constructor) {
+          functionNode = node.function;
+          constructor = createGenerativeConstructor(memberIndex, enclosingClass,
+              name, _getParameterStructure(functionNode),
+              isExternal: isExternal, isConst: node.isConst);
+          definition = new SpecialMemberDefinition(
+              constructor, node, MemberKind.constructor);
+        } else if (node is ir.Procedure) {
+          functionNode = node.function;
+          bool isFromEnvironment = isExternal &&
+              name.text == 'fromEnvironment' &&
+              const ['int', 'bool', 'String'].contains(enclosingClass.name);
+          constructor = createFactoryConstructor(memberIndex, enclosingClass,
+              name, _getParameterStructure(functionNode),
+              isExternal: isExternal,
+              isConst: node.isConst,
+              isFromEnvironmentConstructor: isFromEnvironment);
+          definition = new RegularMemberDefinition(constructor, node);
+        } else {
+          // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
+          throw failedAt(
+              NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
+        }
+        return constructor;
+      }, (IndexedConstructor constructor) {
+        return new ConstructorDataImpl(node, functionNode, definition);
+      });
     });
   }
 
   AsyncMarker _getAsyncMarker(ir.FunctionNode node) {
     switch (node.asyncMarker) {
       case ir.AsyncMarker.Async:
         return AsyncMarker.ASYNC;
       case ir.AsyncMarker.AsyncStar:
         return AsyncMarker.ASYNC_STAR;
       case ir.AsyncMarker.Sync:
         return AsyncMarker.SYNC;
       case ir.AsyncMarker.SyncStar:
         return AsyncMarker.SYNC_STAR;
       case ir.AsyncMarker.SyncYielding:
       default:
         throw new UnsupportedError(
             "Async marker ${node.asyncMarker} is not supported.");
     }
   }
 
   FunctionEntity _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
-      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;
-      bool isExternal = node.isExternal;
-      bool isAbstract = node.isAbstract;
-      IndexedFunction function;
-      AsyncMarker asyncMarker = _getAsyncMarker(node.function);
-      switch (node.kind) {
-        case ir.ProcedureKind.Factory:
-          throw new UnsupportedError("Cannot create method from factory.");
-        case ir.ProcedureKind.Getter:
-          function = createGetter(
-              memberIndex, library, enclosingClass, name, asyncMarker,
-              isStatic: isStatic,
-              isExternal: isExternal,
-              isAbstract: isAbstract);
-          break;
-        case ir.ProcedureKind.Method:
-        case ir.ProcedureKind.Operator:
-          function = createMethod(memberIndex, library, enclosingClass, name,
-              _getParameterStructure(node.function), asyncMarker,
-              isStatic: isStatic,
-              isExternal: isExternal,
-              isAbstract: isAbstract);
-          break;
-        case ir.ProcedureKind.Setter:
-          assert(asyncMarker == AsyncMarker.SYNC);
-          function = createSetter(
-              memberIndex, library, enclosingClass, name.setter,
-              isStatic: isStatic,
-              isExternal: isExternal,
-              isAbstract: isAbstract);
-          break;
-      }
-      _memberData.add(new FunctionDataImpl(
-          node, node.function, new RegularMemberDefinition(function, node)));
-      _memberList.add(function);
-      return function;
+      return _members.register<IndexedFunction, FunctionData>(
+          (int memberIndex) {
+        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;
+        bool isExternal = node.isExternal;
+        bool isAbstract = node.isAbstract;
+        AsyncMarker asyncMarker = _getAsyncMarker(node.function);
+        switch (node.kind) {
+          case ir.ProcedureKind.Factory:
+            throw new UnsupportedError("Cannot create method from factory.");
+          case ir.ProcedureKind.Getter:
+            return createGetter(
+                memberIndex, library, enclosingClass, name, asyncMarker,
+                isStatic: isStatic,
+                isExternal: isExternal,
+                isAbstract: isAbstract);
+          case ir.ProcedureKind.Method:
+          case ir.ProcedureKind.Operator:
+            return createMethod(memberIndex, library, enclosingClass, name,
+                _getParameterStructure(node.function), asyncMarker,
+                isStatic: isStatic,
+                isExternal: isExternal,
+                isAbstract: isAbstract);
+            break;
+          case ir.ProcedureKind.Setter:
+            assert(asyncMarker == AsyncMarker.SYNC);
+            return createSetter(
+                memberIndex, library, enclosingClass, name.setter,
+                isStatic: isStatic,
+                isExternal: isExternal,
+                isAbstract: isAbstract);
+            break;
+        }
+      }, (IndexedFunction function) {
+        return new FunctionDataImpl(
+            node, node.function, new RegularMemberDefinition(function, node));
+      });
     });
   }
 
   FieldEntity _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
-      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;
-      FieldEntity field = createField(
-          memberIndex, library, enclosingClass, name,
-          isStatic: isStatic,
-          isAssignable: node.isMutable,
-          isConst: node.isConst);
-      _memberData.add(
-          new FieldDataImpl(node, new RegularMemberDefinition(field, node)));
-      _memberList.add(field);
-      return field;
+      return _members.register<IndexedField, FieldData>((int memberIndex) {
+        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;
+        return createField(memberIndex, library, enclosingClass, name,
+            isStatic: isStatic,
+            isAssignable: node.isMutable,
+            isConst: node.isConst);
+      }, (FieldEntity field) {
+        return new FieldDataImpl(
+            node, new RegularMemberDefinition(field, node));
+      });
     });
   }
 
   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 174 matching lines @@
     _env.addProgram(program);
   }
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder =>
       _nativeBehaviorBuilder ??= new KernelBehaviorBuilder(elementEnvironment,
           commonElements, nativeBasicData, reporter, _options);
 
   ResolutionImpact computeWorldImpact(KMember member) {
     return buildKernelImpact(
-        _memberData[member.memberIndex].definition.node, this);
+        _members.getData(member.memberIndex).definition.node, this);
   }
 
   ScopeModel computeScopeModel(KMember member) {
-    ir.Member node = _memberData[member.memberIndex].definition.node;
+    ir.Member node = _members.getData(member.memberIndex).definition.node;
     return KernelClosureAnalysis.computeScopeModel(member, node);
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
-    return _memberData[method.memberIndex].definition.node;
+    return _members.getData(method.memberIndex).definition.node;
   }
 
   @override
   Local getLocalFunction(ir.TreeNode node) {
     assert(
         node is ir.FunctionDeclaration || node is ir.FunctionExpression,
         failedAt(
             CURRENT_ELEMENT_SPANNABLE, 'Invalid local function node: $node'));
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
@@ skipping 21 matching lines @@
       } else if (node is ir.FunctionExpression) {
         functionType = getFunctionType(node.function);
       }
       return new KLocalFunction(
           name, memberContext, executableContext, functionType);
     });
   }
 
   bool _implementsFunction(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     OrderedTypeSet orderedTypeSet = data.orderedTypeSet;
     InterfaceType supertype = orderedTypeSet.asInstanceOf(
         commonElements.functionClass,
         _getHierarchyDepth(commonElements.functionClass));
     if (supertype != null) {
       return true;
     }
     _ensureCallType(cls, data);
     return data.callType is FunctionType;
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelToElementMapBase elementMap;
 
   KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => elementMap._mainLibrary;
 
   @override
   FunctionEntity get mainFunction => elementMap._mainFunction;
 
   @override
-  Iterable<LibraryEntity> get libraries => elementMap._libraries;
+  Iterable<LibraryEntity> get libraries => elementMap._libraryList;
 
   @override
   String getLibraryName(LibraryEntity library) {
     return elementMap._getLibraryName(library);
   }
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
     return elementMap._getThisType(cls);
   }
@@ skipping 167 matching lines @@
   }
 
   @override
   bool isDeferredLoadLibraryGetter(MemberEntity member) {
     // TODO(redemption): Support these.
     return false;
   }
 
   @override
   Iterable<ConstantValue> getLibraryMetadata(covariant IndexedLibrary library) {
-    LibraryData libraryData = elementMap._libraryData[library.libraryIndex];
+    LibraryData libraryData =
+        elementMap._libraries.getData(library.libraryIndex);
     return libraryData.getMetadata(elementMap);
   }
 
   @override
   Iterable<ConstantValue> getClassMetadata(covariant IndexedClass cls) {
-    ClassData classData = elementMap._classData[cls.classIndex];
+    ClassData classData = elementMap._classes.getData(cls.classIndex);
     return classData.getMetadata(elementMap);
   }
 
   @override
   Iterable<ConstantValue> getTypedefMetadata(TypedefEntity typedef) {
     // TODO(redemption): Support this.
     throw new UnsupportedError('ElementEnvironment.getTypedefMetadata');
   }
 
   @override
   Iterable<ConstantValue> getMemberMetadata(covariant IndexedMember member,
       {bool includeParameterMetadata: false}) {
     // TODO(redemption): Support includeParameterMetadata.
-    MemberData memberData = elementMap._memberData[member.memberIndex];
+    MemberData memberData = elementMap._members.getData(member.memberIndex);
     return memberData.getMetadata(elementMap);
   }
 
   @override
   FunctionType getFunctionTypeOfTypedef(TypedefEntity typedef) {
     // TODO(redemption): Support this.
     throw new UnsupportedError('ElementEnvironment.getTypedefAlias');
   }
 }
 
@@ skipping 344 matching lines @@
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
 
   WorldDeconstructionForTesting(this.elementMap);
 
   IndexedClass getSuperclassForClass(IndexedClass cls) {
-    ClassEnv env = elementMap._classEnvs[cls.classIndex];
+    ClassEnv env = elementMap._classes.getEnv(cls.classIndex);
     ir.Supertype supertype = env.cls.supertype;
     if (supertype == null) return null;
     return elementMap.getClass(supertype.classNode);
   }
 
   bool isUnnamedMixinApplication(IndexedClass cls) {
     return elementMap._isUnnamedMixinApplication(cls);
   }
 
   InterfaceType getMixinTypeForClass(IndexedClass cls) {
-    ClassEnv env = elementMap._classEnvs[cls.classIndex];
+    ClassEnv env = elementMap._classes.getEnv(cls.classIndex);
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return elementMap.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }
 
 class KernelNativeMemberResolver extends NativeMemberResolverBase {
   final KernelToElementMapForImpactImpl elementMap;
   final NativeBasicData nativeBasicData;
   final NativeDataBuilder nativeDataBuilder;
 
   KernelNativeMemberResolver(
       this.elementMap, this.nativeBasicData, this.nativeDataBuilder);
 
   @override
   ElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
 
   @override
   CommonElements get commonElements => elementMap.commonElements;
 
   @override
   native.NativeBehavior computeNativeFieldStoreBehavior(
       covariant KField field) {
-    ir.Field node = elementMap._memberData[field.memberIndex].definition.node;
+    ir.Field node =
+        elementMap._members.getData(field.memberIndex).definition.node;
     return elementMap.getNativeBehaviorForFieldStore(node);
   }
 
   @override
   native.NativeBehavior computeNativeFieldLoadBehavior(covariant KField field,
       {bool isJsInterop}) {
-    ir.Field node = elementMap._memberData[field.memberIndex].definition.node;
+    ir.Field node =
+        elementMap._members.getData(field.memberIndex).definition.node;
     return elementMap.getNativeBehaviorForFieldLoad(node,
         isJsInterop: isJsInterop);
   }
 
   @override
   native.NativeBehavior computeNativeMethodBehavior(
       covariant KFunction function,
       {bool isJsInterop}) {
     ir.Member node =
-        elementMap._memberData[function.memberIndex].definition.node;
+        elementMap._members.getData(function.memberIndex).definition.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._memberData[function.memberIndex].definition.node;
+        elementMap._members.getData(function.memberIndex).definition.node;
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     return nativeBasicData.isJsInteropMember(element);
   }
 }
 
 class JsToFrontendMapImpl extends JsToFrontendMapBase
     implements JsToFrontendMap {
   final KernelToElementMapBase _backend;
 
   JsToFrontendMapImpl(this._backend);
 
   LibraryEntity toBackendLibrary(covariant IndexedLibrary library) {
-    return _backend._libraryList[library.libraryIndex];
+    return _backend._libraries.getEntity(library.libraryIndex);
   }
 
   ClassEntity toBackendClass(covariant IndexedClass cls) {
-    return _backend._classList[cls.classIndex];
+    return _backend._classes.getEntity(cls.classIndex);
   }
 
   MemberEntity toBackendMember(covariant IndexedMember member) {
-    return _backend._memberList[member.memberIndex];
+    return _backend._members.getEntity(member.memberIndex);
   }
 
   TypeVariableEntity toBackendTypeVariable(
       covariant IndexedTypeVariable typeVariable) {
-    return _backend._typeVariableList[typeVariable.typeVariableIndex];
+    return _backend._typeVariables.getEntity(typeVariable.typeVariableIndex);
   }
 }
 
 class JsKernelToElementMap extends KernelToElementMapBase
     with
         KernelToElementMapForBuildingMixin,
         JsElementCreatorMixin,
         // TODO(johnniwinther): Avoid mixing 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 {
   NativeBasicData nativeBasicData;
 
   JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
       KernelToElementMapForImpactImpl _elementMap)
       : super(reporter, environment) {
     _env = _elementMap._env;
     for (int libraryIndex = 0;
-        libraryIndex < _elementMap._libraryEnvs.length;
+        libraryIndex < _elementMap._libraries.length;
         libraryIndex++) {
-      LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
-      LibraryData data = _elementMap._libraryData[libraryIndex];
-      LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
-      LibraryEntity newLibrary = convertLibrary(oldLibrary);
-      _libraryMap[env.library] = newLibrary;
-      _libraryList.add(newLibrary);
-      _libraryData.add(data.copy());
-      _libraryEnvs.add(env);
+      LibraryEnv env = _elementMap._libraries.getEnv(libraryIndex);
+      LibraryData data = _elementMap._libraries.getData(libraryIndex);
+      IndexedLibrary oldLibrary =
+          _elementMap._libraries.getEntity(libraryIndex);
+      _libraryMap[env.library] = _libraries
+          .register<IndexedLibrary, LibraryData, LibraryEnv>(
+              (int libraryIndex) {
+        assert(libraryIndex == oldLibrary.libraryIndex);
+        return convertLibrary(oldLibrary);
+      }, (LibraryEntity library) {
+        return data.copy();
+      }, (LibraryEntity library) {
+        return env;
+      });
     }
     for (int classIndex = 0;
-        classIndex < _elementMap._classEnvs.length;
+        classIndex < _elementMap._classes.length;
         classIndex++) {
-      ClassEnv env = _elementMap._classEnvs[classIndex];
-      ClassData data = _elementMap._classData[classIndex];
-      ClassEntity oldClass = _elementMap._classList[classIndex];
+      ClassEnv env = _elementMap._classes.getEnv(classIndex);
+      ClassData data = _elementMap._classes.getData(classIndex);
+      IndexedClass oldClass = _elementMap._classes.getEntity(classIndex);
       IndexedLibrary oldLibrary = oldClass.library;
-      LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
-      ClassEntity newClass = convertClass(newLibrary, oldClass);
-      _classMap[env.cls] = newClass;
-      _classList.add(newClass);
-      _classEnvs.add(env);
-      _classData.add(data.copy());
+      _classMap[env.cls] = _classes.register((int classIndex) {
+        assert(classIndex == oldClass.classIndex);
+        LibraryEntity newLibrary =
+            _libraries.getEntity(oldLibrary.libraryIndex);
+        return convertClass(newLibrary, oldClass);
+      }, (IndexedClass cls) {

[Siggi Cherem (dart-lang), 2017/08/22 19:12:22]

I'd use => for these short closures here and elsewhere:

...,
(_) => data.copy(),
(_) => env);

+        return data.copy();
+      }, (IndexedClass cls) {
+        return env;
+      });
     }
     for (int memberIndex = 0;
-        memberIndex < _elementMap._memberData.length;
+        memberIndex < _elementMap._members.length;
         memberIndex++) {
-      MemberDataImpl data = _elementMap._memberData[memberIndex];
-      MemberEntity oldMember = _elementMap._memberList[memberIndex];
+      MemberDataImpl data = _elementMap._members.getData(memberIndex);
+      IndexedMember oldMember = _elementMap._members.getEntity(memberIndex);
       IndexedLibrary oldLibrary = oldMember.library;
       IndexedClass oldClass = oldMember.enclosingClass;
-      LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
-      ClassEntity newClass =
-          oldClass != null ? _classList[oldClass.classIndex] : null;
-      IndexedMember newMember = convertMember(newLibrary, newClass, oldMember);
-      _memberList.add(newMember);
-      _memberData.add(data.copy());
+      IndexedMember newMember = _members.register((int memberIndex) {
+        assert(memberIndex == oldMember.memberIndex);
+        LibraryEntity newLibrary =
+            _libraries.getEntity(oldLibrary.libraryIndex);
+        ClassEntity newClass =
+            oldClass != null ? _classes.getEntity(oldClass.classIndex) : null;
+        return convertMember(newLibrary, newClass, oldMember);
+      }, (IndexedMember member) {
+        return 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 < _elementMap._typeVariables.length;
         typeVariableIndex++) {
       TypeVariableEntity oldTypeVariable =
-          _elementMap._typeVariableList[typeVariableIndex];
+          _elementMap._typeVariables.getEntity(typeVariableIndex);
       Entity newTypeDeclaration;
       if (oldTypeVariable.typeDeclaration is ClassEntity) {
         IndexedClass cls = oldTypeVariable.typeDeclaration;
-        newTypeDeclaration = _classList[cls.classIndex];
+        newTypeDeclaration = _classes.getEntity(cls.classIndex);
       } else {
         IndexedMember member = oldTypeVariable.typeDeclaration;
-        newTypeDeclaration = _memberList[member.memberIndex];
+        newTypeDeclaration = _members.getEntity(member.memberIndex);
       }
-      TypeVariableEntity newTypeVariable = createTypeVariable(typeVariableIndex,
-          newTypeDeclaration, oldTypeVariable.name, oldTypeVariable.index);
-      _typeVariableList.add(newTypeVariable);
+      _typeVariables.register<IndexedTypeVariable>((int typeVariablesIndex) {
+        return createTypeVariable(typeVariableIndex, newTypeDeclaration,
+            oldTypeVariable.name, oldTypeVariable.index);
+      });
     }
   }
 
   @override
   bool checkFamily(Entity entity) {
     assert(
         '$entity'.startsWith(jsElementPrefix),
         failedAt(entity,
             "Unexpected entity $entity, expected family $jsElementPrefix."));
     return true;
   }
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
   }
 
-  Iterable<LibraryEntity> get _libraries {
+  Iterable<LibraryEntity> get _libraryList {
     return _libraryMap.values;
   }
 
   @override
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv env]) {
     LibraryEntity library = _libraryMap[node];
     assert(library != null, "No library entity for $node");
     return library;
   }
 
@@ skipping 27 matching lines @@
     return constructor;
   }
 
   FunctionEntity getConstructorBody(ir.Constructor node) {
     ConstructorEntity constructor = getConstructor(node);
     return _getConstructorBody(node, constructor);
   }
 
   FunctionEntity _getConstructorBody(
       ir.Constructor node, covariant IndexedConstructor constructor) {
-    ConstructorDataImpl data = _memberData[constructor.memberIndex];
+    ConstructorDataImpl data = _members.getData(constructor.memberIndex);
     if (data.constructorBody == null) {
-      ConstructorBodyEntity constructorBody = data.constructorBody =
-          createConstructorBody(_memberList.length, constructor);
-      _memberList.add(constructorBody);
-      _memberData.add(new FunctionDataImpl(
-          node,
-          node.function,
-          new SpecialMemberDefinition(
-              constructorBody, node, MemberKind.constructorBody)));
+      JConstructorBody constructorBody =
+          _members.register<IndexedFunction, FunctionData>((int memberIndex) {
+        return createConstructorBody(memberIndex, constructor);
+      }, (IndexedFunction constructorBody) {
+        return new FunctionDataImpl(
+            node,
+            node.function,
+            new SpecialMemberDefinition(
+                constructorBody, node, MemberKind.constructorBody));
+      });
       IndexedClass cls = constructor.enclosingClass;
-      ClassEnvImpl classEnv = _classEnvs[cls.classIndex];
+      ClassEnvImpl classEnv = _classes.getEnv(cls.classIndex);
       // TODO(johnniwinther): Avoid this by only including live members in the
       // js-model.
       classEnv.addConstructorBody(constructorBody);
+      data.constructorBody = constructorBody;
     }
     return data.constructorBody;
   }
 
-  ConstructorBodyEntity createConstructorBody(
+  JConstructorBody createConstructorBody(
       int memberIndex, ConstructorEntity constructor);
 
   @override
   MemberDefinition getMemberDefinition(MemberEntity member) {
     return _getMemberDefinition(member);
   }
 
   @override
   ClassDefinition getClassDefinition(ClassEntity cls) {
     return _getClassDefinition(cls);
   }
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     // TODO(johnniwinther): Cache the result in [FieldData].
     return getConstantValue(field.initializer,
         requireConstant: field.isConst, implicitNull: !field.isConst);
   }
 
   bool hasConstantFieldInitializer(covariant IndexedField field) {
-    FieldData data = _memberData[field.memberIndex];
+    FieldData data = _members.getData(field.memberIndex);
     return getFieldConstantValue(data.definition.node) != null;
   }
 
   ConstantValue getConstantFieldInitializer(covariant IndexedField field) {
-    FieldData data = _memberData[field.memberIndex];
+    FieldData data = _members.getData(field.memberIndex);
     ConstantValue value = getFieldConstantValue(data.definition.node);
     assert(value != null,
         failedAt(field, "Field $field doesn't have a constant initial value."));
     return value;
   }
 
   void forEachParameter(covariant IndexedFunction function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
-    FunctionData data = _memberData[function.memberIndex];
+    FunctionData data = _members.getData(function.memberIndex);
     data.forEachParameter(this, f);
   }
 
   void _forEachConstructorBody(
       IndexedClass cls, void f(ConstructorBodyEntity member)) {
-    ClassEnv env = _classEnvs[cls.classIndex];
+    ClassEnv env = _classes.getEnv(cls.classIndex);
     env.forEachConstructorBody(f);
   }
 
   KernelClosureClass constructClosureClass(
       MemberEntity member,
       ir.FunctionNode node,
       JLibrary enclosingLibrary,
       KernelScopeInfo info,
       Map<Local, FieldEntity> boxedFields,
       ir.Location location,
       KernelToLocalsMap localsMap,
       InterfaceType supertype) {
     String name = _computeClosureName(node);
-    JClass classEntity =
-        new JClosureClass(enclosingLibrary, _classEnvs.length, name);
-    _classList.add(classEntity);
+    SourceSpan location = computeSourceSpanFromTreeNode(node);
     Map<String, MemberEntity> memberMap = <String, MemberEntity>{};
-    _classEnvs.add(new ClosureClassEnv(memberMap));
 
-    // Create a classData and set up the interfaces and subclass
-    // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
-    var closureData = new ClassData(
-        null,
-        new ClosureClassDefinition(
-            classEntity, computeSourceSpanFromTreeNode(node)));
-    closureData
-      ..isMixinApplication = false
-      ..thisType = closureData.rawType =
-          new InterfaceType(classEntity, const <DartType>[])
-      ..supertype = supertype
-      ..interfaces = const <InterfaceType>[];
+    JClass classEntity = _classes.register((int classIndex) {
+      return new JClosureClass(enclosingLibrary, classIndex, name);
+    }, (IndexedClass cls) {
+      // Create a classData and set up the interfaces and subclass
+      // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
+      var closureData =
+          new ClassData(null, new ClosureClassDefinition(cls, location));
+      closureData
+        ..isMixinApplication = false
+        ..thisType =
+            closureData.rawType = new InterfaceType(cls, const <DartType>[])
+        ..supertype = supertype
+        ..interfaces = const <InterfaceType>[];
+      return closureData;
+    }, (IndexedClass cls) {
+      return new ClosureClassEnv(memberMap);
+    });
+    var closureData = _classes.getData(classEntity.classIndex);
     var setBuilder = new _KernelOrderedTypeSetBuilder(this, classEntity);
-    _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
 
     KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(
         classEntity, node, info, localsMap);
 
     int i = 0;
     Set<Local> boxes = new Set<Local>();
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // Make a corresponding field entity in this closure class for every
       // single freeVariable in the KernelScopeInfo.freeVariable.
 
       void addClosureField(Local local) {
-        FieldEntity closureField = new JClosureField(
-            _getClosureVariableName(local.name, i++), _memberData.length, cls);
-        cls.localToFieldMap[local] = closureField;
-        _memberList.add(closureField);
-        _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
-            closureField,
-            computeSourceSpanFromTreeNode(variable),
-            MemberKind.closureField,
-            variable)));
+        IndexedField closureField =
+            _members.register<IndexedField, FieldData>((int memberIndex) {
+          FieldEntity closureField = new JClosureField(
+              _getClosureVariableName(local.name, i++), memberIndex, cls);
+          cls.localToFieldMap[local] = closureField;
+          return closureField;
+        }, (IndexedField closureField) {
+          return new ClosureFieldData(new ClosureMemberDefinition(
+              closureField,
+              computeSourceSpanFromTreeNode(variable),
+              MemberKind.closureField,
+              variable));
+        });
         memberMap[closureField.name] = closureField;
       }
 
       Local capturedLocal = localsMap.getLocalVariable(variable);
       JBoxedField boxedField = boxedFields[capturedLocal];
       if (boxedField != null) {
         /// [capturedLocal] is encoded as a boxed field.
         if (boxes.add(boxedField.box)) {
           /// Add a closure field for the box, if not already added.
           addClosureField(boxedField.box);
         }
 
         /// Remember that [capturedLocal] should be accessed through the boxed
         /// field.
         cls.boxedVariables[capturedLocal] = boxedField;
       } else {
         /// [capturedLocal] is passed by value. Add a closure field for
         /// the value.
         addClosureField(capturedLocal);
       }
     }
 
-    FunctionEntity callMethod = cls.callMethod = new JClosureCallMethod(
-        _memberData.length,
-        cls,
-        _getParameterStructure(node),
-        _getAsyncMarker(node));
-    _memberList.add(cls.callMethod);
-
-    _memberData.add(new ClosureFunctionData(
-        new ClosureMemberDefinition(callMethod, closureData.definition.location,
-            MemberKind.closureCall, node.parent),
-        getFunctionType(node),
-        node));
+    cls.callMethod =
+        _members.register<IndexedFunction, FunctionData>((int memberIndex) {
+      return new JClosureCallMethod(memberIndex, cls,
+          _getParameterStructure(node), _getAsyncMarker(node));
+    }, (IndexedFunction callMethod) {
+      return new ClosureFunctionData(
+          new ClosureMemberDefinition(
+              callMethod, location, MemberKind.closureCall, node.parent),
+          getFunctionType(node),
+          node);
+    });
     memberMap[cls.callMethod.name] = cls.callMethod;
     return cls;
   }
 
   // Returns a non-unique name for the given closure element.
   String _computeClosureName(ir.TreeNode treeNode) {
     var parts = <String>[];
     if (treeNode is ir.Field && treeNode.name.name != "") {
       parts.add(treeNode.name.name);
     } else {
@@ skipping 39 matching lines @@
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }