Use the parameterNames map to allocate names for HParameterValue. In case of native methods, we mus…

dart/lib/compiler/implementation/ssa/variable_allocator.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.
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
   final int start;
   // [end] is not final because it can be updated due to loops.
@@ skipping 367 matching lines @@
     handler.addAssignment(source, destination);
   }
 }
 
 /**
  * Allocates variable names for instructions, making sure they don't collide.
  */
 class VariableNamer {
   final VariableNames names;
   final Set<String> usedNames;
+  final Map<Element, String> parameterNames;
 
-  VariableNamer(LiveEnvironment environment, this.names)
+  VariableNamer(LiveEnvironment environment, this.names, this.parameterNames)
     : usedNames = new Set<String>() {
     // [VariableNames.SWAP_TEMP] is being used when there is a cycle
     // in a copy handler. Therefore we make sure no one will use it.
     usedNames.add(VariableNames.SWAP_TEMP);
 
     // All liveIns instructions must have a name at this point, so we
     // add them to the list of used names.
     environment.liveInstructions.forEach((HInstruction instruction, int index) {
       String name = names.getName(instruction);
       if (name !== null) {
@@ skipping 35 matching lines @@
       // Special case the check instruction to use the name of its
       // checked instruction.
       HCheck check = instruction;
       name = names.ownName[check.checkedInput];
       // If the name is null, then the checked input is being
       // generated at use site, and we don't need a name for the check
       // instruction.
       if (name == null) return;
     } else if (instruction is HParameterValue) {
       HParameterValue parameter = instruction;
-      name = allocateWithHint(parameter.element.name.slowToString());
+      name = parameterNames[parameter.element];
+      if (name == null) {
+        name = allocateWithHint(parameter.element.name.slowToString());
+      }
     } else if (instruction.sourceElement !== null) {
       name = allocateWithHint(instruction.sourceElement.name.slowToString());
     } else {
       // We could not find an element for the instruction. If the
       // instruction is used by a phi, try to use the name of the phi.
       // Otherwise, just allocate a temporary name.
       HPhi phi = firstPhiUserWithElement(instruction);
       if (phi !== null) {
         name = allocateWithHint(phi.sourceElement.name.slowToString());
       } else {
@@ skipping 27 matching lines @@
  * instruction, it frees the names of the inputs that die at that
  * instruction, and allocates a name to the instruction. For each phi,
  * it adds a copy to the CopyHandler of the corresponding predecessor.
  */
 class SsaVariableAllocator extends HBaseVisitor {
 
   final Compiler compiler;
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
   final Map<HInstruction, LiveInterval> liveIntervals;
   final Set<HInstruction> generateAtUseSite;
+  final Map<Element, String> parameterNames;
 
   final VariableNames names;
 
   SsaVariableAllocator(this.compiler,
                        this.liveInstructions,
                        this.liveIntervals,
-                       this.generateAtUseSite)
+                       this.generateAtUseSite,
+                       this.parameterNames)
     : names = new VariableNames();
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
-    VariableNamer namer = new VariableNamer(liveInstructions[block], names);
+    VariableNamer namer = new VariableNamer(
+        liveInstructions[block], names, parameterNames);
 
     block.forEachPhi((HPhi phi) {
       handlePhi(phi, namer);
     });
 
     block.forEachInstruction((HInstruction instruction) {
       handleInstruction(instruction, namer);
     });
   }
 
@@ skipping 45 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }