public MultiMap<PsiElement, String> findConflicts(Ref<UsageInfo[]> refUsages) {
MultiMap<PsiElement, String> conflictDescriptions = new MultiMap<PsiElement, String>();
addMethodConflicts(conflictDescriptions);
Set<UsageInfo> usagesSet = new HashSet<UsageInfo>(Arrays.asList(refUsages.get()));
RenameUtil.removeConflictUsages(usagesSet);
if (myChangeInfo.isVisibilityChanged()) {
try {
addInaccessibilityDescriptions(usagesSet, conflictDescriptions);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
for (UsageInfo usageInfo : usagesSet) {
if (usageInfo instanceof OverriderUsageInfo) {
final PsiMethod method = (PsiMethod) usageInfo.getElement();
final PsiMethod baseMethod = ((OverriderUsageInfo) usageInfo).getBaseMethod();
final int delta =
baseMethod.getParameterList().getParametersCount()
- method.getParameterList().getParametersCount();
if (delta > 0) {
final boolean[] toRemove = myChangeInfo.toRemoveParm();
if (toRemove[
toRemove.length - 1]) { // todo check if implicit parameter is not the last one
conflictDescriptions.putValue(
baseMethod, "Implicit last parameter should not be deleted");
}
}
}
}
return conflictDescriptions;
}
private static void processCallerMethod(
JavaChangeInfo changeInfo,
PsiMethod caller,
PsiMethod baseMethod,
boolean toInsertParams,
boolean toInsertThrows)
throws IncorrectOperationException {
LOG.assertTrue(toInsertParams || toInsertThrows);
if (toInsertParams) {
List<PsiParameter> newParameters = new ArrayList<PsiParameter>();
ContainerUtil.addAll(newParameters, caller.getParameterList().getParameters());
final JavaParameterInfo[] primaryNewParms = changeInfo.getNewParameters();
PsiSubstitutor substitutor =
baseMethod == null
? PsiSubstitutor.EMPTY
: ChangeSignatureProcessor.calculateSubstitutor(caller, baseMethod);
for (JavaParameterInfo info : primaryNewParms) {
if (info.getOldIndex() < 0)
newParameters.add(createNewParameter(changeInfo, info, substitutor));
}
PsiParameter[] arrayed = newParameters.toArray(new PsiParameter[newParameters.size()]);
boolean[] toRemoveParm = new boolean[arrayed.length];
Arrays.fill(toRemoveParm, false);
resolveParameterVsFieldsConflicts(arrayed, caller, caller.getParameterList(), toRemoveParm);
}
if (toInsertThrows) {
List<PsiJavaCodeReferenceElement> newThrowns = new ArrayList<PsiJavaCodeReferenceElement>();
final PsiReferenceList throwsList = caller.getThrowsList();
ContainerUtil.addAll(newThrowns, throwsList.getReferenceElements());
final ThrownExceptionInfo[] primaryNewExns = changeInfo.getNewExceptions();
for (ThrownExceptionInfo thrownExceptionInfo : primaryNewExns) {
if (thrownExceptionInfo.getOldIndex() < 0) {
final PsiClassType type =
(PsiClassType) thrownExceptionInfo.createType(caller, caller.getManager());
final PsiJavaCodeReferenceElement ref =
JavaPsiFacade.getInstance(caller.getProject())
.getElementFactory()
.createReferenceElementByType(type);
newThrowns.add(ref);
}
}
PsiJavaCodeReferenceElement[] arrayed =
newThrowns.toArray(new PsiJavaCodeReferenceElement[newThrowns.size()]);
boolean[] toRemoveParm = new boolean[arrayed.length];
Arrays.fill(toRemoveParm, false);
ChangeSignatureUtil.synchronizeList(
throwsList, Arrays.asList(arrayed), ThrowsList.INSTANCE, toRemoveParm);
}
}
private static void resolveParameterVsFieldsConflicts(
final PsiParameter[] newParms,
final PsiMethod method,
final PsiParameterList list,
boolean[] toRemoveParm)
throws IncorrectOperationException {
List<FieldConflictsResolver> conflictResolvers = new ArrayList<FieldConflictsResolver>();
for (PsiParameter parameter : newParms) {
conflictResolvers.add(new FieldConflictsResolver(parameter.getName(), method.getBody()));
}
ChangeSignatureUtil.synchronizeList(
list, Arrays.asList(newParms), ParameterList.INSTANCE, toRemoveParm);
JavaCodeStyleManager.getInstance(list.getProject()).shortenClassReferences(list);
for (FieldConflictsResolver fieldConflictsResolver : conflictResolvers) {
fieldConflictsResolver.fix();
}
}
public List<PsiJavaCodeReferenceElement> getChildren(PsiReferenceList throwsList) {
return Arrays.asList(throwsList.getReferenceElements());
}
public List<PsiParameter> getChildren(PsiParameterList psiParameterList) {
return Arrays.asList(psiParameterList.getParameters());
}
// This methods works equally well for primary usages as well as for propagated callers' usages
private static void fixActualArgumentsList(
PsiExpressionList list,
JavaChangeInfo changeInfo,
boolean toInsertDefaultValue,
PsiSubstitutor substitutor)
throws IncorrectOperationException {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
if (changeInfo.isParameterSetOrOrderChanged()) {
if (changeInfo instanceof JavaChangeInfoImpl
&& ((JavaChangeInfoImpl) changeInfo).isPropagationEnabled) {
final ParameterInfoImpl[] createdParmsInfo =
((JavaChangeInfoImpl) changeInfo).getCreatedParmsInfoWithoutVarargs();
for (ParameterInfoImpl info : createdParmsInfo) {
PsiExpression newArg;
if (toInsertDefaultValue) {
newArg = createDefaultValue(changeInfo, factory, info, list);
} else {
newArg = factory.createExpressionFromText(info.getName(), list);
}
JavaCodeStyleManager.getInstance(list.getProject())
.shortenClassReferences(list.add(newArg));
}
} else {
final PsiExpression[] args = list.getExpressions();
final int nonVarargCount = getNonVarargCount(changeInfo, args);
final int varargCount = args.length - nonVarargCount;
if (varargCount < 0) return;
PsiExpression[] newVarargInitializers = null;
final int newArgsLength;
final int newNonVarargCount;
final JavaParameterInfo[] newParms = changeInfo.getNewParameters();
if (changeInfo.isArrayToVarargs()) {
newNonVarargCount = newParms.length - 1;
final JavaParameterInfo lastNewParm = newParms[newParms.length - 1];
final PsiExpression arrayToConvert = args[lastNewParm.getOldIndex()];
if (arrayToConvert instanceof PsiNewExpression) {
final PsiNewExpression expression = (PsiNewExpression) arrayToConvert;
final PsiArrayInitializerExpression arrayInitializer = expression.getArrayInitializer();
if (arrayInitializer != null) {
newVarargInitializers = arrayInitializer.getInitializers();
}
}
newArgsLength =
newVarargInitializers == null
? newParms.length
: newNonVarargCount + newVarargInitializers.length;
} else if (changeInfo.isRetainsVarargs()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount + varargCount;
} else if (changeInfo.isObtainsVarags()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount;
} else {
newNonVarargCount = newParms.length;
newArgsLength = newParms.length;
}
String[] oldVarargs = null;
if (changeInfo.wasVararg() && !changeInfo.isRetainsVarargs()) {
oldVarargs = new String[varargCount];
for (int i = nonVarargCount; i < args.length; i++) {
oldVarargs[i - nonVarargCount] = args[i].getText();
}
}
final PsiExpression[] newArgs = new PsiExpression[newArgsLength];
for (int i = 0; i < newNonVarargCount; i++) {
if (newParms[i].getOldIndex() == nonVarargCount && oldVarargs != null) {
PsiType type = newParms[i].createType(changeInfo.getMethod(), list.getManager());
if (type instanceof PsiArrayType) {
type = substitutor.substitute(type);
type = TypeConversionUtil.erasure(type);
String typeText = type.getCanonicalText();
if (type instanceof PsiEllipsisType) {
typeText = typeText.replace("...", "[]");
}
String text = "new " + typeText + "{" + StringUtil.join(oldVarargs, ",") + "}";
newArgs[i] = factory.createExpressionFromText(text, changeInfo.getMethod());
continue;
}
}
newArgs[i] =
createActualArgument(changeInfo, list, newParms[i], toInsertDefaultValue, args);
}
if (changeInfo.isArrayToVarargs()) {
if (newVarargInitializers == null) {
newArgs[newNonVarargCount] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(
newVarargInitializers, 0, newArgs, newNonVarargCount, newVarargInitializers.length);
}
} else {
final int newVarargCount = newArgsLength - newNonVarargCount;
LOG.assertTrue(newVarargCount == 0 || newVarargCount == varargCount);
for (int i = newNonVarargCount; i < newArgsLength; i++) {
final int oldIndex = newParms[newNonVarargCount].getOldIndex();
if (oldIndex >= 0 && oldIndex != nonVarargCount) {
newArgs[i] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(args, nonVarargCount, newArgs, newNonVarargCount, newVarargCount);
break;
}
}
}
ChangeSignatureUtil.synchronizeList(
list, Arrays.asList(newArgs), ExpressionList.INSTANCE, changeInfo.toRemoveParm());
}
}
}
public List<PsiExpression> getChildren(PsiExpressionList psiExpressionList) {
return Arrays.asList(psiExpressionList.getExpressions());
}
private PsiMethod createMethodToAdd() {
ChangeContextUtil.encodeContextInfo(myMethod, true);
try {
final PsiManager manager = myMethod.getManager();
final PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
// correct internal references
final PsiCodeBlock body = myMethod.getBody();
if (body != null) {
final Map<PsiElement, PsiElement> replaceMap = new HashMap<PsiElement, PsiElement>();
body.accept(
new JavaRecursiveElementVisitor() {
@Override
public void visitThisExpression(PsiThisExpression expression) {
final PsiClass classReferencedByThis =
MoveInstanceMembersUtil.getClassReferencedByThis(expression);
if (classReferencedByThis != null
&& !PsiTreeUtil.isAncestor(myMethod, classReferencedByThis, false)) {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(myProject).getElementFactory();
String paramName = getParameterNameToCreate(classReferencedByThis);
try {
final PsiExpression refExpression =
factory.createExpressionFromText(paramName, null);
replaceMap.put(expression, refExpression);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {
try {
final PsiExpression qualifier = expression.getQualifierExpression();
final PsiElement resolved = expression.resolve();
if (qualifier instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) qualifier).isReferenceTo(myTargetVariable)) {
if (resolved instanceof PsiField) {
for (PsiParameter parameter : myMethod.getParameterList().getParameters()) {
if (Comparing.strEqual(
parameter.getName(), ((PsiField) resolved).getName())) {
qualifier.replace(factory.createExpressionFromText("this", null));
return;
}
}
}
// Target is a field, replace target.m -> m
qualifier.delete();
return;
}
if (myTargetVariable.equals(resolved)) {
PsiThisExpression thisExpression =
RefactoringChangeUtil.createThisExpression(
manager,
PsiTreeUtil.isAncestor(
myMethod,
PsiTreeUtil.getParentOfType(expression, PsiClass.class),
true)
? myTargetClass
: null);
replaceMap.put(expression, thisExpression);
return;
} else if (myMethod.equals(resolved)) {
} else {
PsiClass classReferencedByThis =
MoveInstanceMembersUtil.getClassReferencedByThis(expression);
if (classReferencedByThis != null) {
final String paramName = getParameterNameToCreate(classReferencedByThis);
if (paramName != null) {
PsiReferenceExpression newQualifier =
(PsiReferenceExpression)
factory.createExpressionFromText(paramName, null);
expression.setQualifierExpression(newQualifier);
return;
}
}
}
super.visitReferenceExpression(expression);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
@Override
public void visitNewExpression(PsiNewExpression expression) {
try {
final PsiExpression qualifier = expression.getQualifier();
if (qualifier instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) qualifier).isReferenceTo(myTargetVariable)) {
// Target is a field, replace target.new A() -> new A()
qualifier.delete();
} else {
final PsiClass classReferencedByThis =
MoveInstanceMembersUtil.getClassReferencedByThis(expression);
if (classReferencedByThis != null) {
if (qualifier != null) qualifier.delete();
final String paramName = getParameterNameToCreate(classReferencedByThis);
final PsiExpression newExpression =
factory.createExpressionFromText(
paramName + "." + expression.getText(), null);
replaceMap.put(expression, newExpression);
}
}
super.visitNewExpression(expression);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
correctMethodCall(expression, true);
super.visitMethodCallExpression(expression);
}
});
for (PsiElement element : replaceMap.keySet()) {
final PsiElement replacement = replaceMap.get(element);
element.replace(replacement);
}
}
final PsiMethod methodCopy = getPatternMethod();
final List<PsiParameter> newParameters =
Arrays.asList(methodCopy.getParameterList().getParameters());
RefactoringUtil.fixJavadocsForParams(methodCopy, new HashSet<PsiParameter>(newParameters));
return methodCopy;
} catch (IncorrectOperationException e) {
LOG.error(e);
return myMethod;
}
}