Move .getLocalFunction from KernelToElementMap to KernelToLocalsMap

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';
@@ skipping 48 matching lines @@
   /// 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;
 
-  // TODO(johnniwinther): Remove the need for this.
-  final KernelToElementMap _kernelToElementMap;
-
   final Entity _thisLocal;
 
-  CapturedScopeBuilder(
-      this._currentMember,
-      this._scopesCapturedInClosureMap,
-      this._scopeInfoMap,
-      this._closuresToGenerate,
-      this._localsMap,
-      this._kernelToElementMap)
+  CapturedScopeBuilder(this._currentMember, this._scopesCapturedInClosureMap,
+      this._scopeInfoMap, this._closuresToGenerate, this._localsMap)
       : this._thisLocal =
             _currentMember.isInstanceMember || _currentMember.isConstructor
                 ? new ThisLocal(_currentMember)
                 : null;
 
   /// Update the [CapturedScope] object corresponding to
   /// this node if any variables are captured.
   void attachCapturedScopeVariables(ir.Node node) {
     Set<Local> capturedVariablesForScope = new Set<Local>();
 
     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.getLocal(variable));
+        capturedVariablesForScope.add(_localsMap.getLocalVariable(variable));
       }
     }
     if (!capturedVariablesForScope.isEmpty) {
       assert(_scopeInfoMap[_currentMember] != null);
       assert(_currentLocalFunction != null);
       KernelScopeInfo from = _scopeInfoMap[_currentMember];
       _scopesCapturedInClosureMap[node] = new KernelCapturedScope(
           capturedVariablesForScope,
           _currentLocalFunction,
           from.localsUsedInTryOrSync,
@@ skipping 54 matching lines @@
       // 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.getLocal(variable));
+          .add(_localsMap.getLocalVariable(variable));
     }
   }
 
   @override
   void visitForStatement(ir.ForStatement node) {
     List<Local> boxedLoopVariables = <Local>[];
     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
@@ skipping 14 matching lines @@
       // 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.getLocal(variable));
+          boxedLoopVariables.add(_localsMap.getLocalVariable(variable));
         }
       }
     });
     KernelCapturedScope scope = _scopesCapturedInClosureMap[node];
     if (scope == null) return;
     _scopesCapturedInClosureMap[node] = new KernelCapturedLoopScope(
         scope.boxedVariables,
         boxedLoopVariables,
         scope.context,
         scope.localsUsedInTryOrSync,
         scope.freeVariables,
         _localsMap,
         scope.thisLocal);
   }
 
   void visitInvokable(ir.TreeNode node) {
     bool oldIsInsideClosure = _isInsideClosure;
     ir.Node oldExecutableContext = _executableContext;
     KernelScopeInfo oldScopeInfo = _currentScopeInfo;
     Local 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, _localsMap);
     if (_isInsideClosure) {
       _closuresToGenerate[node] = _currentScopeInfo;
-      _currentLocalFunction = _kernelToElementMap.getLocalFunction(node.parent);
+      _currentLocalFunction = _localsMap.getLocalFunction(node.parent);
     } else {
       _outermostNode = node;
       _scopeInfoMap[_currentMember] = _currentScopeInfo;
     }
 
     enterNewScope(node, () {
       node.visitChildren(this);
     });
 
     KernelScopeInfo savedScopeInfo = _currentScopeInfo;
@@ skipping 32 matching lines @@
   }
 
   void translateConstructorOrProcedure(ir.Node constructorOrProcedure) {
     constructorOrProcedure.accept(this);
   }
 
   void visitFunctionNode(ir.FunctionNode functionNode) {
     visitInvokable(functionNode);
   }
 }