Add boxing for modified variables

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 82 matching lines @@
   @override
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
     _createClosureEntities(_closureModels, closedWorldRefiner);
   }
 
   void _createClosureEntities(Map<MemberEntity, ScopeModel> closureModels,
       JsClosedWorld closedWorldRefiner) {
     closureModels.forEach((MemberEntity member, ScopeModel model) {
       KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
-      if (model.scopeInfo != null) {
-        _scopeMap[member] = new JsScopeInfo.from(model.scopeInfo, localsMap);
-      }
+      Map<Local, JRecordField> allBoxedVariables =
+          _elementMap.makeRecordContainer(model.scopeInfo, member, localsMap);
+      _scopeMap[member] =
+          new JsScopeInfo.from(allBoxedVariables, model.scopeInfo, localsMap);
 
       model.capturedScopesMap
           .forEach((ir.Node node, KernelCapturedScope scope) {
+        Map<Local, JRecordField> boxedVariables =
+            _elementMap.makeRecordContainer(scope, member, localsMap);
         if (scope is KernelCapturedLoopScope) {
           _capturedScopesMap[node] =
-              new JsCapturedLoopScope.from(scope, localsMap);
+              new JsCapturedLoopScope.from(boxedVariables, scope, localsMap);
         } else {
-          _capturedScopesMap[node] = new JsCapturedScope.from(scope, localsMap);
+          _capturedScopesMap[node] =
+              new JsCapturedScope.from(boxedVariables, scope, localsMap);
         }
+        allBoxedVariables.addAll(boxedVariables);
       });
 
       Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
           model.closuresToGenerate;
       for (ir.TreeNode node in closuresToGenerate.keys) {
         ir.FunctionNode functionNode;
         if (node is ir.FunctionDeclaration) {
           functionNode = node.function;
         } else if (node is ir.FunctionExpression) {
           functionNode = node.function;
         } else {
           failedAt(member, "Unexpected closure node ${node}");
         }
         KernelClosureClass closureClass = _produceSyntheticElements(
-            member, functionNode, closuresToGenerate[node], closedWorldRefiner);
+            member,
+            functionNode,
+            closuresToGenerate[node],
+            allBoxedVariables,
+            closedWorldRefiner);
         // Add also for the call method.
         _scopeMap[closureClass.callMethod] = closureClass;
       }
     });
   }
 
   /// Given what variables are captured at each point, construct closure classes
   /// with fields containing the captured variables to replicate the Dart
   /// closure semantics in JS. If this closure captures any variables (meaning
   /// the closure accesses a variable that gets accessed at some point), then
   /// boxForCapturedVariables stores the local context for those variables.
   /// If no variables are captured, this parameter is null.
   KernelClosureClass _produceSyntheticElements(
       MemberEntity member,
       ir.FunctionNode node,
       KernelScopeInfo info,
+      Map<Local, JRecordField> boxedVariables,
       JsClosedWorld closedWorldRefiner) {
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
     KernelClosureClass closureClass = closedWorldRefiner.buildClosureClass(
-        member, node, member.library, info, node.location, localsMap);
+        member,
+        node,
+        member.library,
+        boxedVariables,
+        info,
+        node.location,
+        localsMap);
 
     // We want the original declaration where that function is used to point
     // to the correct closure class.
     _memberClosureRepresentationMap[closureClass.callMethod] = closureClass;
     _globalLocalsMap.setLocalsMap(closureClass.callMethod, localsMap);
     if (node.parent is ir.Member) {
       assert(_elementMap.getMember(node.parent) == member);
       _memberClosureRepresentationMap[member] = closureClass;
     } else {
       assert(node.parent is ir.FunctionExpression ||
@@ skipping 96 matching lines @@
     StringBuffer sb = new StringBuffer();
     sb.write('this=$hasThisLocal,');
     sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
     return sb.toString();
   }
 }
 
 class JsScopeInfo extends ScopeInfo {
   final Set<Local> localsUsedInTryOrSync;
   final Local thisLocal;
-  final Set<Local> boxedVariables;
+  final Map<Local, JRecordField> boxedVariables;
 
   /// The set of variables that were defined in another scope, but are used in
   /// this scope.
   final Set<Local> freeVariables;
 
-  JsScopeInfo(this.thisLocal, this.localsUsedInTryOrSync, this.boxedVariables,
-      this.freeVariables);
-
-  JsScopeInfo.from(KernelScopeInfo info, KernelToLocalsMap localsMap)
+  JsScopeInfo.from(
+      this.boxedVariables, KernelScopeInfo info, KernelToLocalsMap localsMap)
       : this.thisLocal =
             info.hasThisLocal ? new ThisLocal(localsMap.currentMember) : null,
         this.localsUsedInTryOrSync =
             info.localsUsedInTryOrSync.map(localsMap.getLocalVariable).toSet(),
-        this.boxedVariables =
-            info.boxedVariables.map(localsMap.getLocalVariable).toSet(),
         this.freeVariables =
             info.freeVariables.map(localsMap.getLocalVariable).toSet();
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
-    boxedVariables.forEach((Local l) {
-      // TODO(efortuna): add FieldEntities as created.
-      f(l, null);
+    boxedVariables.forEach((Local l, JRecordField box) {
+      f(l, box);
     });
   }
 
   bool localIsUsedInTryOrSync(Local variable) =>
       localsUsedInTryOrSync.contains(variable);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('this=$thisLocal,');
     sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
     return sb.toString();
   }
 
-  bool isBoxed(Local variable) => boxedVariables.contains(variable);
+  bool isBoxed(Local variable) => boxedVariables.containsKey(variable);
 }
 
 class KernelCapturedScope extends KernelScopeInfo {
-  final ir.TreeNode context;
-
   KernelCapturedScope(
       Set<ir.VariableDeclaration> boxedVariables,
       NodeBox capturedVariablesAccessor,
-      this.context,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
       : super.withBoxedVariables(boxedVariables, capturedVariablesAccessor,
             localsUsedInTryOrSync, freeVariables, hasThisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
 class JsCapturedScope extends JsScopeInfo implements CapturedScope {
   final Local context;
 
-  JsCapturedScope.from(
+  JsCapturedScope.from(Map<Local, JRecordField> boxedVariables,
       KernelCapturedScope capturedScope, KernelToLocalsMap localsMap)
-      : this.context = localsMap.getLocalVariable(capturedScope.context),
-        super.from(capturedScope, localsMap);
+      : this.context =
+            boxedVariables.isNotEmpty ? boxedVariables.values.first.box : null,
+        super.from(boxedVariables, capturedScope, localsMap);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
 class KernelCapturedLoopScope extends KernelCapturedScope {
   final List<ir.VariableDeclaration> boxedLoopVariables;
 
   KernelCapturedLoopScope(
       Set<ir.VariableDeclaration> boxedVariables,
       NodeBox capturedVariablesAccessor,
       this.boxedLoopVariables,
-      ir.TreeNode context,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
-      : super(boxedVariables, capturedVariablesAccessor, context,
-            localsUsedInTryOrSync, freeVariables, hasThisLocal);
+      : super(boxedVariables, capturedVariablesAccessor, localsUsedInTryOrSync,
+            freeVariables, hasThisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 class JsCapturedLoopScope extends JsCapturedScope implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
-  JsCapturedLoopScope.from(
+  JsCapturedLoopScope.from(Map<Local, JRecordField> boxedVariables,
       KernelCapturedLoopScope capturedScope, KernelToLocalsMap localsMap)
       : this.boxedLoopVariables = capturedScope.boxedLoopVariables
             .map(localsMap.getLocalVariable)
             .toList(),
-        super.from(capturedScope, localsMap);
+        super.from(boxedVariables, capturedScope, localsMap);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends JsScopeInfo
     implements ClosureRepresentationInfo {
   JFunction callMethod;
   final Local closureEntity;
   final Local thisLocal;
   final JClass closureClassEntity;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
   KernelClosureClass.fromScopeInfo(
       this.closureClassEntity,
       ir.FunctionNode closureSourceNode,
+      Map<Local, JRecordField> boxedVariables,
       KernelScopeInfo info,
       KernelToLocalsMap localsMap,
       this.closureEntity,
       this.thisLocal)
-      : super.from(info, localsMap);
+      : super.from(boxedVariables, info, localsMap);
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
 
   FieldEntity get thisFieldEntity => localToFieldMap[thisLocal];
 
   void forEachCapturedVariable(f(Local from, JField to)) {
-    localToFieldMap.forEach(f);
+    for (Local l in localToFieldMap.keys) {
+      var jField = localToFieldMap[l];
+      if (l is! BoxLocal) f(l, jField);
+    }
   }
 
   @override
   void forEachBoxedVariable(f(Local local, JField field)) {
-    for (Local l in localToFieldMap.keys) {
-      if (localToFieldMap[l] is JRecordField) f(l, localToFieldMap[l]);
-    }
+    boxedVariables.forEach(f);
   }
 
   void forEachFreeVariable(f(Local variable, JField field)) {
-    for (Local l in localToFieldMap.keys) {
-      var jField = localToFieldMap[l];
-      if (jField is! JRecordField && jField is! BoxLocal) f(l, jField);
-    }
+    localToFieldMap.forEach(f);
+    boxedVariables.forEach(f);
   }
 
   bool isVariableBoxed(Local variable) =>
       localToFieldMap.keys.contains(variable);
 
   bool get isClosure => true;
 }
 
 /// 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
@@ skipping 180 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>{};
 }