argNames =
assembleParamNames(parametersList, highestIndex + 1);
changeMethodSignature(argNames, parametersList);
changeBody(argNames);
}
/**
* Iterate through all the references to arguments array in the
* function to determine the real highestIndex. Returns -1 when we should not
* be replacing any arguments for this scope - we should exit tryReplaceArguments
*
* @param highestIndex highest index that has been accessed from the arguments array
*/
private int getHighestIndex(int highestIndex) {
for (Node ref : currentArgumentsAccesses) {
Node getElem = ref.getParent();
// Bail on anything but argument[c] access where c is a constant.
// TODO(user): We might not need to bail out all the time, there might
// be more cases that we can cover.
if (!getElem.isGetElem() || ref != getElem.getFirstChild()) {
return -1;
}
Node index = ref.getNext();
// We have something like arguments[x] where x is not a constant. That
// means at least one of the access is not known.
if (!index.isNumber() || index.getDouble() < 0) {
// TODO(user): Its possible not to give up just yet. The type
// inference did a 'semi value propagation'. If we know that string
// is never a subclass of the type of the index. We'd know that
// it is never 'callee'.
return -1; // Give up.
}
//We want to bail out if someone tries to access arguments[0.5] for example
if (index.getDouble() != Math.floor(index.getDouble())){
return -1;
}
Node getElemParent = getElem.getParent();
// When we have argument[0](), replacing it with a() is semantically
// different if argument[0] is a function call that refers to 'this'
if (getElemParent.isCall() && getElemParent.getFirstChild() == getElem) {
// TODO(user): We can consider using .call() if aliasing that
// argument allows shorter alias for other arguments.
return -1;
}
// Replace the highest index if we see an access that has a higher index
// than all the one we saw before.
int value = (int) index.getDouble();
if (value > highestIndex) {
highestIndex = value;
}
}
return highestIndex;
}
/**
* Inserts new formal parameters into the method's signature based on the given set of names.
*
* Example: function() --> function(r0, r1, r2)
*
* @param argNames maps param index to param name, if the param with that index has a name.
* @param paramList node representing the function signature
*/
private void changeMethodSignature(ImmutableSortedMap argNames, Node paramList) {
ImmutableSortedMap newParams = argNames.tailMap(paramList.getChildCount());
for (String name : newParams.values()) {
paramList.addChildToBack(IR.name(name).useSourceInfoIfMissingFrom(paramList));
}
if (!newParams.isEmpty()) {
compiler.reportChangeToEnclosingScope(paramList);
}
}
/**
* Performs the replacement of arguments[x] -> a if x is known.
*
* @param argNames maps param index to param name, if the param with that index has a name.
*/
private void changeBody(ImmutableMap argNames) {
for (Node ref : currentArgumentsAccesses) {
Node index = ref.getNext();
Node parent = ref.getParent();
int value = (int) index.getDouble(); // This was validated earlier.
@Nullable String name = argNames.get(value);
if (name == null) {
continue;
}
Node newName = IR.name(name).useSourceInfoIfMissingFrom(parent);
parent.replaceWith(newName);
// TODO(nickreid): See if we can do this fewer times. The accesses may be in different scopes.
compiler.reportChangeToEnclosingScope(newName);
}
}
/**
* Generates a {@link Map} from argument indices to parameter names.
*
* A {@link Map} is used because the sequence may be sparse in the case that there is an
* anonymous param, such as a destructuring param. There may also be fewer returned names than
* {@code maxCount} if there is a rest param, since no additional params may be synthesized.
*
* @param maxCount The maximum number of argument names in the returned map.
*/
private ImmutableSortedMap assembleParamNames(Node paramList, int maxCount) {
checkArgument(paramList.isParamList(), paramList);
ImmutableSortedMap.Builder builder = ImmutableSortedMap.naturalOrder();
int index = 0;
// Collect all existing param names first...
for (Node param = paramList.getFirstChild(); param != null; param = param.getNext()) {
switch (param.getToken()) {
case NAME:
builder.put(index, param.getString());
break;
case REST:
return builder.build();
case DEFAULT_VALUE:
// `arguments` doesn't consider default values. It holds exactly the provided args.
case OBJECT_PATTERN:
case ARRAY_PATTERN:
// Patterns have no names to substitute into the body.
break;
default:
throw new IllegalArgumentException(param.toString());
}
index++;
}
// ... then synthesize any additional param names.
for (; index < maxCount; index++) {
builder.put(index, paramPrefix + uniqueId++);
}
return builder.build();
}
}