Encapsulate the index based maps for entities.

pkg/compiler/lib/src/kernel/env.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.env;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
 import '../common.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../ordered_typeset.dart';
 import 'element_map.dart';
 import 'element_map_impl.dart';
 import 'element_map_mixins.dart';
 
+/// Base implementation for an index based map of entities of type [E].
+abstract class EntityMapBase<E> {
+  List<E> _list = <E>[];
+
+  /// Returns the [index]th entity in the map.
+  E getEntity(int index) => _list[index];
+
+  /// Returns the number entities in the map.
+  int get length => _list.length;
+}
+
+/// Index based map of entities of type [E].
+class EntityMap<E> extends EntityMapBase<E> {
+  /// Registers a new entity.
+  ///
+  /// [createEntity] is called to create the entity with the given index.
+  E0 register<E0 extends E>(E0 createEntity(int index)) {
+    E0 entity = createEntity(_list.length);
+    assert(entity != null);
+    _list.add(entity);
+    return entity;
+  }
+}
+
+/// Base implementation of an index based map of entities of type [E] with a
+/// corresponding data object of type [D].
+abstract class EntityDataMapBase<E, D> extends EntityMapBase<E> {
+  List<D> _data = <D>[];
+
+  /// Returns the data object stored for the [index]th entity.
+  D getData(int index) {

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

what about making a generic Indexable interface and make E extend from it?

Then you can do:
  getData(member);

and you retrieve and set the index here.

You can even make the field private to this library by declaring the interface
here.

+    if (index < length && index >= _data.length) {
+      throw new StateError(
+          'Data is in the process of being created for ${_list[index]}.');
+    }
+    return _data[index];
+  }
+}
+
+/// Index based map of entities of type [E] with a corresponding data object
+/// of type [D].
+class EntityDataMap<E, D> extends EntityDataMapBase<E, D> {
+  /// Registers a new entity with an associated data object.
+  ///
+  /// Firstly, [createEntity] is called to create the entity with the given
+  /// index. Secondly, [createData] is called with the newly created entity to
+  /// create the associated data object.
+  E0 register<E0 extends E, D0 extends D>(
+      E0 createEntity(int index), D0 createData(E0 entity)) {
+    E0 entity = createEntity(_list.length);
+    assert(entity != null);
+    _list.add(entity);
+    D0 data = createData(entity);
+    assert(data != null);
+    _data.add(data);
+    return entity;
+  }
+}
+
+/// Base implementation for an index based of entities of type [E] with a
+/// corresponding data object of type [D] and an environment of type [V].
+abstract class EntityDataEnvMapBase<E, D, V> extends EntityDataMapBase<E, D> {
+  List<V> _env = <V>[];
+
+  /// Returns the environment object stored for the [index]th entity.
+  V getEnv(int index) {
+    if (index < length && index >= _env.length) {
+      throw new StateError(
+          'Env is in the process of being created for ${_list[index]}.');
+    }
+    return _env[index];
+  }
+}
+
+/// Index based of entities of type [E] with a corresponding data object of
+/// type [D] and an environment of type [V].
+class EntityDataEnvMap<E, D, V> extends EntityDataEnvMapBase<E, D, V> {
+  /// Registers a new entity with an associated data object and environment.
+  ///
+  /// Firstly, [createEntity] is called to create the entity with the given
+  /// index. Secondly, [createData] is called with the newly created entity to
+  /// create the associated data object. Thirdly, [createEnv] is called with
+  /// the newly created entity to create the associated environment object.
+  E0 register<E0 extends E, D0 extends D, V0 extends V>(
+      E0 createEntity(int index),

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

can we switch to take the actual values instead of a closure?

   register(E0 entity, D0 data, V0 env)

I think it will make the use site of this API simpler.

I believe it will be easier we change to have _index private to this library and
set it after we create the entity (here on registration). Each caller can use
the entity when building the data/env, but I noticed many callsites won't need
it anyways.

+      D0 createData(E0 entity),
+      V0 createEnv(E0 entity)) {
+    E0 entity = createEntity(_list.length);
+    assert(entity != null);
+    _list.add(entity);
+    D0 data = createData(entity);
+    assert(data != null);
+    _data.add(data);
+    V0 env = createEnv(entity);
+    assert(env != null);
+    _env.add(env);
+    return entity;
+  }
+}
+
 /// Environment for fast lookup of program libraries.
 class ProgramEnv {
   final Set<ir.Program> _programs = new Set<ir.Program>();
 
   Map<Uri, LibraryEnv> _libraryMap;
 
   /// TODO(johnniwinther): Handle arbitrary load order if needed.
   ir.Member get mainMethod => _programs.first?.mainMethod;
 
   void addProgram(ir.Program program) {
@@ skipping 571 matching lines @@
   }
 }
 
 class TypedefData {
   final ir.Typedef node;
   final TypedefEntity element;
   final TypedefType rawType;
 
   TypedefData(this.node, this.element, this.rawType);
 }