Encapsulate the index based maps for entities.

pkg/compiler/lib/src/js_model/closure.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/tasks.dart';
 import '../constants/expressions.dart';
@@ skipping 408 matching lines @@
 /// A local variable to disambiguate between a variable that has been captured
 /// from one scope to another. This is the ir.Node version that corresponds to
 /// [BoxLocal].
 class NodeBox {
   final String name;
   final ir.TreeNode executableContext;
   NodeBox(this.name, this.executableContext);
 }
 
 class JClosureClass extends JClass {
-  JClosureClass(JLibrary library, int classIndex, String name)
-      : super(library, classIndex, name, isAbstract: false);
+  JClosureClass(JLibrary library, String name)
+      : super(library, name, isAbstract: false);
 
   @override
   bool get isClosure => true;
 
   String toString() => '${jsElementPrefix}closure_class($name)';
 }
 
 class JClosureField extends JField {
-  JClosureField(String name, int memberIndex,
-      KernelClosureClass containingClass, bool isConst, bool isAssignable)
+  JClosureField(String name, KernelClosureClass containingClass, bool isConst,
+      bool isAssignable)
       : super(
-            memberIndex,
             containingClass.closureClassEntity.library,
             containingClass.closureClassEntity,
             new Name(name, containingClass.closureClassEntity.library),
             isAssignable: isAssignable,
             isConst: isConst,
             isStatic: false);
 }
 
 /// A container for variables declared in a particular scope that are accessed
 /// elsewhere.
 // TODO(efortuna, johnniwinther): Don't implement JClass. This isn't actually a
 // class.
-class JRecord implements JClass {
-  final JLibrary library;
-  final String name;
-
-  /// Index into the classData, classList and classEnvironment lists where this
-  /// entity is stored in [JsToFrontendMapImpl].
-  final int classIndex;
-
-  JRecord(this.library, this.classIndex, this.name);
-
-  bool get isAbstract => false;
+class JRecord extends JClass {
+  JRecord(LibraryEntity library, String name)
+      : super(library, name, isAbstract: false);
 
   bool get isClosure => false;
 
   String toString() => '${jsElementPrefix}record_container($name)';
 }
 
 /// A variable that has been "boxed" to prevent name shadowing with the
 /// original variable and ensure that this variable is updated/read with the
 /// most recent value.
 /// This corresponds to BoxFieldElement; we reuse BoxLocal from the original
 /// algorithm to correspond to the actual name of the variable.
 class JRecordField extends JField {
   final BoxLocal box;
-  JRecordField(String name, int memberIndex, this.box, JClass containingClass,
-      bool isConst)
-      : super(memberIndex, containingClass.library, containingClass,
+  JRecordField(String name, this.box, JClass containingClass, bool isConst)
+      : super(containingClass.library, containingClass,
             new Name(name, containingClass.library),
             isStatic: false, isAssignable: true, isConst: isConst);
 }
 
 class ClosureClassDefinition implements ClassDefinition {
   final ClassEntity cls;
   final SourceSpan location;
 
   ClosureClassDefinition(this.cls, this.location);
 
@@ skipping 127 matching lines @@
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
       <ir.TreeNode, KernelScopeInfo>{};
 }