Add boxing for modified variables

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
 /// various points to build CapturedScope that can respond to queries
 /// about how a particular variable is being used at any point in the code.
 class CapturedScopeBuilder extends ir.Visitor {
-  ir.TreeNode _currentLocalFunction;
-
   ScopeModel _model;
 
   /// A map of each visited call node with the associated information about what
   /// variables are captured/used. Each ir.Node key corresponds to a scope that
   /// was encountered while visiting a closure (initially called through
   /// [translateLazyIntializer] or [translateConstructorOrProcedure]).
   Map<ir.Node, KernelCapturedScope> get _scopesCapturedInClosureMap =>
       _model.capturedScopesMap;
 
   /// A map of the nodes that we have flagged as necessary to generate closure
@@ skipping 51 matching lines @@
     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;
       var capturedScope = new KernelCapturedScope(
           capturedVariablesForScope,
           new NodeBox(getBoxName(), _executableContext),
-          _currentLocalFunction,
           from.localsUsedInTryOrSync,
           from.freeVariables,
           _hasThisLocal);
       _model.scopeInfo = _scopesCapturedInClosureMap[node] = capturedScope;
     }
   }
 
   /// 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
@@ skipping 45 matching lines @@
     _markVariableAsUsed(node.variable);
   }
 
   @override
   visitVariableSet(ir.VariableSet node) {
     _mutatedVariables.add(node.variable);
     _markVariableAsUsed(node.variable);
     node.visitChildren(this);
   }
 
+  @override
+  visitVariableDeclaration(ir.VariableDeclaration declaration) {
+    if (!declaration.isFieldFormal) {
+      _scopeVariables.add(declaration);
+    }
+
+    declaration.visitChildren(this);
+  }
+
   /// Add this variable to the set of free variables if appropriate and add to
   /// the tally of variables used in try or sync blocks.
   void _markVariableAsUsed(ir.VariableDeclaration variable) {
     if (_isInsideClosure && !_inCurrentContext(variable)) {
       // If the element is not declared in the current function and the element
       // is not the closure itself we need to mark the element as free variable.
       // Note that the check on [insideClosure] is not just an
       // optimization: factories have type parameters as function
       // parameters, and type parameters are declared in the class, not
       // the factory.
@@ skipping 39 matching lines @@
           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) {
     assert(node is ir.Member ||
         node is ir.FunctionExpression ||
         node is ir.FunctionDeclaration);
     bool oldIsInsideClosure = _isInsideClosure;
     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) {
       _closuresToGenerate[node] = _currentScopeInfo;
-      _currentLocalFunction = node.parent;
     } else {
       _outermostNode = node;
     }
     _model.scopeInfo = _currentScopeInfo;
 
     enterNewScope(node, () {
       node.visitChildren(this);
     });
 
     KernelScopeInfo savedScopeInfo = _currentScopeInfo;
     bool savedIsInsideClosure = _isInsideClosure;
 
     // Restore old values.
     _isInsideClosure = oldIsInsideClosure;
     _currentScopeInfo = oldScopeInfo;
     _executableContext = oldExecutableContext;
-    _currentLocalFunction = oldLocalFunction;
 
     // Mark all free variables as captured and expect to encounter them in the
     // outer function.
     Iterable<ir.VariableDeclaration> freeVariables =
         savedScopeInfo.freeVariables;
     assert(freeVariables.isEmpty || savedIsInsideClosure);
     for (ir.VariableDeclaration freeVariable in freeVariables) {
       _capturedVariables.add(freeVariable);
       _markVariableAsUsed(freeVariable);
     }
@@ skipping 27 matching lines @@
   @override
   void visitFunctionExpression(ir.FunctionExpression functionExpression) {
     visitInvokable(functionExpression);
   }
 
   @override
   void visitFunctionDeclaration(ir.FunctionDeclaration functionDeclaration) {
     visitInvokable(functionDeclaration);
   }
 }