Renamed some scoping classes to make their usage clearer.

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 ClosureScope that can respond to queries
+/// 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 ClosureScopeBuilder extends ir.Visitor {
+class CapturedScopeBuilder extends ir.Visitor {
   /// 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, ClosureScope> _scopesCapturedInClosureMap;
+  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;
 
   /// 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;
@@ skipping 31 matching lines @@
 
   /// The current scope we are in.
   KernelScopeInfo _currentScopeInfo;
 
   final KernelToElementMap _kernelToElementMap;
 
   /// The original entity from which we start the tree-walk to find closure and
   /// scope information.
   final Entity _originalEntity;
 
-  ClosureScopeBuilder(
+  CapturedScopeBuilder(
       this._scopesCapturedInClosureMap,
       this._scopeInfoMap,
       this._originalEntity,
       this._closuresToGenerate,
       this._localsMap,
       this._kernelToElementMap);
 
-  /// Update the [ClosureScope] object corresponding to
+  /// 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));
       }
     }
     if (!capturedVariablesForScope.isEmpty) {
       ThisLocal thisLocal = null;
       if (node is ir.Member && node.isInstanceMember) {
         if (node is ir.Procedure) {
           thisLocal = new ThisLocal(_kernelToElementMap.getMethod(node));
         } else if (node is ir.Field) {
           thisLocal = new ThisLocal(_kernelToElementMap.getField(node));
         }
       } else if (node is ir.Constructor) {
         thisLocal = new ThisLocal(_kernelToElementMap.getConstructor(node));
       }
 
       assert(_scopeInfoMap[_nodeToEntity(node)] != null);
-      _scopesCapturedInClosureMap[node] = new KernelClosureScope(
+      _scopesCapturedInClosureMap[node] = new KernelCapturedScope(
           capturedVariablesForScope,
           _nodeToEntity(_executableContext),
           thisLocal);
     }
   }
 
   Entity _nodeToEntity(ir.Node node) {
     if (node is ir.Member) {
       return _kernelToElementMap.getMember(node);
     } else {
@@ skipping 91 matching lines @@
       // 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));
         }
       }
     });
-    KernelClosureScope scope = _scopesCapturedInClosureMap[node];
+    KernelCapturedScope scope = _scopesCapturedInClosureMap[node];
     if (scope == null) return;
-    _scopesCapturedInClosureMap[node] = new KernelLoopClosureScope(
+    _scopesCapturedInClosureMap[node] = new KernelCapturedLoopScope(
         scope.boxedVariables,
         boxedLoopVariables,
         scope.context,
         scope.thisLocal);
   }
 
   void visitInvokable(ir.TreeNode node) {
     bool oldIsInsideClosure = _isInsideClosure;
     ir.Node oldExecutableContext = _executableContext;
     KernelScopeInfo oldScopeInfo = _currentScopeInfo;
@@ skipping 77 matching lines @@
               nodeToConvert.isInstanceMember)) {
         return new ThisLocal(_kernelToElementMap.getConstructor(nodeToConvert));
       } else if (nodeToConvert is ir.Procedure &&
           nodeToConvert.isInstanceMember) {
         return new ThisLocal(_kernelToElementMap.getMethod(nodeToConvert));
       }
     }
     return null;
   }
 }