Fix the locals lookup of variables and partial implementation of boxing of variables.

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 '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 1941 matching lines @@
         // 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;
+  int fieldNumber = 0;
 
   JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
       KernelToElementMapForImpactImpl _elementMap)
       : super(reporter, environment) {
     _env = _elementMap._env;
     for (int libraryIndex = 0;
         libraryIndex < _elementMap._libraryEnvs.length;
         libraryIndex++) {
       LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
       LibraryData data = _elementMap._libraryData[libraryIndex];
@@ skipping 177 matching lines @@
     FunctionData data = _memberData[function.memberIndex];
     data.forEachParameter(this, f);
   }
 
   void _forEachConstructorBody(
       IndexedClass cls, void f(ConstructorBodyEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachConstructorBody(f);
   }
 
+  JRecord _constructBoxedField(
+      ir.VariableDeclaration variable,
+      BoxLocal boxLocal,
+      JClass container,
+      Map<String, MemberEntity> memberMap,
+      KernelToLocalsMap localsMap) {
+    Local local = localsMap.getLocalVariable(variable);
+    var boxedField = new JRecord(
+        _getClosureVariableName(local.name, fieldNumber),
+        _memberData.length,
+        boxLocal,
+        container,
+        variable.isConst,
+        variable.isFinal || variable.isConst);
+    _memberList.add(boxedField);
+    _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
+        boxedField,
+        computeSourceSpanFromTreeNode(variable),
+        MemberKind.closureField,
+        variable)));
+    memberMap[boxedField.name] = boxedField;
+
+    //JsScopeInfo scopeInfo = getScopeInfo(local.memberContext);
+    //scopeInfo.boxedVariables[local] = boxedField;
+    return boxedField;
+  }
+
+  /// Make a container controlling access to records, that is, variables that
+  /// are accessed in different scopes. This function creates the container as
+  /// and returns a map of locals to the corresponding records created.
+  Map<Local, JRecord> makeRecordContainer(
+      KernelScopeInfo info, MemberEntity member, KernelToLocalsMap localsMap) {
+    Map<Local, JRecord> boxedFields = {};
+    fieldNumber = 0;
+    if (info.boxedVariables.isNotEmpty) {
+      Map<Local, JRecord> boxedVariables = new Map<Local, JRecord>();
+      NodeBox box = info.capturedVariablesAccessor;
+      BoxLocal boxLocal = new BoxLocal(
+          box.name, getMember(box.executableContext.parent), member);
+
+      ///
+      var container =
+          new JRecordContainer(member.library, _classEnvs.length, box.name);
+      _classList.add(container);
+      Map<String, MemberEntity> memberMap = <String, MemberEntity>{};
+      _classEnvs.add(new RecordContainerEnv(memberMap));
+
+      var containerData = new ClassData(
+          null,
+          new ClosureClassDefinition(container,
+              computeSourceSpanFromTreeNode(getMemberDefinition(member).node)));
+      containerData
+        ..isMixinApplication = false
+        ..thisType = new InterfaceType(container, const <DartType>[])
+        ..supertype = commonElements.objectType
+        ..interfaces = const <InterfaceType>[];
+      var setBuilder = new _KernelOrderedTypeSetBuilder(this, container);
+      _classData.add(containerData);
+      containerData.orderedTypeSet = setBuilder.createOrderedTypeSet(
+          containerData.supertype, const Link<InterfaceType>());
+
+      ///
+
+      for (ir.VariableDeclaration variable in info.boxedVariables) {
+        boxedFields[localsMap.getLocalVariable(variable)] =
+            _constructBoxedField(
+                variable, boxLocal, container, memberMap, localsMap);
+        fieldNumber++;
+      }
+    }
+    return boxedFields;
+  }
+
+  Map<Local, JRecord> _makeBoxAndFields(
+      KernelScopeInfo info,
+      MemberEntity member,
+      JClass classEntity,
+      Map<String, MemberEntity> memberMap,
+      KernelToLocalsMap localsMap) {
+    Map<Local, JRecord> boxedFields = {};
+    fieldNumber = 0;
+    if (info.boxedVariables.isNotEmpty) {
+      Map<Local, JRecord> boxedVariables = new Map<Local, JRecord>();
+      NodeBox box = info.capturedVariablesAccessor;
+      BoxLocal boxLocal = new BoxLocal(
+          box.name, localsMap.getLocalVariable(box.executableContext), member);
+
+      for (ir.VariableDeclaration variable in info.boxedVariables) {
+        Local local = localsMap.getLocalVariable(variable);
+        boxedFields[local] = _constructBoxedField(
+            variable, boxLocal, classEntity, memberMap, localsMap);
+        fieldNumber++;
+      }
+    }
+    return boxedFields;
+  }
+
   KernelClosureClass constructClosureClass(
       MemberEntity member,
       ir.FunctionNode node,
       JLibrary enclosingLibrary,
+      Set<JsCapturedScope> capturedScopes,
       KernelScopeInfo info,
       ir.Location location,
       KernelToLocalsMap localsMap,
       InterfaceType supertype) {
     String name = _computeClosureName(node);
-    KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(
-        node, name, _classEnvs.length, enclosingLibrary, info, localsMap);
-    _classList.add(cls);
+    JClass clsEntity =
+        new JClosureClass(localsMap, enclosingLibrary, _classEnvs.length, name);
+    _classList.add(clsEntity);
     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(cls, computeSourceSpanFromTreeNode(node)));
+    var closureData = new ClassData(
+        null,
+        new ClosureClassDefinition(
+            clsEntity, computeSourceSpanFromTreeNode(node)));
     closureData
       ..isMixinApplication = false
       ..thisType =
-          closureData.rawType = new InterfaceType(cls, const <DartType>[])
+          closureData.rawType = new InterfaceType(clsEntity, const <DartType>[])
       ..supertype = supertype
       ..interfaces = const <InterfaceType>[];
-    var setBuilder = new _KernelOrderedTypeSetBuilder(this, cls);
+    var setBuilder = new _KernelOrderedTypeSetBuilder(this, clsEntity);
     _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
 
-    int i = 0;
+    var boxedFields =
+        _makeBoxAndFields(info, member, clsEntity, memberMap, localsMap);
+    KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(
+        clsEntity, node, boxedFields, capturedScopes, info, localsMap);
+
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // Make a corresponding field entity in this closure class for every
       // single freeVariable in the KernelScopeInfo.freeVariable.
-      _constructClosureFields(member, cls, memberMap, variable, i,
+      _constructClosureField(member, cls, memberMap, variable,
           info.capturedVariablesAccessor, localsMap);
-      i++;
+      fieldNumber++;
     }
 
     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));
     memberMap[cls.callMethod.name] = cls.callMethod;
     return cls;
   }
 
-  _constructClosureFields(
+  _constructClosureField(
       MemberEntity member,
       KernelClosureClass cls,
       Map<String, MemberEntity> memberMap,
       ir.VariableDeclaration variable,
-      int fieldNumber,
       NodeBox box,
       KernelToLocalsMap localsMap) {
-    // NOTE: This construction order may be slightly different than the
-    // old Element version. The old version did all the boxed items and then
-    // all the others.
     Local capturedLocal = localsMap.getLocalVariable(variable);
-    if (cls.isBoxed(capturedLocal)) {
-      FieldEntity boxedField = new JBoxedField(
-          _getClosureVariableName(capturedLocal.name, fieldNumber),
-          _memberData.length,
-          new BoxLocal(box.name,
-              localsMap.getLocalVariable(box.executableContext), member),
-          cls,
-          variable.isConst,
-          variable.isFinal || variable.isConst);
-      cls.localToFieldMap[capturedLocal] = boxedField;
-      _memberList.add(boxedField);
-      _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
-          boxedField,
-          computeSourceSpanFromTreeNode(variable),
-          MemberKind.closureField,
-          variable)));
-      memberMap[boxedField.name] = boxedField;
-    } else {
+    if (!cls.isBoxed(capturedLocal)) {
+      print('WWWWWWWWWWWWWW $capturedLocal aaaand ${cls.boxedVariables}');
       FieldEntity closureField = new JClosureField(
           _getClosureVariableName(capturedLocal.name, fieldNumber),
           _memberData.length,
           cls,
           variable.isConst,
           variable.isFinal || variable.isConst);
       cls.localToFieldMap[capturedLocal] = closureField;
       _memberList.add(closureField);
       _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
           cls.localToFieldMap[capturedLocal],
           computeSourceSpanFromTreeNode(variable),
           MemberKind.closureField,
           variable)));
       memberMap[closureField.name] = closureField;
+    } else {
+      // The box field should already be constructed from looping through the
+      // boxed fields separately.
+      cls.localToFieldMap[capturedLocal] = cls.boxedVariables[capturedLocal];
+      //assert(cls.localToFieldMap[capturedLocal] != null);
     }
   }
 
   // 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 {
       parts.add('closure');
@@ skipping 38 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');
   }
 }