private static void addParameterUsages(
PsiParameter parameter, ArrayList<UsageInfo> results, ParameterInfo info) {
PsiManager manager = parameter.getManager();
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject());
for (PsiReference psiReference : ReferencesSearch.search(parameter, projectScope, false)) {
PsiElement parmRef = psiReference.getElement();
UsageInfo usageInfo =
new ChangeSignatureParameterUsageInfo(parmRef, parameter.getName(), info.getName());
results.add(usageInfo);
}
}
private PsiMethod[] findSimpleUsagesWithoutParameters(
final PsiMethod method,
final ArrayList<UsageInfo> result,
boolean isToModifyArgs,
boolean isToThrowExceptions,
boolean isOriginal) {
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(method.getProject());
PsiMethod[] overridingMethods =
OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY);
for (PsiMethod overridingMethod : overridingMethods) {
result.add(
new OverriderUsageInfo(
overridingMethod, method, isOriginal, isToModifyArgs, isToThrowExceptions));
}
boolean needToChangeCalls =
!myChangeInfo.isGenerateDelegate()
&& (myChangeInfo.isNameChanged()
|| myChangeInfo.isParameterSetOrOrderChanged()
|| myChangeInfo.isExceptionSetOrOrderChanged()
|| myChangeInfo.isVisibilityChanged() /*for checking inaccessible*/);
if (needToChangeCalls) {
int parameterCount = method.getParameterList().getParametersCount();
PsiReference[] refs =
MethodReferencesSearch.search(method, projectScope, true)
.toArray(PsiReference.EMPTY_ARRAY);
for (PsiReference ref : refs) {
PsiElement element = ref.getElement();
boolean isToCatchExceptions =
isToThrowExceptions
&& needToCatchExceptions(RefactoringUtil.getEnclosingMethod(element));
if (!isToCatchExceptions) {
if (RefactoringUtil.isMethodUsage(element)) {
PsiExpressionList list = RefactoringUtil.getArgumentListByMethodReference(element);
if (list == null
|| !method.isVarArgs() && list.getExpressions().length != parameterCount) continue;
}
}
if (RefactoringUtil.isMethodUsage(element)) {
result.add(new MethodCallUsageInfo(element, isToModifyArgs, isToCatchExceptions));
} else if (element instanceof PsiDocTagValue) {
result.add(new UsageInfo(element));
} else if (element instanceof PsiMethod && ((PsiMethod) element).isConstructor()) {
if (JavaLanguage.INSTANCE.equals(element.getLanguage())) {
DefaultConstructorImplicitUsageInfo implicitUsageInfo =
new DefaultConstructorImplicitUsageInfo(
(PsiMethod) element, ((PsiMethod) element).getContainingClass(), method);
result.add(implicitUsageInfo);
}
} else if (element instanceof PsiClass) {
LOG.assertTrue(method.isConstructor());
final PsiClass psiClass = (PsiClass) element;
if (JavaLanguage.INSTANCE.equals(psiClass.getLanguage())) {
if (myChangeInfo instanceof JavaChangeInfo) {
if (shouldPropagateToNonPhysicalMethod(
method,
result,
psiClass,
((JavaChangeInfo) myChangeInfo).getMethodsToPropagateParameters())) {
continue;
}
}
result.add(new NoConstructorClassUsageInfo(psiClass));
}
} else if (ref instanceof PsiCallReference) {
result.add(new CallReferenceUsageInfo((PsiCallReference) ref));
} else {
result.add(new MoveRenameUsageInfo(element, ref, method));
}
}
// if (method.isConstructor() && parameterCount == 0) {
// RefactoringUtil.visitImplicitConstructorUsages(method.getContainingClass(),
// new
// DefaultConstructorUsageCollector(result));
// }
} else if (myChangeInfo.isParameterTypesChanged()) {
PsiReference[] refs =
MethodReferencesSearch.search(method, projectScope, true)
.toArray(PsiReference.EMPTY_ARRAY);
for (PsiReference reference : refs) {
final PsiElement element = reference.getElement();
if (element instanceof PsiDocTagValue) {
result.add(new UsageInfo(reference));
} else if (element instanceof XmlElement) {
result.add(new MoveRenameUsageInfo(reference, method));
} else if (element instanceof PsiMethodReferenceExpression) {
result.add(new UsageInfo(reference));
}
}
}
// Conflicts
detectLocalsCollisionsInMethod(method, result, isOriginal);
for (final PsiMethod overridingMethod : overridingMethods) {
detectLocalsCollisionsInMethod(overridingMethod, result, isOriginal);
}
return overridingMethods;
}