Remove KernelScopeInfo.localsMap

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 '../elements/elements.dart';
@@ skipping 116 matching lines @@
   /// 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.
   void _produceSyntheticElements(
       MemberEntity member,
       ir.TreeNode /* ir.Member | ir.FunctionNode */ node,
       ScopeInfo info,
       ClosedWorldRefiner closedWorldRefiner) {
     String name = _computeClosureName(node);
+    KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
     KernelClosureClass closureClass = new KernelClosureClass.fromScopeInfo(
-        name, member.library, info, node.location);
+        name, member.library, info, node.location, localsMap);
 
     Entity entity;
     if (node is ir.Member) {
       entity = member;
     } else {
       assert(node is ir.FunctionNode);
-      KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
       entity = localsMap.getLocalFunction(node.parent);
       // We want the original declaration where that function is used to point
       // to the correct closure class.
       _closureRepresentationMap[closureClass.callMethod] = closureClass;
     }
     assert(entity != null);
     _closureRepresentationMap[entity] = closureClass;
 
     // Register that a new class has been created.
     closedWorldRefiner.registerClosureClass(closureClass);
@@ skipping 86 matching lines @@
 
 class KernelScopeInfo extends ScopeInfo {
   final Set<Local> localsUsedInTryOrSync;
   final Local thisLocal;
   final Set<Local> boxedVariables;
 
   /// The set of variables that were defined in another scope, but are used in
   /// this scope.
   Set<ir.VariableDeclaration> freeVariables = new Set<ir.VariableDeclaration>();
 
-  /// Used to map [freeVariables] to their corresponding locals.
-  final KernelToLocalsMap localsMap;
-
-  KernelScopeInfo(this.thisLocal, this.localsMap)
+  KernelScopeInfo(this.thisLocal)
       : localsUsedInTryOrSync = new Set<Local>(),
         boxedVariables = new Set<Local>();
 
   KernelScopeInfo.from(this.thisLocal, KernelScopeInfo info)
       : localsUsedInTryOrSync = info.localsUsedInTryOrSync,
-        boxedVariables = info.boxedVariables,
-        localsMap = info.localsMap;
+        boxedVariables = info.boxedVariables;
 
-  KernelScopeInfo.withBoxedVariables(
-      this.boxedVariables,
-      this.localsUsedInTryOrSync,
-      this.freeVariables,
-      this.localsMap,
-      this.thisLocal);
+  KernelScopeInfo.withBoxedVariables(this.boxedVariables,
+      this.localsUsedInTryOrSync, this.freeVariables, this.thisLocal);
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
     boxedVariables.forEach((Local l) {
       // TODO(efortuna): add FieldEntities as created.
       f(l, null);
     });
   }
 
   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);
 }
 
 class KernelCapturedScope extends KernelScopeInfo implements CapturedScope {
   final Local context;
 
   KernelCapturedScope(
       Set<Local> boxedVariables,
       this.context,
       Set<Local> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
-      KernelToLocalsMap localsMap,
       Local thisLocal)
-      : super.withBoxedVariables(boxedVariables, localsUsedInTryOrSync,
-            freeVariables, localsMap, thisLocal);
+      : super.withBoxedVariables(
+            boxedVariables, localsUsedInTryOrSync, freeVariables, thisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
 class KernelCapturedLoopScope extends KernelCapturedScope
     implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
   KernelCapturedLoopScope(
       Set<Local> boxedVariables,
       this.boxedLoopVariables,
       Local context,
       Set<Local> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
-      KernelToLocalsMap localsMap,
       Local thisLocal)
       : super(boxedVariables, context, localsUsedInTryOrSync, freeVariables,
-            localsMap, thisLocal);
+            thisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends KernelScopeInfo
     implements ClosureRepresentationInfo, JClass {
   final ir.Location location;
 
   final String name;
   final JLibrary library;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
-  KernelClosureClass.fromScopeInfo(
-      this.name, this.library, KernelScopeInfo info, this.location)
+  KernelClosureClass.fromScopeInfo(this.name, this.library,
+      KernelScopeInfo info, this.location, KernelToLocalsMap localsMap)
       : super.from(info.thisLocal, info) {
     // Make a corresponding field entity in this closure class for every single
     // freeVariable in the KernelScopeInfo.freeVariable.
     int i = 0;
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // NOTE: This construction order may be slightly different than the
       // old Element version. The old version did all the boxed items and then
       // all the others.
-      Local capturedLocal = info.localsMap.getLocalVariable(variable);
+      Local capturedLocal = localsMap.getLocalVariable(variable);
       if (info.isBoxed(capturedLocal)) {
         // TODO(efortuna): Coming soon.
       } else {
         localToFieldMap[capturedLocal] = new ClosureField(
             _getClosureVariableName(capturedLocal.name, i),
             this,
             variable.isConst,
             variable.isFinal || variable.isConst);
         // TODO(efortuna): These probably need to get registered somewhere.
       }
@@ skipping 65 matching lines @@
   ClosureClassDefinition(this.cls, this.location);
 
   ClassKind get kind => ClassKind.closure;
 
   ir.Node get node =>
       throw new UnsupportedError('ClosureClassDefinition.node for $cls');
 
   String toString() =>
       'ClosureClassDefinition(kind:$kind,cls:$cls,location:$location)';
 }