Handle parameters in compile_from_dill_test

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 66 matching lines @@
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       builder.globalInferenceResults;
 
-  ClosureClassMaps get _closureToClassMapper => builder.closureToClassMapper;
-
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = DartTypes.getClassContext(type);
       if (typeContext != null) {
         type = builder.types.substByContext(
             type,
             builder.types.asInstanceOf(
                 builder.types.getThisType(contextClass), typeContext));
@@ skipping 32 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(ast.Node node, {bool forGenerativeConstructorBody: false}) {
+  void enterScope(ClosureScope scopeData,
+      {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;
     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);
     } else {
       box = createBox();
     }
@@ skipping 36 matching lines @@
       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,
+  void startFunction(MemberEntity element, ClosureClassMap closureData,
+      ClosureScope scopeData, Map<Local, TypeMask> parameters,
       {bool isGenerativeConstructorBody}) {
     assert(!(element is MemberElement && !element.isImplementation),
         failedAt(element));
-    closureData = _closureToClassMapper.getMemberMap(element);
+    this.closureData = closureData;
 
-    if (element is MethodElement) {

[Emily Fortuna, 2017/06/07 18:16:42]

perhaps I'm missing something here -- why do we want to move this code out of
here into SSA where it gets replicated twice (in builder and then
builder_kernel.dart)

[Johnni Winther, 2017/06/07 18:34:45]

If we move this (and other pieces) out of the locals handler it doesn't even
need to know about nodes (ast or ir) or signatures. 

Also this is one of these places were (it already looks like) temporarily
duplicating the code will show how it mixes concerns (like with the
Resolution/CodegenEnqueuer split)

[Emily Fortuna, 2017/06/07 19:21:40]

Got it! Thanks for the clarification!

-      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)) {
-            // The parameter will be a field in the box passed as the
-            // last parameter. So no need to have it.
-            return;
-          }
+    parameters.forEach((Local local, TypeMask typeMask) {
+      if (isGenerativeConstructorBody) {
+        if (scopeData != null && scopeData.isCapturedVariable(local)) {
+          // 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;
-        directLocals[parameterElement] = parameter;
-      });
-    }
+      }
+      HInstruction parameter = builder.addParameter(local, typeMask);
+      builder.parameters[local] = parameter;
+      directLocals[local] = parameter;
+    });
 
-    enterScope(node, forGenerativeConstructorBody: isGenerativeConstructorBody);
+    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 78 matching lines @@
   bool isUsedInTryOrGenerator(Local local) {
     return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /// Returns an [HInstruction] for the given element. If the element is
   /// boxed or stored in a closure then the method generates code to retrieve
   /// the value.
   HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
-        if (local is TypeVariableElement) {
-          throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
-              "Runtime type information not available for $local.");
+        if (local is TypeVariableLocal) {
+          throw new SpannableAssertionFailure(
+              CURRENT_ELEMENT_SPANNABLE,
+              "Runtime type information not available for $local "
+              "in $executableContext.");
         } else {
           throw new SpannableAssertionFailure(
-              local, "Cannot find value $local in ${directLocals.keys}.");
+              local,
+              "Cannot find value $local in ${directLocals.keys} for "
+              "$executableContext.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
@@ skipping 135 matching lines @@
   ///    goto loop-entry;
   ///  loop-exit:
   void startLoop(ast.Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     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);
+      enterScope(scopeData);
     }
   }
 
   /// 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);
 
@@ skipping 12 matching lines @@
       }
     });
   }
 
   void enterLoopBody(ast.Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     // 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);
+      enterScope(scopeData);
     }
   }
 
   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];
@@ skipping 148 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)';
 }