Test the CapturedScope for local functions

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 70 matching lines @@
   /// 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
   /// [ClosureClassMap.useLocal].
   bool localIsUsedInTryOrSync(Local variable) => false;
+
+  String toString() => 'ScopeInfo()';
 }
 
 /// Class representing the usage of a scope that has been captured in the
 /// context of a closure.
 class CapturedScope extends ScopeInfo {
   const CapturedScope();
 
   /// Loop through each variable that has been defined in this scope, modified
   /// anywhere (this scope or another scope) and used in another scope. Because
   /// it is used in another scope, these variables need to be "boxed", creating
   /// a thin wrapper around accesses to these variables so that accesses get
   /// the correct updated value. The variables in localsUsedInTryOrSync may
   /// be included in this set.
   ///
   /// In the case of loops, this is the set of iteration variables (or any
   /// 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;
 
-  /// 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;
+  /// If `true` this scope requires a `box`. A box is a JavaScript object that
+  /// holds all mutated variables declared in this scope that are accessed in
+  /// another scope.
+  bool get hasBox => false;

[Emily Fortuna, 2017/08/22 23:47:36]

this naming of "context" was suggested by Siggi to distinguish between the
"context" boxes here and the boxing that happens wrapping specific variables.

I'd prefer to keep it. why change it?

[Johnni Winther, 2017/08/23 07:47:17]

[context] _is_ the box, i.e. the JS object that holds the boxed variables (at
least in my CLs). 

 
-  /// Accessor to the local environment in which a particular closure node is
-  /// executed. This will encapsulate the value of any variables that have been
-  /// scoped into this context from outside. This is an accessor to the
-  /// contextBox that [requiresContextBox] is testing is required.
-  Local get context => null;
+  /// Accessor to the box created for this scope. If [hasBox] is `false`,
+  /// `null` is returned.
+  ///
+  /// The box is a JavaScript object that holds all mutated variables declared
+  /// in this scope that are accessed in another scope.
+  Local get box => null;
+
+  String toString() => 'CapturedScope()';
 }
 
 /// Class that describes the actual mechanics of how values of variables
 /// instantiated in a loop are captured inside closures in the loop body.
 /// Unlike JS, the value of a declared loop iteration variable in any closure
 /// is captured/snapshotted inside at each iteration point, as if we created a
 /// new local variable for that value inside the loop. For example, for the
 /// following loop:
 ///
 ///     var lst = [];
@@ skipping 20 matching lines @@
   ///     run(f) => f();
   ///     var a;
   ///     for (int i = 0; i < 3; i++) {
   ///       var b = 3;
   ///       a = () => b = i;
   ///     }
   ///
   /// `i` would be a part of the boxedLoopVariables AND boxedVariables, but b
   /// would only be a part of boxedVariables.
   List<Local> get boxedLoopVariables => const <Local>[];
+
+  String toString() => 'CapturedLoopScope()';
 }
 
 /// Class that describes the actual mechanics of how the converted, rewritten
 /// closure is implemented. For example, for the following closure (named foo
 /// for convenience):
 ///
 ///   var foo = (x) => y + x;
 ///
 /// We would produce the following class to control access to these variables in
 /// the following way (modulo naming of variables, assuming that y is modified
@@ skipping 43 matching lines @@
 
   /// Convenience pointer to the field entity representation in the closure
   /// class of the element representing `this`.
   FieldEntity get thisFieldEntity => null;
 
   /// Loop through every variable that has been captured in this closure. This
   /// consists of all the free variables (variables captured *just* in this
   /// closure) and all variables captured in nested scopes that we may be
   /// capturing as well. These nested scopes hold "boxes" to hold the executable
   /// context for that scope.
+  // TODO(johnniwinther,efortuna): Remove the need for this. It is now only
+  // used in inference.
   void forEachCapturedVariable(f(Local from, FieldEntity to)) {}
 
   /// Loop through each variable that has been boxed in this closure class. Only
   /// captured variables that are mutated need to be "boxed" (which basically
   /// puts a thin layer between updates and reads to this variable to ensure
   /// that every place that accesses it gets the correct updated value). This
   /// includes looping over variables that were boxed from other scopes, not
   /// strictly variables defined in this closure, unlike the behavior in
   /// the superclass ScopeInfo.
+  // TODO(johnniwinther,efortuna): Remove the need for this. It is now only
+  // used in inference.
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {}
 
   /// Loop through each free variable in this closure. Free variables are the
   /// variables that have been captured *just* in this closure, not in nested
   /// scopes.
   void forEachFreeVariable(f(Local variable, FieldEntity field)) {}
 
   /// Return true if [variable] has been captured and mutated (all other
   /// variables do not require boxing).
+  // TODO(johnniwinther,efortuna): Remove the need for this. It is now only
+  // used in inference.
   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, CapturedScopeImpl> _closureInfoMap = <Node, CapturedScopeImpl>{};
@@ skipping 15 matching lines @@
     createClosureClasses(closedWorldRefiner);
   }
 
   CapturedScope _getCapturedScope(Node node) {
     var value = _closureInfoMap[node];
     return value == null ? const CapturedScope() : value;
   }
 
   CapturedScope getCapturedScope(covariant MemberElement member) {
     ResolvedAst resolvedAst = member.resolvedAst;
-    if (resolvedAst.kind != ResolvedAstKind.PARSED)
+    if (resolvedAst.kind != ResolvedAstKind.PARSED) {
       return const CapturedScope();
+    }
     return _getCapturedScope(resolvedAst.node);
   }
 
   ScopeInfo getScopeInfo(MemberEntity member) {
     return _getMemberMapping(member);
   }
 
   ClosureRepresentationInfo getClosureInfoForMember(MemberEntity member) {
     return _getMemberMapping(member);
   }
@@ skipping 389 matching lines @@
   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>[];
 
   CapturedScopeImpl(this.boxElement, this.capturedVariables);
 
-  Local get context => boxElement;
+  Local get box => boxElement;
 
-  bool get requiresContextBox => capturedVariables.keys.isNotEmpty;
+  bool get hasBox => boxElement != null;
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
     capturedVariables.forEach(f);
   }
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 
   bool isBoxed(Local variable) {
     return capturedVariables.containsKey(variable);
   }
@@ skipping 851 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;
 }