@Nullable
private static String getCannotInlineMessage(
final PsiParameter psiParameter, final PsiMethod method) {
if (psiParameter.isVarArgs()) {
return RefactoringBundle.message("inline.parameter.error.varargs");
}
if (method.findSuperMethods().length > 0
|| OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY).length > 0) {
return RefactoringBundle.message("inline.parameter.error.hierarchy");
}
return null;
}
public static boolean isMethodParameterAnnotatedWith(
final PsiMethod method,
final int idx,
@Nullable Collection<PsiMethod> processed,
final String annFqn,
@Nullable Map<String, Object> annotationAttributeValues,
@Nullable final Set<PsiModifierListOwner> nonNlsTargets) {
if (processed != null) {
if (processed.contains(method)) return false;
} else {
processed = new THashSet<PsiMethod>();
}
processed.add(method);
final PsiParameter[] params = method.getParameterList().getParameters();
PsiParameter param;
if (idx >= params.length) {
if (params.length == 0) {
return false;
}
PsiParameter lastParam = params[params.length - 1];
if (lastParam.isVarArgs()) {
param = lastParam;
} else {
return false;
}
} else {
param = params[idx];
}
final PsiAnnotation annotation = AnnotationUtil.findAnnotation(param, annFqn);
if (annotation != null) {
return processAnnotationAttributes(annotationAttributeValues, annotation);
}
if (nonNlsTargets != null) {
nonNlsTargets.add(param);
}
final PsiMethod[] superMethods = method.findSuperMethods();
for (PsiMethod superMethod : superMethods) {
if (isMethodParameterAnnotatedWith(
superMethod, idx, processed, annFqn, annotationAttributeValues, null)) return true;
}
return false;
}
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);
}