Order the parameters of a function at the definition site.

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 194 matching lines @@
             HType type = HGraph.mapConstantTypeToSsaType(defaultValue);
             defaultValueTypes.update(index, parameter.name, type);
             index++;
           });
         }
         HTypeList parameterTypes =
             backend.optimisticParameterTypes(element.declaration,
                                              defaultValueTypes);
         if (!parameterTypes.allUnknown) {
           int i = 0;
-          signature.forEachParameter((Element param) {
+          signature.orderedForEachParameter((Element param) {
             builder.parameters[param].guaranteedType = parameterTypes[i++];
           });
         }
         backend.registerParameterTypesOptimization(
             element, parameterTypes, defaultValueTypes);
       }
 
       if (compiler.tracer.enabled) {
         String name;
         if (element.isMember()) {
@@ skipping 132 matching lines @@
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
     assert(invariant(node, function.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             node, builder.elements);
     FunctionSignature signature = function.computeSignature(compiler);
-    signature.forEachParameter((Element element) {
+    signature.orderedForEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
       builder.parameters[element] = parameter;
       directLocals[element] = parameter;
       parameter.guaranteedType =
         builder.mapInferredType(typesTask.getGuaranteedTypeOfElement(element));
     });
 
     enterScope(node);
 
@@ skipping 628 matching lines @@
     stack = <HInstruction>[];
     returnElement = new Element(const SourceString("result"),
                                 ElementKind.VARIABLE,
                                 function);
     localsHandler.updateLocal(returnElement,
                               graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements !== null);
     FunctionSignature signature = function.computeSignature(compiler);
     int index = 0;
-    signature.forEachParameter((Element parameter) {
+    signature.orderedForEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[index++];
       localsHandler.updateLocal(parameter, argument);
       potentiallyCheckType(argument, parameter);
     });
     return state;
   }
 
   void leaveInlinedMethod(InliningState state) {
     InliningState poppedState = inliningStack.removeLast();
     assert(state == poppedState);
@@ skipping 84 matching lines @@
             "Parameters and arguments didn't match for super/redirect call",
             element: constructor);
       }
 
       sourceElementStack.add(constructor.enclosingElement);
       buildFieldInitializers(constructor.enclosingElement, fieldValues);
       sourceElementStack.removeLast();
 
       int index = 0;
       FunctionSignature params = constructor.computeSignature(compiler);
-      params.forEachParameter((Element parameter) {
+      params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
         localsHandler.updateLocal(parameter, argument);
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.kind == ElementKind.FIELD_PARAMETER) {
           FieldParameterElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
@@ skipping 131 matching lines @@
     openFunction(functionElement, function);
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
 
     // Compile the possible initialization code for local fields and
     // super fields.
     buildFieldInitializers(classElement, fieldValues);
 
     // Compile field-parameters such as [:this.x:].
     FunctionSignature params = functionElement.computeSignature(compiler);
-    params.forEachParameter((Element element) {
+    params.orderedForEachParameter((Element element) {
       if (element.kind == ElementKind.FIELD_PARAMETER) {
         // If the [element] is a field-parameter then
         // initialize the field element with its value.
         FieldParameterElement fieldParameterElement = element;
         HInstruction parameterValue = localsHandler.readLocal(element);
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
 
     // Analyze the constructor and all referenced constructors and collect
@@ skipping 27 matching lines @@
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       FunctionSignature functionSignature = body.computeSignature(compiler);
       int arity = functionSignature.parameterCount;
-      functionSignature.forEachParameter((parameter) {
+      functionSignature.orderedForEachParameter((parameter) {
         bodyCallInputs.add(localsHandler.readLocal(parameter));
       });
       // TODO(ahe): The constructor name is statically resolved. See
       // SsaCodeGenerator.visitInvokeDynamicMethod. Is there a cleaner
       // way to do this?
       SourceString name =
           new SourceString(backend.namer.getName(body.declaration));
       // TODO(kasperl): This seems fishy. We shouldn't be inventing all
       // these selectors. Maybe the resolver can do more of the work
       // for us here?
@@ skipping 61 matching lines @@
     assert(invariant(functionElement, functionElement.isImplementation));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     FunctionSignature params = functionElement.computeSignature(compiler);
-    params.forEachParameter((Element element) {
+    params.orderedForEachParameter((Element element) {
       if (elements.isParameterChecked(element)) {
         addParameterCheckInstruction(element);
       }
     });
 
     // Put the type checks in the first successor of the entry,
     // because that is where the type guards will also be inserted.
     // This way we ensure that a type guard will dominate the type
     // check.
-    params.forEachParameter((Element element) {
+    params.orderedForEachParameter((Element element) {
       HInstruction newParameter = potentiallyCheckType(
           localsHandler.directLocals[element], element);
       localsHandler.directLocals[element] = newParameter;
     });
 
     // Add the type parameters of the class as parameters of this
     // method.
     var enclosing = functionElement.enclosingElement;
     if (functionElement.isConstructor() && compiler.world.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
@@ skipping 2920 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }