private static JetParameterList replaceParameterListAndKeepDelimiters(
JetParameterList parameterList, JetParameterList newParameterList) {
List<JetParameter> oldParameters = parameterList.getParameters();
List<JetParameter> newParameters = newParameterList.getParameters();
int oldCount = oldParameters.size();
int newCount = newParameters.size();
int commonCount = Math.min(oldCount, newCount);
for (int i = 0; i < commonCount; i++) {
oldParameters.set(i, (JetParameter) oldParameters.get(i).replace(newParameters.get(i)));
}
if (commonCount == 0) return (JetParameterList) parameterList.replace(newParameterList);
if (oldCount > commonCount) {
parameterList.deleteChildRange(
oldParameters.get(commonCount - 1).getNextSibling(), KotlinPackage.last(oldParameters));
} else if (newCount > commonCount) {
parameterList.addRangeAfter(
newParameters.get(commonCount - 1).getNextSibling(),
newParameterList.getLastChild().getPrevSibling(),
PsiTreeUtil.skipSiblingsBackward(
parameterList.getLastChild(), PsiWhiteSpace.class, PsiComment.class));
}
return parameterList;
}
@Override
public boolean processUsage(JetChangeInfo changeInfo, PsiElement element) {
JetParameterList parameterList;
JetPsiFactory psiFactory = JetPsiFactory(element.getProject());
if (element instanceof JetFunction) {
JetFunction function = (JetFunction) element;
parameterList = function.getValueParameterList();
if (changeInfo.isNameChanged()) {
PsiElement identifier = function.getNameIdentifier();
if (identifier != null) {
identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName()));
}
}
boolean returnTypeIsNeeded =
(changeInfo.isRefactoringTarget(originalFunctionDescriptor)
|| !(function instanceof JetFunctionLiteral)
|| function.getTypeReference() != null)
&& !(function instanceof JetSecondaryConstructor);
if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) {
function.setTypeReference(null);
String returnTypeText =
changeInfo.renderReturnType((JetFunctionDefinitionUsage<PsiElement>) this);
// TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready
if (!KotlinBuiltIns.getInstance().getUnitType().toString().equals(returnTypeText)) {
ShortenPackage.addToShorteningWaitSet(
function.setTypeReference(JetPsiFactory(function).createType(returnTypeText)),
Options.DEFAULT);
}
}
} else {
parameterList = ((JetClass) element).getPrimaryConstructorParameterList();
}
if (changeInfo.isParameterSetOrOrderChanged()) {
processParameterListWithStructuralChanges(changeInfo, element, parameterList, psiFactory);
} else if (parameterList != null) {
int paramIndex = 0;
for (JetParameter parameter : parameterList.getParameters()) {
JetParameterInfo parameterInfo = changeInfo.getNewParameters()[paramIndex];
changeParameter(paramIndex, parameter, parameterInfo);
paramIndex++;
}
ShortenPackage.addToShorteningWaitSet(parameterList, Options.DEFAULT);
}
if (element instanceof JetFunction && changeInfo.isReceiverTypeChanged()) {
//noinspection unchecked
String receiverTypeText =
changeInfo.renderReceiverType((JetFunctionDefinitionUsage<PsiElement>) this);
JetTypeReference receiverTypeRef =
receiverTypeText != null ? psiFactory.createType(receiverTypeText) : null;
JetTypeReference newReceiverTypeRef =
TypeRefHelpersPackage.setReceiverTypeReference((JetFunction) element, receiverTypeRef);
if (newReceiverTypeRef != null) {
ShortenPackage.addToShorteningWaitSet(
newReceiverTypeRef, ShortenReferences.Options.DEFAULT);
}
}
if (changeInfo.isVisibilityChanged() && !JetPsiUtil.isLocal((JetDeclaration) element)) {
changeVisibility(changeInfo, element);
}
return true;
}