private static boolean callerSignatureIsAboutToChangeToo(
final PsiMethod caller, final UsageInfo[] usages) {
for (UsageInfo usage : usages) {
if (usage instanceof MethodCallUsageInfo
&& MethodSignatureUtil.isSuperMethod(
((MethodCallUsageInfo) usage).getReferencedMethod(), caller)) {
return true;
}
}
return false;
}
private static boolean isMultipleInterfacesImplementation(
final PsiMethod method, PsiMethod originalMethod, final PsiElement[] allElementsToDelete) {
final PsiMethod[] methods = method.findSuperMethods();
for (PsiMethod superMethod : methods) {
if (ArrayUtil.find(allElementsToDelete, superMethod) < 0
&& !MethodSignatureUtil.isSuperMethod(originalMethod, superMethod)) {
return true;
}
}
return false;
}
@Override
public boolean setupDefaultValues(
ChangeInfo changeInfo, Ref<UsageInfo[]> refUsages, Project project) {
if (!(changeInfo instanceof JavaChangeInfo)) return true;
for (UsageInfo usageInfo : refUsages.get()) {
if (usageInfo instanceof GrMethodCallUsageInfo) {
GrMethodCallUsageInfo methodCallUsageInfo = (GrMethodCallUsageInfo) usageInfo;
if (methodCallUsageInfo.isToChangeArguments()) {
final PsiElement element = methodCallUsageInfo.getElement();
if (element == null) continue;
final PsiMethod caller = RefactoringUtil.getEnclosingMethod(element);
final boolean needDefaultValue =
!((JavaChangeInfo) changeInfo).getMethodsToPropagateParameters().contains(caller);
final PsiMethod referencedMethod = methodCallUsageInfo.getReferencedMethod();
if (needDefaultValue
&& (caller == null
|| referencedMethod == null
|| !MethodSignatureUtil.isSuperMethod(referencedMethod, caller))) {
final ParameterInfo[] parameters = changeInfo.getNewParameters();
for (ParameterInfo parameter : parameters) {
final String defaultValue = parameter.getDefaultValue();
if (defaultValue == null && parameter.getOldIndex() == -1) {
((ParameterInfoImpl) parameter).setDefaultValue("");
if (!ApplicationManager.getApplication().isUnitTestMode()) {
final PsiType type =
((ParameterInfoImpl) parameter)
.getTypeWrapper()
.getType(element, element.getManager());
final DefaultValueChooser chooser =
new DefaultValueChooser(
project, parameter.getName(), PsiTypesUtil.getDefaultValueOfType(type));
chooser.show();
if (chooser.isOK()) {
if (chooser.feelLucky()) {
parameter.setUseAnySingleVariable(true);
} else {
((ParameterInfoImpl) parameter).setDefaultValue(chooser.getDefaultValue());
}
} else {
return false;
}
}
}
}
}
}
}
}
return true;
}
private static void findParameterUsages(
final PsiParameter parameter, final List<UsageInfo> usages) {
final PsiMethod method = (PsiMethod) parameter.getDeclarationScope();
final int parameterIndex = method.getParameterList().getParameterIndex(parameter);
// search for refs to current method only, do not search for refs to overriding methods, they'll
// be searched separately
ReferencesSearch.search(method)
.forEach(
reference -> {
PsiElement element = reference.getElement();
if (element != null) {
final JavaSafeDeleteDelegate safeDeleteDelegate =
JavaSafeDeleteDelegate.EP.forLanguage(element.getLanguage());
if (safeDeleteDelegate != null) {
safeDeleteDelegate.createUsageInfoForParameter(
reference, usages, parameter, method);
}
if (!parameter.isVarArgs()
&& !RefactoringChangeUtil.isSuperMethodCall(element.getParent())) {
final PsiParameter paramInCaller =
SafeDeleteJavaCallerChooser.isTheOnlyOneParameterUsage(
element.getParent(), parameterIndex, method);
if (paramInCaller != null) {
final PsiMethod callerMethod = (PsiMethod) paramInCaller.getDeclarationScope();
if (ApplicationManager.getApplication().isUnitTestMode()) {
usages.add(
new SafeDeleteParameterCallHierarchyUsageInfo(
callerMethod, paramInCaller, callerMethod));
} else {
usages.add(
new SafeDeleteParameterCallHierarchyUsageInfo(
method, parameter, callerMethod));
}
}
}
}
return true;
});
ReferencesSearch.search(parameter)
.forEach(
reference -> {
PsiElement element = reference.getElement();
final PsiDocTag docTag = PsiTreeUtil.getParentOfType(element, PsiDocTag.class);
if (docTag != null) {
usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(docTag, parameter, true));
return true;
}
boolean isSafeDelete = false;
if (element.getParent().getParent() instanceof PsiMethodCallExpression) {
PsiMethodCallExpression call =
(PsiMethodCallExpression) element.getParent().getParent();
PsiReferenceExpression methodExpression = call.getMethodExpression();
if (methodExpression.getText().equals(PsiKeyword.SUPER)) {
isSafeDelete = true;
} else if (methodExpression.getQualifierExpression()
instanceof PsiSuperExpression) {
final PsiMethod superMethod = call.resolveMethod();
if (superMethod != null
&& MethodSignatureUtil.isSuperMethod(superMethod, method)) {
isSafeDelete = true;
}
}
}
usages.add(
new SafeDeleteReferenceJavaDeleteUsageInfo(element, parameter, isSafeDelete));
return true;
});
findFunctionalExpressions(usages, method);
}