Create new interface instead of ClosureClassMap for variable usage information that is not Element-…

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/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../io/source_information.dart';
@@ skipping 121 matching lines @@
     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(ast.Node node, {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.
-    ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData == null) return;
+    CapturedVariableInfo scopeData =
+        _closureToClassMapper.getCapturedVariableInfo(node);
+    if (!scopeData.hasCapturedVariables()) return;
+    Local localExecutableContext =
+        _closureToClassMapper.getExecutableContext(node);
+
     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(localExecutableContext, commonMasks.nonNullType);
     } else {
       box = createBox();
     }
     // Add the box to the known locals.
-    directLocals[scopeData.boxElement] = box;
+    directLocals[localExecutableContext] = 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(
         (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
         // contains the updates as the last parameter.
         HInstruction instruction = readLocal(from);
         redirectElement(from, to);
         updateLocal(from, instruction);
       } else {
         redirectElement(from, to);
       }
     });
   }
 
   /// 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(
-      BoxLocal boxElement, List<LocalVariableElement> toBeCopiedElements) {
+      Local boxElement, List<LocalVariableElement> toBeCopiedElements) {
     // Create a new box and copy over the values from the old box into the
     // new one.
     HInstruction oldBox = readLocal(boxElement);
     HInstruction newBox = createBox();
     for (LocalVariableElement boxedVariable in toBeCopiedElements) {
       // [readLocal] uses the [boxElement] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /// Documentation wanted -- johnniwinther
   ///
   /// Invariant: [function] must be an implementation element.
   void startFunction(MemberEntity element, ast.Node node,
       {bool isGenerativeConstructorBody}) {
     assert(invariant(
         element, !(element is MemberElement && !element.isImplementation)));
     closureData = _closureToClassMapper.getMemberMap(element);
 
     if (element is MethodElement) {
       MethodElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
-      ClosureScope scopeData = closureData.capturingScopes[node];
       params.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
-          if (scopeData != null &&
-              scopeData.isCapturedVariable(parameterElement)) {
+          if (_closureToClassMapper
+              .getCapturedVariableInfo(node)
+              .isCaptured(parameterElement)) {
             // 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(
             parameterElement,
             TypeMaskFactory.inferredTypeForParameter(
                 parameterElement, _globalInferenceResults));
         builder.parameters[parameterElement] = parameter;
@@ skipping 246 matching lines @@
   ///  <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;
+    CapturedVariableInfo scopeData =
+        _closureToClassMapper.getCapturedVariableInfo(node);
     if (scopeData.hasBoxedLoopVariables()) {
       // 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(node);
     }
   }
 
   /// Create phis at the loop entry for local variables (ready for the values
@@ skipping 13 matching lines @@
           loopEntry.addPhi(phi);
           directLocals[local] = phi;
         } else {
           directLocals[local] = instruction;
         }
       }
     });
   }
 
   void enterLoopBody(ast.Node node) {
-    ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData == null) return;
+    CapturedVariableInfo scopeData =
+        _closureToClassMapper.getCapturedVariableInfo(node);
     // 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(node);
     }
   }
 
   void enterLoopUpdates(ast.Node node) {
     // 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;
+    CapturedVariableInfo scopeData =
+        _closureToClassMapper.getCapturedVariableInfo(node);
     if (scopeData.hasBoxedLoopVariables()) {
-      updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables);
+      updateCaptureBox(_closureToClassMapper.getExecutableContext(node),
+          scopeData.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)';
 }