Renamed some scoping classes to make their usage clearer.

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
@@ skipping 35 matching lines @@
   // one for local functions.
   ScopeInfo getScopeInfo(covariant Entity member);
 
   /// This returns the same information as ScopeInfo, but can be called in
   /// situations when you are sure you are dealing with a closure specifically.
   ClosureRepresentationInfo getClosureRepresentationInfo(
       covariant Entity member);
 
   /// Look up information about a loop, in case any variables it declares need
   /// to be boxed/snapshotted.
-  LoopClosureScope getLoopClosureScope(T loopNode);
+  CapturedLoopScope getCapturedLoopScope(T loopNode);
 
-  /// Accessor to the information about closures that the SSA builder will use.
-  ClosureScope getClosureScope(MemberEntity entity);
+  /// Accessor to the information about scopes that closures capture. Used by
+  /// the SSA builder.
+  CapturedScope getCapturedScope(MemberEntity entity);
 }
 
 /// Class that represents one level of scoping information, whether this scope
 /// is a closure or not. This is specifically used to store information
 /// about the usage of variables in try or sync blocks, because they need to be
 /// boxed.
 ///
 /// Variables that are used in a try must be treated as boxed because the
 /// control flow can be non-linear. Also parameters to a `sync*` generator must
 /// be boxed, because of the way we rewrite sync* functions. See also comments
@@ skipping 28 matching lines @@
   /// variables declared in the for loop expression (`for (...here...)`) that
   /// need to be boxed to snapshot their value.
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {}
 
   /// True if [variable] has been mutated and is also used in another scope.
   bool isBoxed(Local variable) => false;
 }
 
 /// Class representing the usage of a scope that has been captured in the
 /// context of a closure.
-class ClosureScope extends ScopeInfo {
-  const ClosureScope();
+class CapturedScope extends ScopeInfo {
+  const CapturedScope();
 
   /// If true, this closure accesses a variable that was defined in an outside
   /// scope and this variable gets modified at some point (sometimes we say that
   /// variable has been "captured"). In this situation, access to this variable
   /// is controlled via a wrapper (box) so that updates to this variable
   /// are done in a way that is in line with Dart's closure rules.
   bool get requiresContextBox => false;
 
   /// Accessor to the local environment in which a particular closure node is
   /// executed. This will encapsulate the value of any variables that have been
@@ skipping 10 matching lines @@
 /// following loop:
 ///
 ///     var lst = [];
 ///     for (int i = 0; i < 5; i++) lst.add(()=>i);
 ///     var result = list.map((f) => f()).toList();
 ///
 /// `result` will be [0, 1, 2, 3, 4], whereas were this JS code
 /// the result would be [5, 5, 5, 5, 5]. Because of this difference we need to
 /// create a closure for these sorts of loops to capture the variable's value at
 /// each iteration, by boxing the iteration variable[s].
-class LoopClosureScope extends ClosureScope {
-  const LoopClosureScope();
+class CapturedLoopScope extends CapturedScope {
+  const CapturedLoopScope();
 
   /// True if this loop scope declares in the first part of the loop
   /// `for (<here>;...;...)` any variables that need to be boxed.
   bool get hasBoxedLoopVariables => false;
 
   /// The set of iteration variables (or variables declared in the for loop
   /// expression (`for (<here>; ... ; ...)`) that need to be boxed to snapshot
   /// their value. These variables are also included in the set of
   /// `forEachBoxedVariable` method. The distinction between these two sets is
   /// in this example:
@@ skipping 92 matching lines @@
   /// variables do not require boxing).
   bool isVariableBoxed(Local variable) => false;
 
   // TODO(efortuna): Remove this method. The old system was using
   // ClosureClassMaps for situations other than closure class maps, and that's
   // just confusing.
   bool get isClosure => false;
 }
 
 class ClosureTask extends ClosureConversionTask<Node> {
-  Map<Node, ClosureScopeImpl> _closureInfoMap = <Node, ClosureScopeImpl>{};
+  Map<Node, CapturedScopeImpl> _closureInfoMap = <Node, CapturedScopeImpl>{};
   Map<Element, ClosureClassMap> _closureMappingCache =
       <Element, ClosureClassMap>{};
   Compiler compiler;
   ClosureTask(Compiler compiler)
       : compiler = compiler,
         super(compiler.measurer);
 
   String get name => "Closure Simplifier";
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
     createClosureClasses(closedWorldRefiner);
   }
 
-  ClosureScope _getClosureScope(Node node) {
+  CapturedScope _getCapturedScope(Node node) {
     var value = _closureInfoMap[node];
-    return value == null ? const ClosureScope() : value;
+    return value == null ? const CapturedScope() : value;
   }
 
-  ClosureScope getClosureScope(covariant MemberElement member) {
+  CapturedScope getCapturedScope(covariant MemberElement member) {
     ResolvedAst resolvedAst = member.resolvedAst;
-    if (resolvedAst.kind != ResolvedAstKind.PARSED) return const ClosureScope();
-    return _getClosureScope(resolvedAst.node);
+    if (resolvedAst.kind != ResolvedAstKind.PARSED)
+      return const CapturedScope();
+    return _getCapturedScope(resolvedAst.node);
   }
 
   ScopeInfo getScopeInfo(Element member) {
     return getClosureToClassMapping(member);
   }
 
   ClosureRepresentationInfo getClosureRepresentationInfo(Element member) {
     return getClosureToClassMapping(member);
   }
 
-  LoopClosureScope getLoopClosureScope(Node loopNode) {
+  CapturedLoopScope getCapturedLoopScope(Node loopNode) {
     var value = _closureInfoMap[loopNode];
-    return value == null ? const LoopClosureScope() : value;
+    return value == null ? const CapturedLoopScope() : value;
   }
 
   /// Returns the [ClosureClassMap] computed for [resolvedAst].
   ClosureClassMap getClosureToClassMapping(Element element) {
     return measure(() {
       if (element.isGenerativeConstructorBody) {
         ConstructorBodyElement constructorBody = element;
         element = constructorBody.constructor;
       }
       ClosureClassMap closureClassMap = _closureMappingCache[element];
@@ skipping 345 matching lines @@
         expression.compilationUnit.script.resourceUri);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
-class ClosureScopeImpl implements ClosureScope, LoopClosureScope {
+class CapturedScopeImpl implements CapturedScope, CapturedLoopScope {
   final BoxLocal boxElement;
   final Map<Local, BoxFieldElement> capturedVariables;
 
   // If the scope is attached to a [For] contains the variables that are
   // declared in the initializer of the [For] and that need to be boxed.
   // Otherwise contains the empty List.
   List<Local> boxedLoopVariables = const <Local>[];
 
-  ClosureScopeImpl(this.boxElement, this.capturedVariables);
+  CapturedScopeImpl(this.boxElement, this.capturedVariables);
 
   Local get context => boxElement;
 
   bool get requiresContextBox => capturedVariables.keys.isNotEmpty;
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
     capturedVariables.forEach(f);
   }
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 
   bool isBoxed(Local variable) {
     return capturedVariables.containsKey(variable);
   }
 
   void forEachCapturedVariable(
       f(LocalVariableElement variable, BoxFieldElement boxField)) {
     capturedVariables.forEach(f);
   }
 
   // Should not be called. Added to make the new interface happy.
   bool localIsUsedInTryOrSync(Local variable) =>
-      throw new UnsupportedError("ClosureScopeImpl.localIsUsedInTryOrSync");
+      throw new UnsupportedError("CapturedScopeImpl.localIsUsedInTryOrSync");
 
   // Should not be called. Added to make the new interface happy.
   Local get thisLocal =>
-      throw new UnsupportedError("ClosureScopeImpl.thisLocal");
+      throw new UnsupportedError("CapturedScopeImpl.thisLocal");
 
   String toString() {
     String separator = '';
     StringBuffer sb = new StringBuffer();
-    sb.write('ClosureScopeImpl(');
+    sb.write('CapturedScopeImpl(');
     if (boxElement != null) {
       sb.write('box=$boxElement');
       separator = ',';
     }
     if (boxedLoopVariables.isNotEmpty) {
       sb.write(separator);
       sb.write('boxedLoopVariables=${boxedLoopVariables}');
       separator = ',';
     }
     if (capturedVariables.isNotEmpty) {
@@ skipping 23 matching lines @@
   final MethodElement callMethod;
 
   /// The [thisLocal] makes handling 'this' easier by treating it like any
   /// other argument. It is only set for instance-members.
   final ThisLocal thisLocal;
 
   /// Maps free locals, arguments, function elements, and box locals to
   /// their locations.
   final Map<Local, FieldEntity> freeVariableMap = new Map<Local, FieldEntity>();
 
-  /// Maps [Loop] and [FunctionExpression] nodes to their [ClosureScopeImpl] which
+  /// Maps [Loop] and [FunctionExpression] nodes to their [CapturedScopeImpl] which
   /// contains their box and the captured variables that are stored in the box.
   /// This map will be empty if the method/closure of this [ClosureData] does
   /// not contain any nested closure.
-  final Map<Node, ClosureScopeImpl> capturingScopes =
-      new Map<Node, ClosureScopeImpl>();
+  final Map<Node, CapturedScopeImpl> capturingScopes =
+      new Map<Node, CapturedScopeImpl>();
 
   /// Set of [variable]s referenced in this scope that are used inside a
   /// `try` block or a `sync*` generator (this is important to know because
   /// boxing/redirection needs to happen for those local variables).
   ///
   /// Variables that are used in a try must be treated as boxed because the
   /// control flow can be non-linear.
   ///
   /// Also parameters to a `sync*` generator must be boxed, because of the way
   /// we rewrite sync* functions. See also comments in [useLocal].
@@ skipping 50 matching lines @@
       return true;
     }
     return capturingScopesBox(variable);
   }
 
   void forEachCapturedVariable(void f(Local variable, FieldEntity field)) {
     freeVariableMap.forEach((variable, copy) {
       if (variable is BoxLocal) return;
       f(variable, copy);
     });
-    capturingScopes.values.forEach((ClosureScopeImpl scope) {
+    capturingScopes.values.forEach((CapturedScopeImpl scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   void forEachBoxedVariable(
       void f(LocalVariableElement local, BoxFieldElement field)) {
     freeVariableMap.forEach((variable, copy) {
       if (!isVariableBoxed(variable)) return;
       f(variable, copy);
     });
-    capturingScopes.values.forEach((ClosureScopeImpl scope) {
+    capturingScopes.values.forEach((CapturedScopeImpl scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   bool isBoxed(Local local) {
     bool variableIsBoxed = false;
     forEachBoxedVariable((LocalVariableElement element, BoxFieldElement field) {
       if (element == local) variableIsBoxed = true;
     });
     return variableIsBoxed;
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
   final ClosedWorldRefiner closedWorldRefiner;
   final TreeElements elements;
   int closureFieldCounter = 0;
   int boxedFieldCounter = 0;
   bool inTryStatement = false;
 
   final Map<Element, ClosureClassMap> closureMappingCache;
-  final Map<Node, ClosureScopeImpl> closureInfo;
+  final Map<Node, CapturedScopeImpl> closureInfo;
 
   // Map of captured variables. Initially they will map to `null`. If
   // a variable needs to be boxed then the scope declaring the variable
   // will update this to mapping to the capturing [BoxFieldElement].
   Map<Local, BoxFieldElement> _capturedVariableMapping =
       new Map<Local, BoxFieldElement>();
 
   // List of encountered closures.
   List<LocalFunctionElement> closures = <LocalFunctionElement>[];
 
@@ skipping 390 matching lines @@
       }
     }
 
     for (LocalVariableElement variable in scopeVariables) {
       // No need to box non-assignable elements.
       if (!variable.isAssignable) continue;
       if (!mutatedVariables.contains(variable)) continue;
       boxCapturedVariable(variable);
     }
     if (!scopeMapping.isEmpty) {
-      ClosureScopeImpl scope = new ClosureScopeImpl(box, scopeMapping);
+      CapturedScopeImpl scope = new CapturedScopeImpl(box, scopeMapping);
       closureData.capturingScopes[node] = scope;
       assert(closureInfo[node] == null);
       closureInfo[node] = scope;
     }
   }
 
   void inNewScope(Node node, Function action) {
     List<LocalVariableElement> oldScopeVariables = scopeVariables;
     scopeVariables = <LocalVariableElement>[];
     action();
@@ skipping 44 matching lines @@
           link = link.tail) {
         Node definition = link.head;
         LocalVariableElement element = elements[definition];
         // Non-mutated variables should not be boxed.  The mutatedVariables set
         // gets cleared when 'inNewScope' returns, so check it here.
         if (isCapturedVariable(element) && mutatedVariables.contains(element)) {
           boxedLoopVariables.add(element);
         }
       }
     });
-    ClosureScopeImpl scopeData = closureData.capturingScopes[node];
+    CapturedScopeImpl scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     scopeData.boxedLoopVariables = boxedLoopVariables;
   }
 
   /** Returns a non-unique name for the given closure element. */
   String computeClosureName(Element element) {
     Link<String> parts = const Link<String>();
     String ownName = element.name;
     if (ownName == null || ownName == "") {
       parts = parts.prepend("closure");
@@ skipping 199 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements MemberEntity {
   Local get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }