Renamed some scoping classes to make their usage clearer.

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/tasks.dart';
 import '../elements/entities.dart';
 import '../kernel/element_map.dart';
@@ skipping 16 matching lines @@
 /// http://matt.might.net/articles/closure-conversion/.
 // TODO(efortuna): Change inheritance hierarchy so that the
 // ClosureConversionTask doesn't inherit from ClosureTask because it's just a
 // glorified timer.
 class KernelClosureConversionTask extends ClosureConversionTask<ir.Node> {
   final KernelToElementMapForBuilding _elementMap;
   final GlobalLocalsMap _globalLocalsMap;
 
   /// Map of the scoping information that corresponds to a particular entity.
   Map<Entity, ScopeInfo> _scopeMap = <Entity, ScopeInfo>{};
-  Map<ir.Node, ClosureScope> _scopesCapturedInClosureMap =
-      <ir.Node, ClosureScope>{};
+  Map<ir.Node, CapturedScope> _scopesCapturedInClosureMap =
+      <ir.Node, CapturedScope>{};
 
   Map<Entity, ClosureRepresentationInfo> _closureRepresentationMap =
       <Entity, ClosureRepresentationInfo>{};
 
   /// Should only be used at the very beginning to ensure we are looking at the
   /// right kind of elements.
   // TODO(efortuna): Remove this map once we have one kernel backend strategy.
   final JsToFrontendMap _kToJElementMap;
 
   KernelClosureConversionTask(Measurer measurer, this._elementMap,
@@ skipping 32 matching lines @@
 
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
   void _buildClosureModel(
       MemberEntity entity,
       Map<ir.TreeNode, ScopeInfo> closuresToGenerate,
       ClosedWorldRefiner closedWorldRefiner) {
     if (_scopeMap.keys.contains(entity)) return;
     ir.Node node = _elementMap.getMemberNode(entity);
     if (_scopesCapturedInClosureMap.keys.contains(node)) return;
-    ClosureScopeBuilder translator = new ClosureScopeBuilder(
+    CapturedScopeBuilder translator = new CapturedScopeBuilder(
         _scopesCapturedInClosureMap,
         _scopeMap,
         entity,
         closuresToGenerate,
         _globalLocalsMap.getLocalsMap(entity),
         _elementMap);
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
         translator.translateLazyInitializer(node);
       }
@@ skipping 44 matching lines @@
       ConstructorBodyEntity constructorBody = entity;
       entity = constructorBody.constructor;
     }
 
     return _scopeMap[entity] ?? getClosureRepresentationInfo(entity);
   }
 
   // TODO(efortuna): Eventually scopesCapturedInClosureMap[node] should always
   // be non-null, and we should just test that with an assert.
   @override
-  ClosureScope getClosureScope(MemberEntity entity) =>
+  CapturedScope getCapturedScope(MemberEntity entity) =>
       _scopesCapturedInClosureMap[_elementMap.getMemberNode(entity)] ??
-      const ClosureScope();
+      const CapturedScope();
 
   @override
   // TODO(efortuna): Eventually scopesCapturedInClosureMap[node] should always
   // be non-null, and we should just test that with an assert.
-  LoopClosureScope getLoopClosureScope(ir.Node loopNode) =>
-      _scopesCapturedInClosureMap[loopNode] ?? const LoopClosureScope();
+  CapturedLoopScope getCapturedLoopScope(ir.Node loopNode) =>
+      _scopesCapturedInClosureMap[loopNode] ?? const CapturedLoopScope();
 
   @override
   // TODO(efortuna): Eventually closureRepresentationMap[node] should always be
   // non-null, and we should just test that with an assert.
   ClosureRepresentationInfo getClosureRepresentationInfo(Entity entity) {
     return _closureRepresentationMap[entity] ??
         const ClosureRepresentationInfo();
   }
 }
 
@@ skipping 30 matching lines @@
   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 KernelClosureScope extends KernelScopeInfo implements ClosureScope {
+class KernelCapturedScope extends KernelScopeInfo implements CapturedScope {
   final Local context;
 
-  KernelClosureScope(Set<Local> boxedVariables, this.context, Local thisLocal)
+  KernelCapturedScope(Set<Local> boxedVariables, this.context, Local thisLocal)
       : super.withBoxedVariables(boxedVariables, thisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
-class KernelLoopClosureScope extends KernelClosureScope
-    implements LoopClosureScope {
+class KernelCapturedLoopScope extends KernelCapturedScope
+    implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
-  KernelLoopClosureScope(Set<Local> boxedVariables, this.boxedLoopVariables,
+  KernelCapturedLoopScope(Set<Local> boxedVariables, this.boxedLoopVariables,
       Local context, Local thisLocal)
       : super(boxedVariables, context, thisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends KernelScopeInfo
     implements ClosureRepresentationInfo, JClass {
   // TODO(efortuna): Generate unique name for each closure class.
@@ skipping 42 matching lines @@
   // that (and the subsequent adjustment here) will follow soon.
   bool get isClosure => false;
 
   bool get isAbstract => false;
 
   // TODO(efortuna): Talk to Johnni.
   JLibrary get library => null;
 
   String toString() => '${jsElementPrefix}class($name)';
 }