From f7fcafc161c3a12e1fe4efe7bbb87b32a9b2ca4c Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Mon, 14 Oct 2024 12:04:51 +0200 Subject: [PATCH] Java: cleanup Inline Parameter refactoring GitOrigin-RevId: b0f0e6a85abeaa91afa489bef7f4abe848f61aad --- .../InlineParameterExpressionProcessor.java | 59 ++++++++-------- .../inline/InlineParameterHandler.java | 67 +++++++++---------- 2 files changed, 59 insertions(+), 67 deletions(-) diff --git a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java index 3046f01c7168..da4d40567535 100644 --- a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java +++ b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java @@ -1,4 +1,4 @@ -// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.refactoring.inline; import com.intellij.codeInsight.ExceptionUtil; @@ -50,10 +50,10 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor private JavaChangeInfo myChangeInfo; private UsageInfo[] myChangeSignatureUsages; - public InlineParameterExpressionProcessor(final PsiCallExpression methodCall, + public InlineParameterExpressionProcessor(PsiCallExpression methodCall, @NotNull PsiMethod method, - final PsiParameter parameter, - final PsiExpression initializer, + PsiParameter parameter, + PsiExpression initializer, boolean createLocal) { super(method.getProject()); myMethodCall = methodCall; @@ -87,8 +87,8 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final Map localToParamRef = new HashMap<>(); final PsiExpression[] arguments = myMethodCall.getArgumentList().getExpressions(); for (int i = 0; i < arguments.length; i++) { - if (i != parameterIndex && arguments[i] instanceof PsiReferenceExpression referenceExpression) { - final PsiElement element = referenceExpression.resolve(); + if (i != parameterIndex && arguments[i] instanceof PsiReferenceExpression ref) { + final PsiElement element = ref.resolve(); if (PsiUtil.isJvmLocalVariable(element)) { final PsiParameter param = myMethod.getParameterList().getParameters()[i]; final PsiExpression paramRef = @@ -108,16 +108,16 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final PsiElement[] elements = DefUseUtil.getDefs(myCallingBlock, localVariable, expression); if (elements.length == 1) { PsiExpression localInitializer = null; - if (elements[0] instanceof PsiLocalVariable) { - localInitializer = ((PsiLocalVariable)elements[0]).getInitializer(); + if (elements[0] instanceof PsiLocalVariable var) { + localInitializer = var.getInitializer(); } - else if (elements[0] instanceof PsiAssignmentExpression) { - localInitializer = ((PsiAssignmentExpression)elements[0]).getRExpression(); + else if (elements[0] instanceof PsiAssignmentExpression assignment) { + localInitializer = assignment.getRExpression(); } - else if (elements[0] instanceof PsiReferenceExpression refElement) { - final PsiElement parent = refElement.getParent(); - if (parent instanceof PsiAssignmentExpression && ((PsiAssignmentExpression)parent).getLExpression() == refElement) { - localInitializer = ((PsiAssignmentExpression)parent).getRExpression(); + else if (elements[0] instanceof PsiReferenceExpression ref) { + final PsiElement parent = ref.getParent(); + if (parent instanceof PsiAssignmentExpression assignment && assignment.getLExpression() == ref) { + localInitializer = assignment.getRExpression(); } } if (localInitializer != null) { @@ -167,7 +167,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor return UsageViewUtil.removeDuplicatedUsages(usageInfos); } - private static PsiElement replaceArgs(final Map elementsToReplace, PsiElement expression) { + private static PsiElement replaceArgs(Map elementsToReplace, PsiElement expression) { final Map replacements = new HashMap<>(); expression.accept(new JavaRecursiveElementVisitor() { @Override @@ -193,8 +193,8 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final InaccessibleExpressionsDetector detector = new InaccessibleExpressionsDetector(conflicts); myInitializer.accept(detector); for (UsageInfo usage : usages) { - if (usage instanceof LocalReplacementUsageInfo) { - final PsiElement replacement = ((LocalReplacementUsageInfo)usage).getReplacement(); + if (usage instanceof LocalReplacementUsageInfo usageInfo) { + final PsiElement replacement = usageInfo.getReplacement(); if (replacement != null) { replacement.accept(detector); } @@ -202,9 +202,9 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor } final Set vars = new HashSet<>(); - for (UsageInfo usageInfo : usages) { - if (usageInfo instanceof LocalReplacementUsageInfo) { - final PsiVariable var = ((LocalReplacementUsageInfo)usageInfo).getVariable(); + for (UsageInfo usage : usages) { + if (usage instanceof LocalReplacementUsageInfo usageInfo) { + final PsiVariable var = usageInfo.getVariable(); if (var != null) { vars.add(var); } @@ -213,7 +213,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor for (PsiVariable var : vars) { for (PsiReference ref : ReferencesSearch.search(var)) { final PsiElement element = ref.getElement(); - if (element instanceof PsiExpression && isAccessedForWriting((PsiExpression)element)) { + if (element instanceof PsiExpression exp && isAccessedForWriting(exp)) { conflicts.putValue(element, JavaRefactoringBundle.message("inline.parameter.initializer.depends.on.inaccessible.value")); break; } @@ -236,13 +236,13 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor final Set paramRefsToInline = new HashSet<>(); final Map replacements = new HashMap<>(); for (UsageInfo usage : usages) { - if (usage instanceof LocalReplacementUsageInfo replacementUsageInfo) { - final PsiElement element = replacementUsageInfo.getElement(); - final PsiElement replacement = replacementUsageInfo.getReplacement(); + if (usage instanceof LocalReplacementUsageInfo usageInfo) { + final PsiElement element = usageInfo.getElement(); + final PsiElement replacement = usageInfo.getReplacement(); if (element != null && replacement != null) { replacements.put(element, replacement); } - varsUsedInInitializer.add(replacementUsageInfo.getVariable()); + varsUsedInInitializer.add(usageInfo.getVariable()); } else { LOG.assertTrue(!myCreateLocal); @@ -309,7 +309,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor LocalReplacementUsageInfo(@NotNull PsiReference element, @NotNull PsiElement replacement) { super(element); final PsiElement resolved = element.resolve(); - myVariable = resolved instanceof PsiVariable ? (PsiVariable)resolved : null; + myVariable = resolved instanceof PsiVariable var ? var : null; myReplacement = replacement; } @@ -332,10 +332,10 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor } @Override - public void visitReferenceExpression(final @NotNull PsiReferenceExpression expression) { + public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement element = expression.resolve(); - if (element instanceof PsiMember && !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { + if (element instanceof PsiMember member && !member.hasModifierProperty(PsiModifier.STATIC)) { if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.dependency.unavailable.in.static.method", RefactoringUIUtil.getDescription(element, false))); @@ -347,8 +347,7 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor } else if (!PsiUtil.isAccessible((PsiMember)element, myMethod, null)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.depends.on.unavailable.value")); } - } else if (element instanceof PsiParameter && - PsiTreeUtil.isAncestor(((PsiParameter)element).getDeclarationScope(), myInitializer, true)) { + } else if (element instanceof PsiParameter param && PsiTreeUtil.isAncestor(param.getDeclarationScope(), myInitializer, true)) { boolean bound = false; for (PsiParameter parameter : myMethod.getParameterList().getParameters()) { if (parameter.getType().equals(((PsiParameter)element).getType()) && parameter.getName().equals(((PsiParameter)element).getName())) { diff --git a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterHandler.java b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterHandler.java index 1f7327b24c7b..75e7c292ba85 100644 --- a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterHandler.java +++ b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterHandler.java @@ -1,4 +1,4 @@ -// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.refactoring.inline; import com.intellij.codeInsight.PsiEquivalenceUtil; @@ -32,25 +32,19 @@ import org.jetbrains.annotations.Nullable; import java.util.*; - public final class InlineParameterHandler extends JavaInlineActionHandler { private static final String REFACTORING_ID = "refactoring.inline.parameter"; @Override public boolean canInlineElement(PsiElement element) { - if (element instanceof PsiParameter) { - final PsiElement parent = element.getParent(); - if (parent instanceof PsiParameterList && - parent.getParent() instanceof PsiMethod && - element.getLanguage() == JavaLanguage.INSTANCE) { - return true; - } - } - return false; + return element instanceof PsiParameter p && + p.getParent() instanceof PsiParameterList pl && + pl.getParent() instanceof PsiMethod && + element.getLanguage() == JavaLanguage.INSTANCE; } @Override - public void inlineElement(final Project project, final Editor editor, @NotNull PsiElement psiElement) { + public void inlineElement(Project project, Editor editor, @NotNull PsiElement psiElement) { final PsiParameter psiParameter = (PsiParameter) psiElement; final PsiParameterList parameterList = (PsiParameterList) psiParameter.getParent(); if (!(parameterList.getParent() instanceof PsiMethod method)) { @@ -104,13 +98,13 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { return; } final PsiReference reference = TargetElementUtil.findReference(editor); - final PsiReferenceExpression refExpr = reference instanceof PsiReferenceExpression ? (PsiReferenceExpression)reference : null; + final PsiReferenceExpression refExpr = reference instanceof PsiReferenceExpression ref ? ref : null; final PsiCodeBlock codeBlock = PsiTreeUtil.getParentOfType(refExpr, PsiCodeBlock.class); if (codeBlock != null) { final PsiElement[] defs = DefUseUtil.getDefs(codeBlock, psiParameter, refExpr); if (defs.length == 1) { final PsiElement def = defs[0]; - if (def instanceof PsiReferenceExpression && PsiUtil.isOnAssignmentLeftHand((PsiExpression)def)) { + if (def instanceof PsiReferenceExpression ref && PsiUtil.isOnAssignmentLeftHand(ref)) { final PsiExpression rExpr = ((PsiAssignmentExpression)def.getParent()).getRExpression(); if (rExpr != null) { PsiExpression toInline = InlineLocalHandler.getDefToInline(psiParameter, refExpr, codeBlock, false); @@ -119,8 +113,8 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { if (InlineLocalHandler.checkRefsInAugmentedAssignmentOrUnaryModified(refs, def) == null) { WriteCommandAction.writeCommandAction(project).run(() -> { - for (final PsiElement ref : refs) { - InlineUtil.inlineVariable(psiParameter, rExpr, (PsiJavaCodeReferenceElement)ref); + for (PsiElement e : refs) { + InlineUtil.inlineVariable(psiParameter, rExpr, (PsiJavaCodeReferenceElement)e); } def.getParent().delete(); }); @@ -132,8 +126,8 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { } } if (occurrences.isEmpty()) { - CommonRefactoringUtil - .showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.no.usages.warning.message"), JavaRefactoringBundle.message("inline.parameter.refactoring"), null); + CommonRefactoringUtil.showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.no.usages.warning.message"), + JavaRefactoringBundle.message("inline.parameter.refactoring"), null); return; } if (!result[0]) { @@ -145,8 +139,7 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { if (ApplicationManager.getApplication().isUnitTestMode()) { final InlineParameterExpressionProcessor processor = new InlineParameterExpressionProcessor(refMethodCall.get(), method, psiParameter, refInitializer.get(), - method.getProject().getUserData( - InlineParameterExpressionProcessor.CREATE_LOCAL_FOR_TESTS)); + method.getProject().getUserData(InlineParameterExpressionProcessor.CREATE_LOCAL_FOR_TESTS)); processor.run(); } else { @@ -158,7 +151,8 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { } if (refConstantInitializer.isNull()) { CommonRefactoringUtil.showErrorHint(project, editor, - JavaRefactoringBundle.message("inline.parameter.cannot.find.initializer.warning.message"), JavaRefactoringBundle.message("inline.parameter.refactoring"), null); + JavaRefactoringBundle.message("inline.parameter.cannot.find.initializer.warning.message"), + JavaRefactoringBundle.message("inline.parameter.refactoring"), null); return; } @@ -169,20 +163,22 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement resolved = expression.resolve(); - if (resolved instanceof PsiMember && !PsiUtil.isMemberAccessibleAt((PsiMember)resolved, method)) { + if (resolved instanceof PsiMember member && !PsiUtil.isMemberAccessibleAt(member, method)) { isNotConstantAccessible.set(Boolean.TRUE); } } }); if (!isNotConstantAccessible.isNull() && isNotConstantAccessible.get()) { - CommonRefactoringUtil.showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.not.accessible.warning.message"), JavaRefactoringBundle.message("inline.parameter.refactoring"), null); + CommonRefactoringUtil.showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.not.accessible.warning.message"), + JavaRefactoringBundle.message("inline.parameter.refactoring"), null); return; } for (PsiReference psiReference : ReferencesSearch.search(psiParameter)) { final PsiElement element = psiReference.getElement(); - if (element instanceof PsiExpression && PsiUtil.isAccessedForWriting((PsiExpression)element)) { - CommonRefactoringUtil.showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.write.usages.warning.message"), JavaRefactoringBundle.message("inline.parameter.refactoring"), null); + if (element instanceof PsiExpression exp && PsiUtil.isAccessedForWriting(exp)) { + CommonRefactoringUtil.showErrorHint(project, editor, JavaRefactoringBundle.message("inline.parameter.write.usages.warning.message"), + JavaRefactoringBundle.message("inline.parameter.refactoring"), null); return; } } @@ -190,7 +186,7 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { if (!ApplicationManager.getApplication().isUnitTestMode()) { String occurrencesString = RefactoringBundle.message("occurrences.string", occurrences.size()); String question = JavaRefactoringBundle.message("inline.parameter.confirmation", psiParameter.getName(), - constantExpression.getText()) + " " + occurrencesString; + constantExpression.getText()) + " " + occurrencesString; RefactoringMessageDialog dialog = new RefactoringMessageDialog( getRefactoringName(), question, @@ -214,7 +210,7 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { } @Nullable - private static PsiField getReferencedFinalField(final PsiExpression argument) { + private static PsiField getReferencedFinalField(PsiExpression argument) { if (argument instanceof PsiReferenceExpression ref && ref.resolve() instanceof PsiField field) { final PsiModifierList modifierList = field.getModifierList(); if (modifierList != null && modifierList.hasModifierProperty(PsiModifier.FINAL)) { @@ -224,9 +220,9 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { return null; } - private static boolean isRecursiveReferencedParameter(final PsiExpression argument, final PsiParameter param) { - if (argument instanceof PsiReferenceExpression) { - final PsiElement element = ((PsiReferenceExpression)argument).resolve(); + private static boolean isRecursiveReferencedParameter(PsiExpression argument, PsiParameter param) { + if (argument instanceof PsiReferenceExpression ref) { + final PsiElement element = ref.resolve(); if (element instanceof PsiParameter) { return element.equals(param); } @@ -234,7 +230,7 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { return false; } - private static boolean isSameConstant(final PsiExpression expr1, final PsiExpression expr2) { + private static boolean isSameConstant(PsiExpression expr1, PsiExpression expr2) { boolean expr1Null = InlineToAnonymousConstructorProcessor.ourNullPattern.accepts(expr1); boolean expr2Null = InlineToAnonymousConstructorProcessor.ourNullPattern.accepts(expr2); if (expr1Null || expr2Null) { @@ -257,24 +253,21 @@ public final class InlineParameterHandler extends JavaInlineActionHandler { } @Nullable - private static @NlsContexts.DialogMessage String getCannotInlineMessage(final PsiParameter psiParameter, final PsiMethod method) { + private static @NlsContexts.DialogMessage String getCannotInlineMessage(PsiParameter psiParameter, PsiMethod method) { if (psiParameter.isVarArgs()) { return JavaRefactoringBundle.message("inline.parameter.error.varargs"); } - if (method.findSuperMethods().length > 0 || - OverridingMethodsSearch.search(method).toArray(PsiMethod.EMPTY_ARRAY).length > 0) { + if (method.findSuperMethods().length > 0 || OverridingMethodsSearch.search(method).toArray(PsiMethod.EMPTY_ARRAY).length > 0) { return JavaRefactoringBundle.message("inline.parameter.error.hierarchy"); } - if (!method.getManager().isInProject(method)) { return JavaRefactoringBundle.message("inline.parameter.error.non.project.method"); } return null; } - @Nullable @Override - public String getActionName(PsiElement element) { + public @NotNull String getActionName(PsiElement element) { return JavaRefactoringBundle.message("inline.parameter.action.name"); }