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) {
-      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)';
 }