private static void removeUnusedParameterViaChangeSignature(
final PsiMethod psiMethod, final Collection<PsiElement> parametersToDelete) {
ArrayList<ParameterInfoImpl> newParameters = new ArrayList<ParameterInfoImpl>();
PsiParameter[] oldParameters = psiMethod.getParameterList().getParameters();
for (int i = 0; i < oldParameters.length; i++) {
PsiParameter oldParameter = oldParameters[i];
if (!parametersToDelete.contains(oldParameter)) {
newParameters.add(
new ParameterInfoImpl(i, oldParameter.getName(), oldParameter.getType()));
}
}
ParameterInfoImpl[] parameterInfos =
newParameters.toArray(new ParameterInfoImpl[newParameters.size()]);
ChangeSignatureProcessor csp =
new ChangeSignatureProcessor(
psiMethod.getProject(),
psiMethod,
false,
null,
psiMethod.getName(),
psiMethod.getReturnType(),
parameterInfos);
csp.run();
}
public void applyFix(@NotNull final Project project, @NotNull ProblemDescriptor descriptor) {
final PsiElement element = descriptor.getPsiElement();
final PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class);
LOG.assertTrue(method != null);
PsiParameter parameter = PsiTreeUtil.getParentOfType(element, PsiParameter.class, false);
if (parameter == null) {
final PsiParameter[] parameters = method.getParameterList().getParameters();
for (PsiParameter psiParameter : parameters) {
if (Comparing.strEqual(psiParameter.getName(), myParameterName)) {
parameter = psiParameter;
break;
}
}
}
if (parameter == null) return;
if (!CommonRefactoringUtil.checkReadOnlyStatus(project, parameter)) return;
final PsiExpression defToInline;
try {
defToInline =
JavaPsiFacade.getInstance(project)
.getElementFactory()
.createExpressionFromText(myValue, parameter);
} catch (IncorrectOperationException e) {
return;
}
final PsiParameter parameterToInline = parameter;
inlineSameParameterValue(method, parameterToInline, defToInline);
}
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!CodeInsightUtilBase.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiMethod psiMethod =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiMethod.class);
if (psiMethod != null) {
final ArrayList<PsiElement> psiParameters = new ArrayList<PsiElement>();
final RefElement refMethod = myManager != null ? myManager.getReference(psiMethod) : null;
if (refMethod != null) {
for (final RefParameter refParameter : getUnusedParameters((RefMethod) refMethod)) {
psiParameters.add(refParameter.getElement());
}
} else {
final PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
for (PsiParameter parameter : parameters) {
if (Comparing.strEqual(parameter.getName(), myHint)) {
psiParameters.add(parameter);
break;
}
}
}
final PsiModificationTracker tracker = psiMethod.getManager().getModificationTracker();
final long startModificationCount = tracker.getModificationCount();
removeUnusedParameterViaChangeSignature(psiMethod, psiParameters);
if (refMethod != null && startModificationCount != tracker.getModificationCount()) {
myProcessor.ignoreElement(refMethod);
}
}
}
private static void checkMethodCall(RefElement refWhat, final PsiElement element) {
if (!(refWhat instanceof RefMethod)) return;
final RefMethod refMethod = (RefMethod) refWhat;
final PsiElement psiElement = refMethod.getElement();
if (!(psiElement instanceof PsiMethod)) return;
final PsiMethod psiMethod = (PsiMethod) psiElement;
if (!PsiType.BOOLEAN.equals(psiMethod.getReturnType())) return;
element.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitMethodCallExpression(PsiMethodCallExpression call) {
super.visitMethodCallExpression(call);
final PsiReferenceExpression methodExpression = call.getMethodExpression();
if (methodExpression.isReferenceTo(psiMethod)) {
if (isInvertedMethodCall(methodExpression)) return;
refMethod.putUserData(ALWAYS_INVERTED, Boolean.FALSE);
}
}
@Override
public void visitMethodReferenceExpression(PsiMethodReferenceExpression expression) {
super.visitMethodReferenceExpression(expression);
if (expression.isReferenceTo(psiElement)) {
refMethod.putUserData(ALWAYS_INVERTED, Boolean.FALSE);
}
}
});
}
@Override
public void onInitialize(RefElement refElement) {
((RefElementImpl) refElement).setFlag(true, CAN_BE_FINAL_MASK);
if (refElement instanceof RefClass) {
final RefClass refClass = (RefClass) refElement;
final PsiClass psiClass = refClass.getElement();
if (refClass.isEntry()) {
((RefClassImpl) refClass).setFlag(false, CAN_BE_FINAL_MASK);
return;
}
if (refClass.isAbstract() || refClass.isAnonymous() || refClass.isInterface()) {
((RefClassImpl) refClass).setFlag(false, CAN_BE_FINAL_MASK);
return;
}
if (!refClass.isSelfInheritor(psiClass)) {
for (PsiClass psiSuperClass : psiClass.getSupers()) {
if (myManager.belongsToScope(psiSuperClass)) {
RefClass refSuperClass = (RefClass) myManager.getReference(psiSuperClass);
if (refSuperClass != null) {
((RefClassImpl) refSuperClass).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
} else if (refElement instanceof RefMethod) {
final RefMethod refMethod = (RefMethod) refElement;
final PsiElement element = refMethod.getElement();
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
if (refMethod.isConstructor()
|| refMethod.isAbstract()
|| refMethod.isStatic()
|| PsiModifier.PRIVATE.equals(refMethod.getAccessModifier())
|| refMethod.getOwnerClass().isAnonymous()
|| refMethod.getOwnerClass().isInterface()) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
if (PsiModifier.PRIVATE.equals(refMethod.getAccessModifier())
&& refMethod.getOwner() != null
&& !(refMethod.getOwnerClass().getOwner() instanceof RefElement)) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
for (PsiMethod psiSuperMethod : psiMethod.findSuperMethods()) {
if (myManager.belongsToScope(psiSuperMethod)) {
RefMethod refSuperMethod = (RefMethod) myManager.getReference(psiSuperMethod);
if (refSuperMethod != null) {
((RefMethodImpl) refSuperMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
}
}
@Nullable
public String getQualifiedName(final RefEntity refEntity) {
if (refEntity instanceof RefJavaElement && ((RefJavaElement) refEntity).isSyntheticJSP()) {
return XmlStringUtil.escapeString(refEntity.getName());
} else if (refEntity instanceof RefMethod) {
PsiMethod psiMethod = (PsiMethod) ((RefMethod) refEntity).getElement();
if (psiMethod != null) {
return psiMethod.getName();
} else {
return refEntity.getName();
}
}
return null;
}
@Override
public CommonProblemDescriptor[] checkElement(
@NotNull RefEntity refEntity,
@NotNull AnalysisScope scope,
@NotNull final InspectionManager manager,
@NotNull final GlobalInspectionContext globalContext) {
if (refEntity instanceof RefMethod) {
RefMethod refMethod = (RefMethod) refEntity;
if (!refMethod.isReferenced()) return null;
if (hasNonInvertedCalls(refMethod)) return null;
if (!refMethod.getSuperMethods().isEmpty()) return null;
final PsiMethod psiMethod = (PsiMethod) refMethod.getElement();
final PsiIdentifier psiIdentifier = psiMethod.getNameIdentifier();
if (psiIdentifier != null) {
final Collection<RefElement> inReferences = refMethod.getInReferences();
if (inReferences.size() == 1) {
final RefElement refElement = inReferences.iterator().next();
final PsiElement usagesContainer = refElement.getElement();
if (usagesContainer == null) return null;
if (ReferencesSearch.search(psiMethod, new LocalSearchScope(usagesContainer))
.forEach(
new Processor<PsiReference>() {
private final Set<PsiReference> myFoundRefs = new HashSet<>();
@Override
public boolean process(PsiReference reference) {
myFoundRefs.add(reference);
return myFoundRefs.size() < 2;
}
})) return null;
}
return new ProblemDescriptor[] {
manager.createProblemDescriptor(
psiIdentifier,
InspectionsBundle.message("boolean.method.is.always.inverted.problem.descriptor"),
(LocalQuickFix) getQuickFix(null),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
false)
};
}
}
return null;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiModifierListOwner element =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiModifierListOwner.class);
if (element != null) {
RefElement refElement = null;
if (myManager != null) {
refElement = myManager.getReference(element);
}
try {
if (element instanceof PsiVariable) {
((PsiVariable) element).normalizeDeclaration();
}
PsiModifierList list = element.getModifierList();
LOG.assertTrue(list != null);
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& containingClass.getParent() instanceof PsiFile
&& myHint == PsiModifier.PRIVATE
&& list.hasModifierProperty(PsiModifier.FINAL)) {
list.setModifierProperty(PsiModifier.FINAL, false);
}
}
list.setModifierProperty(myHint, true);
if (refElement instanceof RefJavaElement) {
RefJavaUtil.getInstance().setAccessModifier((RefJavaElement) refElement, myHint);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
public static void removeParameter(final PsiMethod method, final PsiParameter parameter) {
final PsiParameter[] parameters = method.getParameterList().getParameters();
final List<ParameterInfoImpl> psiParameters = new ArrayList<ParameterInfoImpl>();
int paramIdx = 0;
final String paramName = parameter.getName();
for (PsiParameter param : parameters) {
if (!Comparing.strEqual(paramName, param.getName())) {
psiParameters.add(new ParameterInfoImpl(paramIdx, param.getName(), param.getType()));
}
paramIdx++;
}
new ChangeSignatureProcessor(
method.getProject(),
method,
false,
null,
method.getName(),
method.getReturnType(),
psiParameters.toArray(new ParameterInfoImpl[psiParameters.size()]))
.run();
}
private static void appendMethodParameters(
StringBuffer buf, PsiMethod method, boolean showNames) {
PsiParameter[] params = method.getParameterList().getParameters();
buf.append('(');
for (int i = 0; i < params.length; i++) {
if (i != 0) buf.append(", ");
PsiParameter param = params[i];
buf.append(param.getType().getPresentableText());
if (showNames) {
buf.append(' ');
buf.append(param.getName());
}
}
buf.append(')');
}
@Override
public void onReferencesBuild(RefElement refElement) {
if (refElement instanceof RefClass) {
final PsiClass psiClass = (PsiClass) refElement.getElement();
if (psiClass != null) {
if (refElement.isEntry()) {
((RefClassImpl) refElement).setFlag(false, CAN_BE_FINAL_MASK);
}
PsiMethod[] psiMethods = psiClass.getMethods();
PsiField[] psiFields = psiClass.getFields();
HashSet<PsiVariable> allFields = new HashSet<PsiVariable>();
ContainerUtil.addAll(allFields, psiFields);
ArrayList<PsiVariable> instanceInitializerInitializedFields = new ArrayList<PsiVariable>();
boolean hasInitializers = false;
for (PsiClassInitializer initializer : psiClass.getInitializers()) {
PsiCodeBlock body = initializer.getBody();
hasInitializers = true;
ControlFlow flow;
try {
flow =
ControlFlowFactory.getInstance(body.getProject())
.getControlFlow(
body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false);
} catch (AnalysisCanceledException e) {
flow = ControlFlow.EMPTY;
}
Collection<PsiVariable> writtenVariables = new ArrayList<PsiVariable>();
ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false, writtenVariables);
for (PsiVariable psiVariable : writtenVariables) {
if (allFields.contains(psiVariable)) {
if (instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
instanceInitializerInitializedFields.remove(psiVariable);
} else {
instanceInitializerInitializedFields.add(psiVariable);
}
}
}
for (PsiVariable psiVariable : writtenVariables) {
if (!instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
}
}
}
for (PsiMethod psiMethod : psiMethods) {
if (psiMethod.isConstructor()) {
PsiCodeBlock body = psiMethod.getBody();
if (body != null) {
hasInitializers = true;
ControlFlow flow;
try {
flow =
ControlFlowFactory.getInstance(body.getProject())
.getControlFlow(
body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false);
} catch (AnalysisCanceledException e) {
flow = ControlFlow.EMPTY;
}
Collection<PsiVariable> writtenVariables =
ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false);
for (PsiVariable psiVariable : writtenVariables) {
if (instanceInitializerInitializedFields.contains(psiVariable)) {
allFields.remove(psiVariable);
instanceInitializerInitializedFields.remove(psiVariable);
}
}
List<PsiMethod> redirectedConstructors =
HighlightControlFlowUtil.getChainedConstructors(psiMethod);
if (redirectedConstructors == null || redirectedConstructors.isEmpty()) {
List<PsiVariable> ssaVariables = ControlFlowUtil.getSSAVariables(flow);
ArrayList<PsiVariable> good = new ArrayList<PsiVariable>(ssaVariables);
good.addAll(instanceInitializerInitializedFields);
allFields.retainAll(good);
} else {
allFields.removeAll(writtenVariables);
}
}
}
}
for (PsiField psiField : psiFields) {
if ((!hasInitializers || !allFields.contains(psiField))
&& psiField.getInitializer() == null) {
final RefFieldImpl refField = (RefFieldImpl) myManager.getReference(psiField);
if (refField != null) {
refField.setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
} else if (refElement instanceof RefMethod) {
final RefMethod refMethod = (RefMethod) refElement;
if (refMethod.isEntry()) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
public void appendReferencePresentation(
RefEntity refElement, final StringBuffer buf, final boolean isPackageIncluded) {
if (refElement instanceof RefImplicitConstructor) {
buf.append(InspectionsBundle.message("inspection.export.results.implicit.constructor"));
refElement = ((RefImplicitConstructor) refElement).getOwnerClass();
}
buf.append(HTMLComposerImpl.CODE_OPENING);
if (refElement instanceof RefField) {
RefField field = (RefField) refElement;
PsiField psiField = field.getElement();
buf.append(psiField.getType().getPresentableText());
buf.append(HTMLComposerImpl.NBSP);
} else if (refElement instanceof RefMethod) {
RefMethod method = (RefMethod) refElement;
PsiMethod psiMethod = (PsiMethod) method.getElement();
PsiType returnType = psiMethod.getReturnType();
if (returnType != null) {
buf.append(returnType.getPresentableText());
buf.append(HTMLComposerImpl.NBSP);
}
}
buf.append(HTMLComposerImpl.A_HREF_OPENING);
if (myComposer.myExporter == null) {
buf.append(((RefElementImpl) refElement).getURL());
} else {
buf.append(myComposer.myExporter.getURL(refElement));
}
buf.append("\">");
if (refElement instanceof RefClass && ((RefClass) refElement).isAnonymous()) {
buf.append(InspectionsBundle.message("inspection.reference.anonymous"));
} else if (refElement instanceof RefJavaElement
&& ((RefJavaElement) refElement).isSyntheticJSP()) {
buf.append(XmlStringUtil.escapeString(refElement.getName()));
} else if (refElement instanceof RefMethod) {
PsiMethod psiMethod = (PsiMethod) ((RefMethod) refElement).getElement();
buf.append(psiMethod.getName());
} else {
buf.append(refElement.getName());
}
buf.append(HTMLComposerImpl.A_CLOSING);
if (refElement instanceof RefMethod) {
PsiMethod psiMethod = (PsiMethod) ((RefMethod) refElement).getElement();
appendMethodParameters(buf, psiMethod, false);
}
buf.append(HTMLComposerImpl.CODE_CLOSING);
if (refElement instanceof RefClass && ((RefClass) refElement).isAnonymous()) {
buf.append(" ");
buf.append(InspectionsBundle.message("inspection.export.results.anonymous.ref.in.owner"));
buf.append(" ");
myComposer.appendElementReference(
buf, ((RefElement) refElement.getOwner()), isPackageIncluded);
} else if (isPackageIncluded) {
buf.append(" ").append(HTMLComposerImpl.CODE_OPENING).append("(");
myComposer.appendQualifiedName(buf, refElement.getOwner());
// buf.append(RefUtil.getPackageName(refElement));
buf.append(")").append(HTMLComposerImpl.CODE_CLOSING);
}
}