Encapsulate the index based maps for entities.

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 88d06df7ab1a6430b4b8921bedbc92cfafc424de..aec123c5a92d350eebae3995b25d9ba330e45d8d 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -77,35 +77,16 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   /// 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);
@@ -138,21 +119,21 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
         : 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;
@@ -171,14 +152,14 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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;
   }
@@ -186,7 +167,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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));
     });
@@ -194,7 +175,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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);
@@ -204,7 +185,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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));
@@ -215,13 +196,13 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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);
   }
 
@@ -242,7 +223,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   InterfaceType _getSuperType(IndexedClass cls) {
     assert(checkFamily(cls));
-    ClassData data = _classData[cls.classIndex];
+    ClassData data = _classes.getData(cls.classIndex);
     _ensureSupertypes(cls, data);
     return data.supertype;
   }
@@ -290,7 +271,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
         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;
         }
@@ -328,7 +309,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   @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);
@@ -357,7 +338,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
     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) {
@@ -383,7 +364,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
     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;
@@ -590,7 +571,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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);
@@ -600,53 +581,53 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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);
   }
@@ -654,7 +635,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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);
@@ -665,7 +646,7 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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);
   }
 
@@ -678,11 +659,11 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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);
@@ -691,13 +672,13 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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);
   }
 
@@ -714,21 +695,21 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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;
   }
@@ -744,29 +725,23 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
 
   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>{};
@@ -784,7 +759,7 @@ abstract class ElementCreatorMixin {
   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) {
@@ -797,62 +772,64 @@ abstract class ElementCreatorMixin {
   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;
@@ -868,11 +845,10 @@ abstract class ElementCreatorMixin {
             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);
+            });
           }
         }
       }
@@ -882,40 +858,42 @@ abstract class ElementCreatorMixin {
 
   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;
-
-      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;
+      ir.FunctionNode functionNode;
+      return _members.register<IndexedConstructor, ConstructorData>(
+          (int memberIndex) {
+        ClassEntity enclosingClass = _getClass(node.enclosingClass);
+        Name name = getName(node.name);
+        bool isExternal = node.isExternal;
+
+        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);
+      });
     });
   }
 
@@ -938,77 +916,75 @@ abstract class ElementCreatorMixin {
 
   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));
+      });
     });
   }
 
@@ -1203,17 +1179,17 @@ class KernelToElementMapForImpactImpl extends KernelToElementMapBase
 
   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
@@ -1255,7 +1231,7 @@ class KernelToElementMapForImpactImpl extends KernelToElementMapBase
 
   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,
@@ -1283,7 +1259,7 @@ class KernelElementEnvironment implements ElementEnvironment {
   FunctionEntity get mainFunction => elementMap._mainFunction;
 
   @override
-  Iterable<LibraryEntity> get libraries => elementMap._libraries;
+  Iterable<LibraryEntity> get libraries => elementMap._libraryList;
 
   @override
   String getLibraryName(LibraryEntity library) {
@@ -1471,13 +1447,14 @@ class KernelElementEnvironment implements ElementEnvironment {
 
   @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);
   }
 
@@ -1491,7 +1468,7 @@ class KernelElementEnvironment implements ElementEnvironment {
   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);
   }
 
@@ -1856,7 +1833,7 @@ class WorldDeconstructionForTesting {
   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);
@@ -1867,7 +1844,7 @@ class WorldDeconstructionForTesting {
   }
 
   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(
@@ -1892,14 +1869,16 @@ class KernelNativeMemberResolver extends NativeMemberResolverBase {
   @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);
   }
@@ -1909,7 +1888,7 @@ class KernelNativeMemberResolver extends NativeMemberResolverBase {
       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);
   }
@@ -1918,7 +1897,7 @@ class KernelNativeMemberResolver extends NativeMemberResolverBase {
   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);
   }
@@ -1936,20 +1915,20 @@ class JsToFrontendMapImpl extends JsToFrontendMapBase
   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);
   }
 }
 
@@ -1975,44 +1954,58 @@ class JsKernelToElementMap extends KernelToElementMapBase
       : 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) {
@@ -2022,21 +2015,22 @@ class JsKernelToElementMap extends KernelToElementMapBase
       }
     }
     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);
+      });
     }
   }
 
@@ -2054,7 +2048,7 @@ class JsKernelToElementMap extends KernelToElementMapBase
     return _getSpannable(member, node);
   }
 
-  Iterable<LibraryEntity> get _libraries {
+  Iterable<LibraryEntity> get _libraryList {
     return _libraryMap.values;
   }
 
@@ -2102,26 +2096,29 @@ class JsKernelToElementMap extends KernelToElementMapBase
 
   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
@@ -2142,12 +2139,12 @@ class JsKernelToElementMap extends KernelToElementMapBase
   }
 
   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."));
@@ -2156,13 +2153,13 @@ class JsKernelToElementMap extends KernelToElementMapBase
 
   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);
   }
 
@@ -2176,26 +2173,28 @@ class JsKernelToElementMap extends KernelToElementMapBase
       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>());
 
@@ -2209,15 +2208,19 @@ class JsKernelToElementMap extends KernelToElementMapBase
       // 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;
       }
 
@@ -2240,18 +2243,17 @@ class JsKernelToElementMap extends KernelToElementMapBase
       }
     }
 
-    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;
   }