Add boxed fields in closure classes.

pkg/compiler/lib/src/js_model/closure_visitors.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 'closure.dart';
 
 /// This builder walks the code to determine what variables are captured/free at
@@ skipping 16 matching lines @@
   /// about variable usage in the surrounding scope.
   Map<ir.FunctionNode, KernelScopeInfo> get _closuresToGenerate =>
       _model.closuresToGenerate;
 
   /// The local variables that have been declared in the current scope.
   List<ir.VariableDeclaration> _scopeVariables;
 
   /// Pointer to the context in which this closure is executed.
   /// For example, in the expression `var foo = () => 3 + i;`, the executable
   /// context as we walk the nodes in that expression is the ir.Field `foo`.
-  ir.Node _executableContext;
+  ir.TreeNode _executableContext;
 
   /// A flag to indicate if we are currently inside a closure.
   bool _isInsideClosure = false;
 
   /// Pointer to the original node where this closure builder started.
   ir.Node _outermostNode;
 
   /// Keep track of the mutated local variables so that we don't need to box
   /// non-mutated variables.
   Set<ir.VariableDeclaration> _mutatedVariables =
       new Set<ir.VariableDeclaration>();
 
   /// The set of variables that are accessed in some form, whether they are
   /// mutated or not.
   Set<ir.VariableDeclaration> _capturedVariables =
       new Set<ir.VariableDeclaration>();
 
   /// If true, the visitor is currently traversing some nodes that are inside a
   /// try block.
   bool _inTry = false;
 
   /// The current scope we are in.
   KernelScopeInfo _currentScopeInfo;
 
   final bool _hasThisLocal;
 
+  /// Keeps track of the number of boxes that we've created so that they each
+  /// have unique names.
+  int _boxCounter = 0;
+
   CapturedScopeBuilder(this._model, {bool hasThisLocal})
       : this._hasThisLocal = hasThisLocal;
 
   /// Update the [CapturedScope] object corresponding to
   /// this node if any variables are captured.
   void attachCapturedScopeVariables(ir.Node node) {
     Set<ir.VariableDeclaration> capturedVariablesForScope =
         new Set<ir.VariableDeclaration>();
 
     for (ir.VariableDeclaration variable in _scopeVariables) {
       // No need to box non-assignable elements.
       if (variable.isFinal || variable.isConst) continue;
       if (!_mutatedVariables.contains(variable)) continue;
       if (_capturedVariables.contains(variable)) {
         capturedVariablesForScope.add(variable);
       }
     }
     if (!capturedVariablesForScope.isEmpty) {
       assert(_model.scopeInfo != null);
       assert(_currentLocalFunction != null);
       KernelScopeInfo from = _model.scopeInfo;
       _scopesCapturedInClosureMap[node] = new KernelCapturedScope(
           capturedVariablesForScope,
+          new NodeBox(getBoxName(), _executableContext,
+              _getMemberContext(_executableContext)),

[Johnni Winther, 2017/08/01 09:09:10]

The member context is not needed. See comment in [_constructClosureFields].

[Emily Fortuna, 2017/08/01 19:30:06]

got it.

           _currentLocalFunction,
           from.localsUsedInTryOrSync,
           from.freeVariables,
           _hasThisLocal);
     }
   }
 
+  /// Look up the outermost member that contains this node.
+  ///
+  /// For top level, static or instance members, the member context is the
+  /// node itself. For parameters, local variables and nested closures, the
+  /// member context is the top level, static or instance member in which it is
+  /// defined.
+  ir.Member _getMemberContext(ir.TreeNode startNode) {
+    ir.TreeNode node = startNode;
+    while (node is! ir.Member && node != _outermostNode) {
+      node = node.parent;
+    }
+    assert(node is ir.Member);
+    return node;
+  }
+
+  /// Generate a unique name for the [_boxCounter]th box field.
+  ///
+  /// The result is used as the name of [NodeBox]s and [BoxLocal]s, and must
+  /// therefore be unique to avoid breaking an invariant in the element model
+  /// (classes cannot declare multiple fields with the same name).
+  ///
+  /// Also, the names should be distinct from real field names to prevent
+  /// clashes with selectors for those fields.
+  ///
+  /// These names are not used in generated code, just as element name.
+  String getBoxName() {
+    return "_box_${_boxCounter++}";
+  }
+
   /// Perform book-keeping with the current set of local variables that have
   /// been seen thus far before entering this new scope.
   void enterNewScope(ir.Node node, void visitNewScope()) {
     List<ir.VariableDeclaration> oldScopeVariables = _scopeVariables;
     _scopeVariables = <ir.VariableDeclaration>[];
     visitNewScope();
     attachCapturedScopeVariables(node);
     _mutatedVariables.removeAll(_scopeVariables);
     _scopeVariables = oldScopeVariables;
   }
@@ skipping 81 matching lines @@
         if (_capturedVariables.contains(variable) &&
             _mutatedVariables.contains(variable)) {
           boxedLoopVariables.add(variable);
         }
       }
     });
     KernelCapturedScope scope = _scopesCapturedInClosureMap[node];
     if (scope == null) return;
     _scopesCapturedInClosureMap[node] = new KernelCapturedLoopScope(
         scope.boxedVariables,
+        scope.capturedVariablesAccessor,
         boxedLoopVariables,
         scope.context,
         scope.localsUsedInTryOrSync,
         scope.freeVariables,
         scope.hasThisLocal);
   }
 
   void visitInvokable(ir.TreeNode node) {
     bool oldIsInsideClosure = _isInsideClosure;
-    ir.Node oldExecutableContext = _executableContext;
+    ir.TreeNode oldExecutableContext = _executableContext;
     KernelScopeInfo oldScopeInfo = _currentScopeInfo;
     ir.TreeNode oldLocalFunction = _currentLocalFunction;
 
     // _outermostNode is only null the first time we enter the body of the
     // field, constructor, or method that is being analyzed.
     _isInsideClosure = _outermostNode != null;
     _executableContext = node;
 
     _currentScopeInfo = new KernelScopeInfo(_hasThisLocal);
     if (_isInsideClosure) {
@@ skipping 43 matching lines @@
   }
 
   void translateConstructorOrProcedure(ir.Node constructorOrProcedure) {
     constructorOrProcedure.accept(this);
   }
 
   void visitFunctionNode(ir.FunctionNode functionNode) {
     visitInvokable(functionNode);
   }
 }