Test the CapturedScope for local functions

pkg/compiler/lib/src/ssa/locals_handler.dart

 // Copyright (c) 2016, 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 '../closure.dart';
 import '../common.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../io/source_information.dart';
@@ skipping 112 matching lines @@
         cachedTypesOfCapturedVariables = other.cachedTypesOfCapturedVariables;
 
   /// Redirects accesses from element [from] to element [to]. The [to] element
   /// must be a boxed variable or a variable that is stored in a closure-field.
   void redirectElement(Local from, FieldEntity to) {
     assert(_redirectionMapping[from] == null);
     _redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
-  HInstruction createBox() {
+  HInstruction createBoxObject() {
     HInstruction box = new HCreateBox(commonMasks.nonNullType);
     builder.add(box);
     return box;
   }
 
   /// If the scope (function or loop) [node] has captured variables then this
   /// method creates a box and sets up the redirections.
   void enterScope(CapturedScope closureInfo,
       {bool forGenerativeConstructorBody: false}) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
-    if (!closureInfo.requiresContextBox) return;
-    HInstruction box;
+    if (!closureInfo.hasBox) return;
+    HInstruction boxObject;
     // The scope has captured variables.
     if (forGenerativeConstructorBody) {
       // The box is passed as a parameter to a generative
       // constructor body.
-      box = builder.addParameter(closureInfo.context, commonMasks.nonNullType);
+      boxObject =
+          builder.addParameter(closureInfo.box, commonMasks.nonNullType);
     } else {
-      box = createBox();
+      boxObject = createBoxObject();
     }
     // Add the box to the known locals.
-    directLocals[closureInfo.context] = box;
+    directLocals[closureInfo.box] = boxObject;
     // Make sure that accesses to the boxed locals go into the box. We also
     // need to make sure that parameters are copied into the box if necessary.
     closureInfo.forEachBoxedVariable((_from, _to) {
       Local from = _from;
       FieldEntity to = _to;
       // The [from] can only be a parameter for function-scopes and not
       // loop scopes.
       bool isParameter =
           // TODO(johnniwinther): Avoid this hack. Maybe [Local] should have an
           // [isParameter] property?
@@ skipping 16 matching lines @@
       }
     });
   }
 
   /// Replaces the current box with a new box and copies over the given list
   /// of elements from the old box into the new box.
   void updateCaptureBox(Local currentBox, List<Local> toBeCopiedElements) {
     // Create a new box and copy over the values from the old box into the
     // new one.
     HInstruction oldBox = readLocal(currentBox);
-    HInstruction newBox = createBox();
+    HInstruction newBox = createBoxObject();
     for (Local boxedVariable in toBeCopiedElements) {
       // [readLocal] uses the [currentBox] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(currentBox, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(currentBox, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(currentBox, newBox);
   }
@@ skipping 340 matching lines @@
     }
   }
 
   void enterLoopUpdates(CapturedLoopScope loopInfo) {
     // If there are declared boxed loop variables then the updates might have
     // access to the box and we must switch to a new box before executing the
     // updates.
     // In all other cases a new box will be created when entering the body of
     // the next iteration.
     if (loopInfo.hasBoxedLoopVariables) {
-      updateCaptureBox(loopInfo.context, loopInfo.boxedLoopVariables);
+      updateCaptureBox(loopInfo.box, loopInfo.boxedLoopVariables);
     }
   }
 
   /// Goes through the phis created in beginLoopHeader entry and adds the
   /// input from the back edge (from the current value of directLocals) to them.
   void endLoop(HBasicBlock loopEntry) {
     // If the loop has an aborting body, we don't update the loop
     // phis.
     if (loopEntry.predecessors.length == 1) return;
     loopEntry.forEachPhi((HPhi phi) {
@@ skipping 135 matching lines @@
   final MemberEntity memberContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext, this.memberContext);
 
   toString() => 'SyntheticLocal($name)';
 }