anchor.diff:  ///
   /// We never merge variables that originated from distinct source variables,
   /// so we build a separate register interference graph for each source variable.
  -Map<Variable, Variable> _computeRegisterAllocation(List<Block> blocks) {
  +Map<Variable, Variable> _computeRegisterAllocation(List<Block> blocks,
  +                                                   List<Variable> parameters) {
     Map<Variable, Set<Variable>> interference = <Variable, Set<Variable>>{};
   
     /// Group for the given variable. We attempt to merge variables in the same
     /// group.
  -  /// By default, variables are grouped based on their source variable, but
  -  /// this can be disabled for testing purposes.
  -  Local group(Variable variable) {
  -    if (NO_PRESERVE_VARS) {
  -      // Parameters may not occur more than once in a parameter list,
  -      // so except for parameters, we try to merge all variables.
  -      return variable.element is ParameterElement ? variable.element : null;
  -    }
  -    return variable.element;
  +  /// By default, variables are grouped based on their source variable name,
  +  /// but this can be disabled for testing purposes.
  +  String group(Variable variable) {
  +    if (NO_PRESERVE_VARS) return '';
  +    // Group variables based on the source variable's name, not its element,
  +    // so if multiple locals are declared with the same name, they will
  +    // map to the same (hoisted) variable in the output.
  +    return variable.element == null ? '' : variable.element.name;
     }
   
     Set<Variable> empty = new Set<Variable>();
  
positive.code:   // live after the assignment (if it came from the same source variable).
    for (Block block in blocks) {
      // Group the liveOut set by source variable.
      Map<Local, Set<Variable>> liveOut = <Local, Set<Variable>>{};
      for (Variable variable in block.liveOut) {
        liveOut.putIfAbsent(
            group(variable),
  
negative.code:   List<Variable> variables = interference.keys.toList();
    variables.sort((x, y) => interference[y].length - interference[x].length);
  
    Map<String, List<Variable>> registers = <String, List<Variable>>{};
    Map<Variable, Variable> subst = <Variable, Variable>{};
  
    // Parameters are special in that they must have a ParameterElement and
    // cannot be merged with each other. Ensure that they are not substituted.
    // Other variables can still be substituted by a parameter.
    for (Variable parameter in parameters) {
      subst[parameter] = parameter;
      registers[group(parameter)] = <Variable>[parameter];
    }
  
    for (Variable v1 in variables) {
      // Parameters have already been assigned a substitute; skip those.
      if (subst.containsKey(v1)) continue;
  
      List<Variable> register = registers[group(v1)];
  
      // Optimization: For the first variable in a group, allocate a new color
  