Reapply "Separate out loop closure information."

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 118 matching lines @@
   }
 
   HInstruction createBox() {
     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(ClosureScope scopeData,
+  void enterScope(ClosureAnalysisInfo 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 (scopeData == null) return;
+    if (!closureInfo.requiresContextBox()) return;
     HInstruction box;
     // The scope has captured variables.
     if (forGenerativeConstructorBody) {
       // The box is passed as a parameter to a generative
       // constructor body.
-      box = builder.addParameter(scopeData.boxElement, commonMasks.nonNullType);
+      box = builder.addParameter(closureInfo.context, commonMasks.nonNullType);
     } else {
       box = createBox();
     }
     // Add the box to the known locals.
-    directLocals[scopeData.boxElement] = box;
+    directLocals[closureInfo.context] = box;
     // 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.
-    scopeData.forEachCapturedVariable(
+    closureInfo.forEachCapturedVariable(
         (LocalVariableElement from, BoxFieldElement to) {
       // The [from] can only be a parameter for function-scopes and not
       // loop scopes.
       if (from.isRegularParameter && !forGenerativeConstructorBody) {
         // Now that the redirection is set up, the update to the local will
         // write the parameter value into the box.
         // Store the captured parameter in the box. Get the current value
         // before we put the redirection in place.
         // We don't need to update the local for a generative
         // constructor body, because it receives a box that already
@@ skipping 41 matching lines @@
           // The parameter will be a field in the box passed as the
           // last parameter. So no need to have it.
           return;
         }
       }
       HInstruction parameter = builder.addParameter(local, typeMask);
       builder.parameters[local] = parameter;
       directLocals[local] = parameter;
     });
 
-    enterScope(scopeData,
-        forGenerativeConstructorBody: isGenerativeConstructorBody);
+    if (scopeData != null) {
+      // TODO(efortuna): Remove the above if wrapper (always execute this step)
+      // when the switch away from ClosureClassMap is complete (prior behavior
+      // in enterScope it was acceptable to pass in a null scopeData, but no
+      // longer).
+      enterScope(scopeData,
+          forGenerativeConstructorBody: isGenerativeConstructorBody);
+    }
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.forEachFreeVariable((Local from, FieldEntity to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction =
@@ skipping 235 matching lines @@
   /// We solve this by emitting the following code (only for [ast.For] loops):
   ///  <Create box>    <== move the first box creation outside the loop.
   ///  <initializer>;
   ///  loop-entry:
   ///    if (!<condition>) goto loop-exit;
   ///    <body>
   ///    <update box>  // create a new box and copy the captured loop-variables.
   ///    <updates>
   ///    goto loop-entry;
   ///  loop-exit:
-  void startLoop(ast.Node node) {
-    ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData == null) return;
-    if (scopeData.hasBoxedLoopVariables()) {
+  void startLoop(LoopClosureRepresentationInfo loopInfo) {
+    if (loopInfo.hasBoxedVariables) {
       // If there are boxed loop variables then we set up the box and
       // redirections already now. This way the initializer can write its
       // values into the box.
       // For other loops the box will be created when entering the body.
-      enterScope(scopeData);
+      enterScope(loopInfo);
     }
   }
 
   /// Create phis at the loop entry for local variables (ready for the values
   /// from the back edge).  Populate the phis with the current values.
   void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
     Map<Local, HInstruction> savedDirectLocals =
         new Map<Local, HInstruction>.from(directLocals);
 
     // Create phis for all elements in the definitions environment.
     savedDirectLocals.forEach((Local local, HInstruction instruction) {
       if (isAccessedDirectly(local)) {
         // We know 'this' cannot be modified.
         if (local != closureData.thisLocal) {
           HPhi phi =
               new HPhi.singleInput(local, instruction, commonMasks.dynamicType);
           loopEntry.addPhi(phi);
           directLocals[local] = phi;
         } else {
           directLocals[local] = instruction;
         }
       }
     });
   }
 
-  void enterLoopBody(ast.Node node) {
-    ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData == null) return;
+  void enterLoopBody(LoopClosureRepresentationInfo loopInfo) {
     // If there are no declared boxed loop variables then we did not create the
     // box before the initializer and we have to create the box now.
-    if (!scopeData.hasBoxedLoopVariables()) {
-      enterScope(scopeData);
+    if (!loopInfo.hasBoxedVariables) {
+      enterScope(loopInfo);
     }
   }
 
-  void enterLoopUpdates(ast.Node node) {
+  void enterLoopUpdates(LoopClosureRepresentationInfo 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.
-    ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData == null) return;
-    if (scopeData.hasBoxedLoopVariables()) {
-      updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables);
+    if (loopInfo.hasBoxedVariables) {
+      updateCaptureBox(loopInfo.context, loopInfo.boxedVariables);
     }
   }
 
   /// 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)';
 }