Compute closure model purely from IR nodes

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 '../elements/entities.dart';
-import '../kernel/element_map.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 {
-  final MemberEntity _currentMember;
-  Local _currentLocalFunction;
+  ir.TreeNode _currentLocalFunction;
+
+  ClosureModel _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]).
-  final Map<ir.Node, CapturedScope> _scopesCapturedInClosureMap;
-
-  /// Map entities to their corresponding scope information (such as what
-  /// variables are captured/used).
-  final Map<Entity, ScopeInfo> _scopeInfoMap;
+  Map<ir.Node, KernelCapturedScope> get _scopesCapturedInClosureMap =>
+      _model.capturedScopesMap;
 
   /// A map of the nodes that we have flagged as necessary to generate closure
   /// classes for in a later stage. We map that node to information ascertained
   /// about variable usage in the surrounding scope.
-  final Map<ir.TreeNode /* ir.Field | ir.FunctionNode */, ScopeInfo>
-      _closuresToGenerate;
+  Map<ir.TreeNode /* ir.Field | 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;
 
   /// 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;
 
-  /// Lookup the local entity that corresponds to a kernel variable declaration.
-  final KernelToLocalsMap _localsMap;
-
   /// The current scope we are in.
   KernelScopeInfo _currentScopeInfo;
 
-  final Entity _thisLocal;
+  final bool _hasThisLocal;
 
-  CapturedScopeBuilder(this._currentMember, this._scopesCapturedInClosureMap,
-      this._scopeInfoMap, this._closuresToGenerate, this._localsMap)
-      : this._thisLocal =
-            _currentMember.isInstanceMember || _currentMember.isConstructor
-                ? new ThisLocal(_currentMember)
-                : null;
+  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<Local> capturedVariablesForScope = new Set<Local>();
+    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(_localsMap.getLocalVariable(variable));
+        capturedVariablesForScope.add(variable);
       }
     }
     if (!capturedVariablesForScope.isEmpty) {
-      assert(_scopeInfoMap[_currentMember] != null);
+      assert(_model.scopeInfo != null);
       assert(_currentLocalFunction != null);
-      KernelScopeInfo from = _scopeInfoMap[_currentMember];
+      KernelScopeInfo from = _model.scopeInfo;
       _scopesCapturedInClosureMap[node] = new KernelCapturedScope(
           capturedVariablesForScope,
           _currentLocalFunction,
           from.localsUsedInTryOrSync,
           from.freeVariables,
-          _thisLocal);
+          _hasThisLocal);
     }
   }
 
   /// 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);
@@ skipping 40 matching lines @@
     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.
       _currentScopeInfo.freeVariables.add(variable);
     }
     if (_inTry) {
-      _currentScopeInfo.localsUsedInTryOrSync
-          .add(_localsMap.getLocalVariable(variable));
+      _currentScopeInfo.localsUsedInTryOrSync.add(variable);
     }
   }
 
   @override
   void visitForStatement(ir.ForStatement node) {
-    List<Local> boxedLoopVariables = <Local>[];
+    List<ir.VariableDeclaration> boxedLoopVariables =
+        <ir.VariableDeclaration>[];
     enterNewScope(node, () {
       // First visit initialized variables and update steps so we can easily
       // check if a loop variable was captured in one of these subexpressions.
       node.variables
           .forEach((ir.VariableDeclaration variable) => variable.accept(this));
       node.updates
           .forEach((ir.Expression expression) => expression.accept(this));
 
       // Loop variables that have not been captured yet can safely be flagged as
       // non-mutated, because no nested function can observe the mutation.
       for (ir.VariableDeclaration variable in node.variables) {
         if (!_capturedVariables.contains(variable)) {
           _mutatedVariables.remove(variable);
         }
       }
 
       // Visit condition and body.
       // This must happen after the above, so any loop variables mutated in the
       // condition or body are indeed flagged as mutated.
       if (node.condition != null) node.condition.accept(this);
       node.body.accept(this);
 
       // See if we have declared loop variables that need to be boxed.
       for (ir.VariableDeclaration variable in node.variables) {
         // Non-mutated variables should not be boxed.  The _mutatedVariables set
         // gets cleared when `enterNewScope` returns, so check it here.
         if (_capturedVariables.contains(variable) &&
             _mutatedVariables.contains(variable)) {
-          boxedLoopVariables.add(_localsMap.getLocalVariable(variable));
+          boxedLoopVariables.add(variable);
         }
       }
     });
     KernelCapturedScope scope = _scopesCapturedInClosureMap[node];
     if (scope == null) return;
     _scopesCapturedInClosureMap[node] = new KernelCapturedLoopScope(
         scope.boxedVariables,
         boxedLoopVariables,
         scope.context,
         scope.localsUsedInTryOrSync,
         scope.freeVariables,
-        scope.thisLocal);
+        scope.hasThisLocal);
   }
 
   void visitInvokable(ir.TreeNode node) {
     bool oldIsInsideClosure = _isInsideClosure;
     ir.Node oldExecutableContext = _executableContext;
     KernelScopeInfo oldScopeInfo = _currentScopeInfo;
-    Local oldLocalFunction = _currentLocalFunction;
+    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(_thisLocal);
+    _currentScopeInfo = new KernelScopeInfo(_hasThisLocal);
     if (_isInsideClosure) {
       _closuresToGenerate[node] = _currentScopeInfo;
-      _currentLocalFunction = _localsMap.getLocalFunction(node.parent);
+      _currentLocalFunction = node.parent;
     } else {
       _outermostNode = node;
-      _scopeInfoMap[_currentMember] = _currentScopeInfo;
+      _model.scopeInfo = _currentScopeInfo;
     }
 
     enterNewScope(node, () {
       node.visitChildren(this);
     });
 
     KernelScopeInfo savedScopeInfo = _currentScopeInfo;
     bool savedIsInsideClosure = _isInsideClosure;
 
     // Restore old values.
@@ skipping 29 matching lines @@
   }
 
   void translateConstructorOrProcedure(ir.Node constructorOrProcedure) {
     constructorOrProcedure.accept(this);
   }
 
   void visitFunctionNode(ir.FunctionNode functionNode) {
     visitInvokable(functionNode);
   }
 }