Adding JRecord and boxing mechanics.

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 370 matching lines @@
 
   FieldEntity get thisFieldEntity => localToFieldMap[thisLocal];
 
   void forEachCapturedVariable(f(Local from, JField to)) {
     localToFieldMap.forEach(f);
   }
 
   @override
   void forEachBoxedVariable(f(Local local, JField field)) {
     for (Local l in localToFieldMap.keys) {
-      if (localToFieldMap[l] is JBoxedField) f(l, localToFieldMap[l]);
+      if (localToFieldMap[l] is JRecord) f(l, localToFieldMap[l]);
     }
   }
 
   void forEachFreeVariable(f(Local variable, JField field)) {
     for (Local l in localToFieldMap.keys) {
       var jField = localToFieldMap[l];
-      if (jField is! JBoxedField && jField is! BoxLocal) f(l, jField);
+      if (jField is! JRecord && jField is! BoxLocal) f(l, jField);
     }
   }
 
   bool isVariableBoxed(Local variable) =>
       localToFieldMap.keys.contains(variable);
 
   bool get isClosure => true;
 }
 
 /// A local variable to disambiguate between a variable that has been captured
@@ skipping 21 matching lines @@
       : super(
             memberIndex,
             containingClass.closureClassEntity.library,
             containingClass.closureClassEntity,
             new Name(name, containingClass.closureClassEntity.library),
             isAssignable: isAssignable,
             isConst: isConst,
             isStatic: false);
 }
 
-/// A ClosureField that has been "boxed" to prevent name shadowing with the
+/// 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 JRecordContainer 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;
+
+  JRecordContainer(this.library, this.classIndex, this.name);
+
+  bool get 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 JBoxedField extends JField {
+class JRecord extends JField {
   final BoxLocal box;
-  JBoxedField(String name, int memberIndex, this.box, JClass containingClass,
-      bool isConst, bool isAssignable)
+  JRecord(String name, int memberIndex, this.box, JClass containingClass,
+      bool isConst)
       : super(memberIndex, containingClass.library, containingClass,
             new Name(name, containingClass.library),
-            isAssignable: isAssignable, isConst: isConst);
+            isStatic: false, isAssignable: true, isConst: isConst);
 }
 
 class ClosureClassDefinition implements ClassDefinition {
   final ClassEntity cls;
   final SourceSpan location;
 
   ClosureClassDefinition(this.cls, this.location);
 
   ClassKind get kind => ClassKind.closure;
 
@@ skipping 79 matching lines @@
   final SourceSpan location;
   final MemberKind kind;
   final ir.Node node;
 
   ClosureMemberDefinition(this.member, this.location, this.kind, this.node);
 
   String toString() =>
       'ClosureMemberDefinition(kind:$kind,member:$member,location:$location)';
 }
 
+class RecordContainerDefinition implements ClassDefinition {
+  final ClassEntity cls;
+  final SourceSpan location;
+
+  RecordContainerDefinition(this.cls, this.location);
+
+  ClassKind get kind => ClassKind.container;
+
+  ir.Node get node =>
+      throw new UnsupportedError('RecordContainerDefinition.node for $cls');
+
+  String toString() =>
+      'RecordContainerDefinition(kind:$kind,cls:$cls,location:$location)';
+}
+
 /// Collection of scope data collected for a single member.
 class ScopeModel {
   /// Collection [ScopeInfo] data for the member.
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
       <ir.FunctionNode, KernelScopeInfo>{};
 }