From a9d5a7e52fa0aea52d02730956df31b2e9f2471d Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 23 May 2025 10:06:56 +0300 Subject: [PATCH] Refactoring of BaseRefactoringProcessor descendants (part 2). --- .../java/language/util/VisibilityUtil.java | 14 +- .../diGraph/analyzer/GlobalAnalyzer.java | 50 ++--- .../ConvertToInstanceMethodProcessor.java | 144 ++++++------ .../inline/InlineConstantFieldProcessor.java | 5 +- .../inline/InlineMethodProcessor.java | 3 +- .../IntroduceParameterUtil.java | 45 ++-- .../invertBoolean/InvertBooleanProcessor.java | 19 +- .../MakeMethodOrClassStaticProcessor.java | 94 ++++---- .../memberPushDown/PushDownProcessor.java | 129 ++++++----- .../MoveClassesOrPackagesUtil.java | 2 +- .../move/moveInner/MoveInnerProcessor.java | 212 +++++++++--------- 11 files changed, 346 insertions(+), 371 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/util/VisibilityUtil.java b/java-language-api/src/main/java/com/intellij/java/language/util/VisibilityUtil.java index 7b485887f1..ea6046bba2 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/util/VisibilityUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/util/VisibilityUtil.java @@ -39,7 +39,6 @@ import jakarta.annotation.Nonnull; public class VisibilityUtil { - @NonNls public static final String ESCALATE_VISIBILITY = "EscalateVisible"; private static final String[] visibilityModifiers = { PsiModifier.PRIVATE, @@ -61,7 +60,7 @@ public static String getHighestVisibility(@PsiModifier.ModifierConstant String v } public static void escalateVisibility(PsiMember modifierListOwner, PsiElement place) throws IncorrectOperationException { - final String visibilityModifier = getVisibilityModifier(modifierListOwner.getModifierList()); + String visibilityModifier = getVisibilityModifier(modifierListOwner.getModifierList()); int index; for (index = 0; index < visibilityModifiers.length; index++) { String modifier = visibilityModifiers[index]; @@ -76,14 +75,14 @@ public static void escalateVisibility(PsiMember modifierListOwner, PsiElement pl } public static void escalateVisibility(PsiModifierList modifierList, PsiElement place) throws IncorrectOperationException { - final PsiElement parent = modifierList.getParent(); + PsiElement parent = modifierList.getParent(); if (parent instanceof PsiMember) { escalateVisibility((PsiMember)parent, place); } } @PsiModifier.ModifierConstant - public static String getPossibleVisibility(final PsiMember psiMethod, final PsiElement place) { + public static String getPossibleVisibility(PsiMember psiMethod, PsiElement place) { Project project = psiMethod.getProject(); if (PsiUtil.isAccessible(project, psiMethod, place, null)) { return getVisibilityModifier(psiMethod.getModifierList()); @@ -111,7 +110,6 @@ public static String getVisibilityModifier(PsiModifierList list) { } @Nonnull - @NonNls public static String getVisibilityString(@PsiModifier.ModifierConstant String visibilityModifier) { if (PsiModifier.PACKAGE_LOCAL.equals(visibilityModifier)) { return ""; @@ -122,13 +120,13 @@ public static String getVisibilityString(@PsiModifier.ModifierConstant String vi @Nls @Nonnull public static String getVisibilityStringToDisplay(@Nonnull PsiMember member) { - if (member.hasModifierProperty(PsiModifier.PUBLIC)) { + if (member.isPublic()) { return toPresentableText(PsiModifier.PUBLIC); } - if (member.hasModifierProperty(PsiModifier.PROTECTED)) { + if (member.isProtected()) { return toPresentableText(PsiModifier.PROTECTED); } - if (member.hasModifierProperty(PsiModifier.PRIVATE)) { + if (member.isPrivate()) { return toPresentableText(PsiModifier.PRIVATE); } return toPresentableText(PsiModifier.PACKAGE_LOCAL); diff --git a/plugin/src/main/java/com/intellij/java/impl/internal/diGraph/analyzer/GlobalAnalyzer.java b/plugin/src/main/java/com/intellij/java/impl/internal/diGraph/analyzer/GlobalAnalyzer.java index face5fa6a1..1dd69e6192 100644 --- a/plugin/src/main/java/com/intellij/java/impl/internal/diGraph/analyzer/GlobalAnalyzer.java +++ b/plugin/src/main/java/com/intellij/java/impl/internal/diGraph/analyzer/GlobalAnalyzer.java @@ -19,66 +19,66 @@ import java.util.Iterator; import java.util.LinkedList; +import java.util.List; /** - * Created by IntelliJ IDEA. - * User: db - * Date: 21.06.2003 - * Time: 20:23:16 - * To change this template use Options | File Templates. + * @author db + * @since 2003-06-21 */ public class GlobalAnalyzer { - private static boolean stepOneEnd(MarkedNode currNode, LinkedList worklist, OneEndFunctor functor) { + @SuppressWarnings("unchecked") + private static boolean stepOneEnd(MarkedNode currNode, List worklist, OneEndFunctor functor) { boolean result = false; - for (Iterator i = currNode.outIterator(); i.hasNext(); ) { - MarkedEdge currEdge = (MarkedEdge)i.next(); + for (Iterator i = currNode.outIterator(); i.hasNext(); ) { + MarkedEdge currEdge = i.next(); MarkedNode nextNode = (MarkedNode)currEdge.end(); Mark theMark = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark()); if (!theMark.coincidesWith(nextNode.getMark())) { result = true; nextNode.setMark(theMark); - worklist.addFirst(nextNode); + worklist.addFirst((T)nextNode); } } return result; } - private static boolean stepTwoEnds(final MarkedNode currNode, final LinkedList worklist, final TwoEndsFunctor functor) { + @SuppressWarnings("unchecked") + private static boolean stepTwoEnds(MarkedNode currNode, List worklist, TwoEndsFunctor functor) { boolean result = false; for (Iterator i = currNode.outIterator(); i.hasNext(); ) { - final MarkedEdge currEdge = (MarkedEdge)i.next(); - final MarkedNode nextNode = (MarkedNode)currEdge.end(); - final Pair markPair = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark()); + MarkedEdge currEdge = (MarkedEdge)i.next(); + MarkedNode nextNode = (MarkedNode)currEdge.end(); + Pair markPair = functor.compute(currNode.getMark(), currEdge.getMark(), nextNode.getMark()); - final Mark leftMark = markPair.getFirst(); - final Mark rightMark = markPair.getSecond(); + Mark leftMark = markPair.getFirst(); + Mark rightMark = markPair.getSecond(); if (!leftMark.coincidesWith(currNode.getMark())) { result = true; currNode.setMark(leftMark); - worklist.addFirst(currNode); + worklist.addFirst((T)currNode); } if (!rightMark.coincidesWith(nextNode.getMark())) { result = true; nextNode.setMark(rightMark); - worklist.addFirst(nextNode); + worklist.addFirst((T)nextNode); } } return result; } - public static boolean doOneEnd(final LinkedList init, final OneEndFunctor functor) { + public static boolean doOneEnd(List init, OneEndFunctor functor) { boolean result = false; - final LinkedList worklist = new LinkedList(); + List worklist = new LinkedList<>(); - for (Iterator i = init.iterator(); i.hasNext(); ) { - result = stepOneEnd(i.next(), worklist, functor) || result; + for (T anInit : init) { + result = stepOneEnd(anInit, worklist, functor) || result; } while (worklist.size() > 0) { @@ -88,13 +88,13 @@ public static boolean doOneEnd(final LinkedList init, return result; } - public static boolean doTwoEnds(final LinkedList init, final TwoEndsFunctor functor) { + public static boolean doTwoEnds(LinkedList init, TwoEndsFunctor functor) { boolean result = false; - final LinkedList worklist = new LinkedList(); + LinkedList worklist = new LinkedList<>(); - for (Iterator i = init.iterator(); i.hasNext(); ) { - result = stepTwoEnds(i.next(), worklist, functor) || result; + for (T anInit : init) { + result = stepTwoEnds(anInit, worklist, functor) || result; } while (worklist.size() > 0) { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java index 6aab275f23..f7c49ecc44 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/convertToInstanceMethod/ConvertToInstanceMethodProcessor.java @@ -27,6 +27,8 @@ import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.RefactoringUIUtil; @@ -66,19 +68,14 @@ public class ConvertToInstanceMethodProcessor extends BaseRefactoringProcessor { private final String myOldVisibility; private final String myNewVisibility; - public ConvertToInstanceMethodProcessor( - final Project project, - final PsiMethod method, - final PsiParameter targetParameter, - final String newVisibility - ) { + public ConvertToInstanceMethodProcessor(Project project, PsiMethod method, PsiParameter targetParameter, String newVisibility) { super(project); myMethod = method; myTargetParameter = targetParameter; - LOG.assertTrue(method.hasModifierProperty(PsiModifier.STATIC)); + LOG.assertTrue(method.isStatic()); LOG.assertTrue(myTargetParameter.getDeclarationScope() == myMethod); LOG.assertTrue(myTargetParameter.getType() instanceof PsiClassType); - final PsiType type = myTargetParameter.getType(); + PsiType type = myTargetParameter.getType(); LOG.assertTrue(type instanceof PsiClassType); myTargetClass = ((PsiClassType)type).resolve(); myOldVisibility = VisibilityUtil.getVisibilityModifier(method.getModifierList()); @@ -90,10 +87,12 @@ public PsiClass getTargetClass() { } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new MoveInstanceMethodViewDescriptor(myMethod, myTargetParameter, myTargetClass); } + @Override protected void refreshElements(PsiElement[] elements) { LOG.assertTrue(elements.length == 3); myMethod = (PsiMethod)elements[0]; @@ -102,18 +101,20 @@ protected void refreshElements(PsiElement[] elements) { } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { LOG.assertTrue(myTargetParameter.getDeclarationScope() == myMethod); - final Project project = myMethod.getProject(); + Project project = myMethod.getProject(); - final PsiReference[] methodReferences = + PsiReference[] methodReferences = ReferencesSearch.search(myMethod, GlobalSearchScope.projectScope(project), false).toArray(new PsiReference[0]); - List result = new ArrayList(); - for (final PsiReference ref : methodReferences) { - final PsiElement element = ref.getElement(); + List result = new ArrayList<>(); + for (PsiReference ref : methodReferences) { + PsiElement element = ref.getElement(); if (element instanceof PsiReferenceExpression) { - if (element.getParent() instanceof PsiMethodCallExpression) { - result.add(new MethodCallUsageInfo((PsiMethodCallExpression)element.getParent())); + if (element.getParent() instanceof PsiMethodCallExpression methodCall) { + result.add(new MethodCallUsageInfo(methodCall)); } } else if (element instanceof PsiDocTagValue) { @@ -121,8 +122,8 @@ else if (element instanceof PsiDocTagValue) { } } - for (final PsiReference ref : ReferencesSearch.search(myTargetParameter, new LocalSearchScope(myMethod), false)) { - final PsiElement element = ref.getElement(); + for (PsiReference ref : ReferencesSearch.search(myTargetParameter, new LocalSearchScope(myMethod), false)) { + PsiElement element = ref.getElement(); if (element instanceof PsiReferenceExpression || element instanceof PsiDocParamRef) { result.add(new ParameterUsageInfo(ref)); } @@ -130,7 +131,7 @@ else if (element instanceof PsiDocTagValue) { if (myTargetClass.isInterface()) { PsiClass[] implementingClasses = RefactoringHierarchyUtil.findImplementingClasses(myTargetClass); - for (final PsiClass implementingClass : implementingClasses) { + for (PsiClass implementingClass : implementingClasses) { result.add(new ImplementingClassUsageInfo(implementingClass)); } } @@ -168,7 +169,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag if (index < expressions.length) { PsiExpression instanceValue = expressions[index]; instanceValue = RefactoringUtil.unparenthesizeExpression(instanceValue); - if (instanceValue instanceof PsiLiteralExpression && ((PsiLiteralExpression)instanceValue).getValue() == null) { + if (instanceValue instanceof PsiLiteralExpression literal && literal.getValue() == null) { LocalizeValue message = RefactoringLocalize.zeroContainsCallWithNullArgumentForParameter1( RefactoringUIUtil.getDescription(ConflictsUtil.getContainer(methodCall), true), CommonRefactoringUtil.htmlEmphasize(myTargetParameter.getName()) @@ -200,6 +201,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { } } + @RequiredWriteAction private void doRefactoring(UsageInfo[] usages) throws IncorrectOperationException { myTypeParameterReplacements = buildTypeParameterReplacements(); List inheritors = new ArrayList<>(); @@ -208,14 +210,14 @@ private void doRefactoring(UsageInfo[] usages) throws IncorrectOperationExceptio // Process usages for (UsageInfo usage : usages) { - if (usage instanceof MethodCallUsageInfo) { - processMethodCall((MethodCallUsageInfo)usage); + if (usage instanceof MethodCallUsageInfo methodCallUsageInfo) { + processMethodCall(methodCallUsageInfo); } - else if (usage instanceof ParameterUsageInfo) { - processParameterUsage((ParameterUsageInfo)usage); + else if (usage instanceof ParameterUsageInfo parameterUsageInfo) { + processParameterUsage(parameterUsageInfo); } - else if (usage instanceof ImplementingClassUsageInfo) { - inheritors.add(((ImplementingClassUsageInfo)usage).getPsiClass()); + else if (usage instanceof ImplementingClassUsageInfo implementingClassUsageInfo) { + inheritors.add(implementingClassUsageInfo.getPsiClass()); } } @@ -247,6 +249,7 @@ else if (usage instanceof ImplementingClassUsageInfo) { myMethod.delete(); } + @RequiredWriteAction private void fixVisibility(PsiMethod method, UsageInfo[] usages) throws IncorrectOperationException { PsiModifierList modifierList = method.getModifierList(); if (VisibilityUtil.ESCALATE_VISIBILITY.equals(myNewVisibility)) { @@ -264,27 +267,29 @@ else if (myNewVisibility != null && !myNewVisibility.equals(myOldVisibility)) { } } + @RequiredWriteAction private void prepareTypeParameterReplacement() throws IncorrectOperationException { if (myTypeParameterReplacements == null) { return; } - final Collection typeParameters = myTypeParameterReplacements.keySet(); - for (final PsiTypeParameter parameter : typeParameters) { - for (final PsiReference reference : ReferencesSearch.search(parameter, new LocalSearchScope(myMethod), false)) { - if (reference.getElement() instanceof PsiJavaCodeReferenceElement) { - reference.getElement().putCopyableUserData(BIND_TO_TYPE_PARAMETER, myTypeParameterReplacements.get(parameter)); + Collection typeParameters = myTypeParameterReplacements.keySet(); + for (PsiTypeParameter parameter : typeParameters) { + for (PsiReference reference : ReferencesSearch.search(parameter, new LocalSearchScope(myMethod), false)) { + if (reference.getElement() instanceof PsiJavaCodeReferenceElement codeRefElem) { + codeRefElem.putCopyableUserData(BIND_TO_TYPE_PARAMETER, myTypeParameterReplacements.get(parameter)); } } } - final Set methodTypeParameters = myTypeParameterReplacements.keySet(); - for (final PsiTypeParameter methodTypeParameter : methodTypeParameters) { + Set methodTypeParameters = myTypeParameterReplacements.keySet(); + for (PsiTypeParameter methodTypeParameter : methodTypeParameters) { methodTypeParameter.delete(); } } - private PsiMethod addMethodToClass(final PsiClass targetClass) throws IncorrectOperationException { - final PsiMethod newMethod = (PsiMethod)targetClass.add(myMethod); - final PsiModifierList modifierList = newMethod.getModifierList(); + @RequiredWriteAction + private PsiMethod addMethodToClass(PsiClass targetClass) throws IncorrectOperationException { + PsiMethod newMethod = (PsiMethod)targetClass.add(myMethod); + PsiModifierList modifierList = newMethod.getModifierList(); modifierList.setModifierProperty(PsiModifier.STATIC, false); ChangeContextUtil.decodeContextInfo(newMethod, null, null); if (myTypeParameterReplacements == null) { @@ -292,14 +297,14 @@ private PsiMethod addMethodToClass(final PsiClass targetClass) throws IncorrectO } final Map additionalReplacements; if (targetClass != myTargetClass) { - final PsiSubstitutor superClassSubstitutor = + PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(myTargetClass, targetClass, PsiSubstitutor.EMPTY); - final Map map = calculateReplacementMap(superClassSubstitutor, myTargetClass, targetClass); + Map map = calculateReplacementMap(superClassSubstitutor, myTargetClass, targetClass); if (map == null) { return newMethod; } - additionalReplacements = new HashMap(); - for (final Map.Entry entry : map.entrySet()) { + additionalReplacements = new HashMap<>(); + for (Map.Entry entry : map.entrySet()) { additionalReplacements.put(entry.getValue(), entry.getKey()); } } @@ -308,7 +313,8 @@ private PsiMethod addMethodToClass(final PsiClass targetClass) throws IncorrectO } newMethod.accept(new JavaRecursiveElementVisitor() { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + @RequiredWriteAction + public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { PsiTypeParameter typeParameterToBind = reference.getCopyableUserData(BIND_TO_TYPE_PARAMETER); if (typeParameterToBind != null) { reference.putCopyableUserData(BIND_TO_TYPE_PARAMETER, null); @@ -330,28 +336,29 @@ public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { return newMethod; } + @RequiredWriteAction private void processParameterUsage(ParameterUsageInfo usage) throws IncorrectOperationException { - final PsiReference reference = usage.getReferenceExpression(); - if (reference instanceof PsiReferenceExpression) { - final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)reference; - if (referenceExpression.getParent() instanceof PsiReferenceExpression) { + PsiReference reference = usage.getReferenceExpression(); + if (reference instanceof PsiReferenceExpression refExpr) { + if (refExpr.getParent() instanceof PsiReferenceExpression) { // todo: check for correctness - referenceExpression.delete(); + refExpr.delete(); } else { - final PsiExpression expression = + PsiExpression expression = JavaPsiFacade.getInstance(myMethod.getProject()).getElementFactory().createExpressionFromText("this", null); - referenceExpression.replace(expression); + refExpr.replace(expression); } } else { - final PsiElement element = reference.getElement(); + PsiElement element = reference.getElement(); if (element instanceof PsiDocParamRef) { element.getParent().delete(); } } } + @RequiredWriteAction private void processMethodCall(MethodCallUsageInfo usageInfo) throws IncorrectOperationException { PsiMethodCallExpression methodCall = usageInfo.getMethodCall(); PsiParameterList parameterList = myMethod.getParameterList(); @@ -361,13 +368,13 @@ private void processMethodCall(MethodCallUsageInfo usageInfo) throws IncorrectOp if (arguments.length <= parameterIndex) { return; } - final PsiReferenceExpression methodExpression = methodCall.getMethodExpression(); - final PsiExpression qualifier; + PsiReferenceExpression methodExpression = methodCall.getMethodExpression(); + PsiExpression qualifier; if (methodExpression.getQualifierExpression() != null) { qualifier = methodExpression.getQualifierExpression(); } else { - final PsiReferenceExpression newRefExpr = + PsiReferenceExpression newRefExpr = (PsiReferenceExpression)factory.createExpressionFromText("x." + myMethod.getName(), null); qualifier = ((PsiReferenceExpression)methodExpression.replace(newRefExpr)).getQualifierExpression(); } @@ -375,41 +382,36 @@ private void processMethodCall(MethodCallUsageInfo usageInfo) throws IncorrectOp arguments[parameterIndex].delete(); } + @Nonnull + @Override protected String getCommandName() { return ConvertToInstanceMethodHandler.REFACTORING_NAME; } @Nullable public Map buildTypeParameterReplacements() { - final PsiClassType type = (PsiClassType)myTargetParameter.getType(); - final PsiSubstitutor substitutor = type.resolveGenerics().getSubstitutor(); + PsiClassType type = (PsiClassType)myTargetParameter.getType(); + PsiSubstitutor substitutor = type.resolveGenerics().getSubstitutor(); return calculateReplacementMap(substitutor, myTargetClass, myMethod); } @Nullable private static Map calculateReplacementMap( - final PsiSubstitutor substitutor, - final PsiClass targetClass, - final PsiElement containingElement + PsiSubstitutor substitutor, + PsiClass targetClass, + PsiElement containingElement ) { - final HashMap result = new HashMap(); + Map result = new HashMap<>(); for (PsiTypeParameter classTypeParameter : PsiUtil.typeParametersIterable(targetClass)) { - final PsiType substitution = substitutor.substitute(classTypeParameter); - if (!(substitution instanceof PsiClassType)) { - return null; - } - final PsiClass aClass = ((PsiClassType)substitution).resolve(); - if (!(aClass instanceof PsiTypeParameter)) { - return null; + if (substitutor.substitute(classTypeParameter) instanceof PsiClassType classType + && classType.resolve() instanceof PsiTypeParameter methodTypeParameter + && methodTypeParameter.getOwner() == containingElement + && !result.keySet().contains(methodTypeParameter)) { + result.put(methodTypeParameter, classTypeParameter); } - final PsiTypeParameter methodTypeParameter = (PsiTypeParameter)aClass; - if (methodTypeParameter.getOwner() != containingElement) { - return null; - } - if (result.keySet().contains(methodTypeParameter)) { + else { return null; } - result.put(methodTypeParameter, classTypeParameter); } return result; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java index e340b72f47..b8c6c5312e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineConstantFieldProcessor.java @@ -176,10 +176,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { initializer = normalize((PsiExpression)initializer.copy()); for (UsageInfo info : usages) { - if (info instanceof UsageFromJavaDoc) { - continue; - } - if (info instanceof NonCodeUsageInfo) { + if (info instanceof UsageFromJavaDoc || info instanceof NonCodeUsageInfo) { continue; } PsiElement element = info.getElement(); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java index afa8afa147..bad7d29ee8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineMethodProcessor.java @@ -397,10 +397,9 @@ private static Map> getInaccessible( continue; } PsiElement container = ConflictsUtil.getContainer(usageElement); - if (!(container instanceof PsiMember)) { + if (!(container instanceof PsiMember memberContainer)) { continue; // usage in import statement } - PsiMember memberContainer = (PsiMember)container; Set inaccessibleReferenced = result.get(memberContainer); if (inaccessibleReferenced == null) { inaccessibleReferenced = new HashSet<>(); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceParameter/IntroduceParameterUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceParameter/IntroduceParameterUtil.java index 2b7cb001cd..3cfd157e84 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceParameter/IntroduceParameterUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/introduceParameter/IntroduceParameterUtil.java @@ -15,14 +15,15 @@ */ package com.intellij.java.impl.refactoring.introduceParameter; +import com.intellij.java.impl.refactoring.util.usageInfo.DefaultConstructorImplicitUsageInfo; +import com.intellij.java.impl.refactoring.util.usageInfo.NoConstructorClassUsageInfo; +import com.intellij.java.language.psi.PsiMethod; import consulo.annotation.access.RequiredReadAction; +import consulo.application.Application; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiManager; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.impl.refactoring.util.usageInfo.DefaultConstructorImplicitUsageInfo; -import com.intellij.java.impl.refactoring.util.usageInfo.NoConstructorClassUsageInfo; -import consulo.usage.UsageInfo; import consulo.language.util.IncorrectOperationException; +import consulo.usage.UsageInfo; import java.util.ArrayList; import java.util.List; @@ -46,39 +47,26 @@ public static boolean insideMethodToBeReplaced(PsiElement methodUsage, PsiMethod } public static boolean isMethodUsage(UsageInfo usageInfo) { - for (IntroduceParameterMethodUsagesProcessor processor : IntroduceParameterMethodUsagesProcessor.EP_NAME.getExtensions()) { - if (processor.isMethodUsage(usageInfo)) { - return true; - } - } - return false; + return Application.get().getExtensionPoint(IntroduceParameterMethodUsagesProcessor.class) + .anyMatchSafe(processor -> processor.isMethodUsage(usageInfo)); } public static void addSuperCall(UsageInfo usage, UsageInfo[] usages, IntroduceParameterData data) throws IncorrectOperationException { - for (IntroduceParameterMethodUsagesProcessor processor : IntroduceParameterMethodUsagesProcessor.EP_NAME.getExtensions()) { - if (!processor.processAddSuperCall(data, usage, usages)) { - break; - } - } + Application.get().getExtensionPoint(IntroduceParameterMethodUsagesProcessor.class) + .allMatchSafe(processor -> processor.processAddSuperCall(data, usage, usages)); } public static void addDefaultConstructor(UsageInfo usage, UsageInfo[] usages, IntroduceParameterData data) throws IncorrectOperationException { - for (IntroduceParameterMethodUsagesProcessor processor : IntroduceParameterMethodUsagesProcessor.EP_NAME.getExtensions()) { - if (!processor.processAddDefaultConstructor(data, usage, usages)) { - break; - } - } + Application.get().getExtensionPoint(IntroduceParameterMethodUsagesProcessor.class) + .allMatchSafe(processor -> processor.processAddDefaultConstructor(data, usage, usages)); } public static void changeExternalUsage(UsageInfo usage, UsageInfo[] usages, IntroduceParameterData data) throws IncorrectOperationException { - for (IntroduceParameterMethodUsagesProcessor processor : IntroduceParameterMethodUsagesProcessor.EP_NAME.getExtensions()) { - if (!processor.processChangeMethodUsage(data, usage, usages)) { - break; - } - } + Application.get().getExtensionPoint(IntroduceParameterMethodUsagesProcessor.class) + .allMatchSafe(processor -> processor.processChangeMethodUsage(data, usage, usages)); } public static void changeMethodSignatureAndResolveFieldConflicts( @@ -86,11 +74,8 @@ public static void changeMethodSignatureAndResolveFieldConflicts( UsageInfo[] usages, IntroduceParameterData data ) throws IncorrectOperationException { - for (IntroduceParameterMethodUsagesProcessor processor : IntroduceParameterMethodUsagesProcessor.EP_NAME.getExtensions()) { - if (!processor.processChangeMethodSignature(data, usage, usages)) { - break; - } - } + Application.get().getExtensionPoint(IntroduceParameterMethodUsagesProcessor.class) + .allMatchSafe(processor -> processor.processChangeMethodSignature(data, usage, usages)); } @RequiredReadAction diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/invertBoolean/InvertBooleanProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/invertBoolean/InvertBooleanProcessor.java index 9c6a41d5e8..9e0d873184 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/invertBoolean/InvertBooleanProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/invertBoolean/InvertBooleanProcessor.java @@ -50,6 +50,7 @@ public class InvertBooleanProcessor extends BaseRefactoringProcessor { private final Map myToInvert = new HashMap<>(); private final SmartPointerManager mySmartPointerManager; + @RequiredReadAction public InvertBooleanProcessor(PsiNamedElement namedElement, String newName) { super(namedElement.getProject()); myElement = namedElement; @@ -83,14 +84,14 @@ protected UsageInfo[] findUsages() { addRefsToInvert(toInvert, myElement); - if (myElement instanceof PsiMethod) { - Collection overriders = OverridingMethodsSearch.search((PsiMethod)myElement).findAll(); + if (myElement instanceof PsiMethod currentMethod) { + Collection overriders = OverridingMethodsSearch.search(currentMethod).findAll(); for (PsiMethod overrider : overriders) { myRenameProcessor.addElement(overrider, myNewName); } Collection allMethods = new HashSet<>(overriders); - allMethods.add((PsiMethod)myElement); + allMethods.add(currentMethod); for (PsiMethod method : allMethods) { method.accept(new JavaRecursiveElementWalkingVisitor() { @@ -108,8 +109,7 @@ public void visitClass(@Nonnull PsiClass aClass) { }); } } - else if (myElement instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod) { - PsiMethod method = (PsiMethod)parameter.getDeclarationScope(); + else if (myElement instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod method) { int index = method.getParameterList().getParameterIndex(parameter); LOG.assertTrue(index >= 0); Query methodQuery = MethodReferencesSearch.search(method); @@ -214,18 +214,15 @@ protected void refreshElements(PsiElement[] elements) { private static UsageInfo[] extractUsagesForElement(PsiElement element, UsageInfo[] usages) { ArrayList extractedUsages = new ArrayList<>(usages.length); for (UsageInfo usage : usages) { - if (usage instanceof MoveRenameUsageInfo) { - MoveRenameUsageInfo usageInfo = (MoveRenameUsageInfo)usage; - if (element.equals(usageInfo.getReferencedElement())) { - extractedUsages.add(usageInfo); - } + if (usage instanceof MoveRenameUsageInfo usageInfo && element.equals(usageInfo.getReferencedElement())) { + extractedUsages.add(usageInfo); } } return extractedUsages.toArray(new UsageInfo[extractedUsages.size()]); } @Override - @RequiredReadAction + @RequiredUIAccess protected void performRefactoring(@Nonnull UsageInfo[] usages) { for (PsiElement element : myRenameProcessor.getElements()) { try { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java index 2dbd6d4c70..cee2611289 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/makeStatic/MakeMethodOrClassStaticProcessor.java @@ -20,6 +20,7 @@ import com.intellij.java.indexing.search.searches.OverridingMethodsSearch; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.ConflictsDialog; @@ -42,13 +43,13 @@ import consulo.util.collection.ContainerUtil; import consulo.util.collection.MultiMap; import consulo.util.lang.StringUtil; -import consulo.util.lang.ref.Ref; import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; import java.util.ArrayList; import java.util.HashSet; import java.util.List; +import java.util.Set; /* * @author dsl @@ -67,7 +68,8 @@ public MakeMethodOrClassStaticProcessor(Project project, T member, Settings sett } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new MakeMethodOrClassStaticViewDescriptor(myMember); } @@ -98,7 +100,7 @@ protected final boolean preprocessUsages(@Nonnull SimpleReference r } private static UsageInfo[] filterOverriding(UsageInfo[] usages) { - ArrayList result = new ArrayList(); + List result = new ArrayList<>(); for (UsageInfo usage : usages) { if (!(usage instanceof OverridingMethodUsageInfo)) { result.add(usage); @@ -108,7 +110,7 @@ private static UsageInfo[] filterOverriding(UsageInfo[] usages) { } private static UsageInfo[] filterInternalUsages(UsageInfo[] usages) { - ArrayList result = new ArrayList(); + List result = new ArrayList<>(); for (UsageInfo usage : usages) { if (!(usage instanceof InternalUsageInfo)) { result.add(usage); @@ -117,27 +119,25 @@ private static UsageInfo[] filterInternalUsages(UsageInfo[] usages) { return result.toArray(new UsageInfo[result.size()]); } + @RequiredReadAction protected MultiMap getConflictDescriptions(UsageInfo[] usages) { - MultiMap conflicts = new MultiMap(); - HashSet processed = new HashSet(); + MultiMap conflicts = new MultiMap<>(); + Set processed = new HashSet<>(); String typeString = StringUtil.capitalize(UsageViewUtil.getType(myMember)); for (UsageInfo usageInfo : usages) { - if (usageInfo instanceof InternalUsageInfo && !(usageInfo instanceof SelfUsageInfo)) { - PsiElement referencedElement = ((InternalUsageInfo)usageInfo).getReferencedElement(); + if (usageInfo instanceof InternalUsageInfo internalUsageInfo && !(internalUsageInfo instanceof SelfUsageInfo)) { + PsiElement referencedElement = internalUsageInfo.getReferencedElement(); if (!mySettings.isMakeClassParameter()) { - if (referencedElement instanceof PsiModifierListOwner) { - if (((PsiModifierListOwner)referencedElement).hasModifierProperty(PsiModifier.STATIC)) { + if (referencedElement instanceof PsiModifierListOwner modifierListOwner + && modifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { continue; } - } if (processed.contains(referencedElement)) { continue; } processed.add(referencedElement); - if (referencedElement instanceof PsiField) { - PsiField field = (PsiField)referencedElement; - + if (referencedElement instanceof PsiField field) { if (mySettings.getNameForField(field) == null) { String description = RefactoringUIUtil.getDescription(field, true); LocalizeValue message = @@ -154,7 +154,7 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage } if (usageInfo instanceof OverridingMethodUsageInfo) { LOG.assertTrue(myMember instanceof PsiMethod); - final PsiMethod overridingMethod = (PsiMethod)usageInfo.getElement(); + PsiMethod overridingMethod = (PsiMethod)usageInfo.getElement(); LocalizeValue message = RefactoringLocalize.method0IsOverriddenBy1( RefactoringUIUtil.getDescription(myMember, false), RefactoringUIUtil.getDescription(overridingMethod, true) @@ -169,9 +169,9 @@ protected MultiMap getConflictDescriptions(UsageInfo[] usage } processed.add(container); List fieldParameters = mySettings.getParameterOrderList(); - ArrayList inaccessible = new ArrayList(); + ArrayList inaccessible = new ArrayList<>(); - for (final Settings.FieldParameter fieldParameter : fieldParameters) { + for (Settings.FieldParameter fieldParameter : fieldParameters) { if (!PsiUtil.isAccessible(fieldParameter.field, element, null)) { inaccessible.add(fieldParameter.field); } @@ -193,7 +193,7 @@ private static void createInaccessibleFieldsConflictDescription( MultiMap conflicts ) { if (inaccessible.size() == 1) { - final PsiField field = inaccessible.get(0); + PsiField field = inaccessible.get(0); conflicts.putValue( field, RefactoringLocalize.field0IsNotAccessible( @@ -216,8 +216,9 @@ private static void createInaccessibleFieldsConflictDescription( } @Nonnull + @Override protected UsageInfo[] findUsages() { - ArrayList result = new ArrayList(); + ArrayList result = new ArrayList<>(); ContainerUtil.addAll(result, MakeStaticUtil.findClassRefsInMember(myMember, true)); @@ -225,11 +226,11 @@ protected UsageInfo[] findUsages() { findExternalUsages(result); } - if (myMember instanceof PsiMethod) { - final PsiMethod[] overridingMethods = - OverridingMethodsSearch.search((PsiMethod)myMember, myMember.getUseScope(), false).toArray(PsiMethod.EMPTY_ARRAY); + if (myMember instanceof PsiMethod method) { + PsiMethod[] overridingMethods = + OverridingMethodsSearch.search(method, method.getUseScope(), false).toArray(PsiMethod.EMPTY_ARRAY); for (PsiMethod overridingMethod : overridingMethods) { - if (overridingMethod != myMember) { + if (overridingMethod != method) { result.add(new OverridingMethodUsageInfo(overridingMethod)); } } @@ -240,12 +241,13 @@ protected UsageInfo[] findUsages() { protected abstract void findExternalUsages(ArrayList result); - protected void findExternalReferences(final PsiMethod method, final ArrayList result) { + @RequiredReadAction + protected void findExternalReferences(PsiMethod method, ArrayList result) { for (PsiReference ref : ReferencesSearch.search(method)) { PsiElement element = ref.getElement(); PsiElement qualifier = null; - if (element instanceof PsiReferenceExpression) { - qualifier = ((PsiReferenceExpression)element).getQualifierExpression(); + if (element instanceof PsiReferenceExpression refExpr) { + qualifier = refExpr.getQualifierExpression(); if (qualifier instanceof PsiThisExpression) { qualifier = null; } @@ -258,9 +260,9 @@ protected void findExternalReferences(final PsiMethod method, final ArrayList refUsages) { - final UsageInfo[] usagesIn = refUsages.get(); - final PushDownConflicts pushDownConflicts = new PushDownConflicts(myClass, myMemberInfos); + UsageInfo[] usagesIn = refUsages.get(); + PushDownConflicts pushDownConflicts = new PushDownConflicts(myClass, myMemberInfos); pushDownConflicts.checkSourceClassConflicts(); if (usagesIn.length == 0) { - if (myClass.isEnum() || myClass.hasModifierProperty(PsiModifier.FINAL)) { + if (myClass.isEnum() || myClass.isFinal()) { if (Messages.showOkCancelDialog( ( myClass.isEnum() @@ -121,8 +125,8 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag LocalizeValue noInheritors = myClass.isInterface() ? RefactoringLocalize.interface0DoesNotHaveInheritors(myClass.getQualifiedName()) : RefactoringLocalize.class0DoesNotHaveInheritors(myClass.getQualifiedName()); - final String message = noInheritors + "\n" + RefactoringLocalize.pushDownWillDeleteMembers(); - final int answer = Messages.showYesNoCancelDialog(message, JavaPushDownHandler.REFACTORING_NAME, UIUtil.getWarningIcon()); + String message = noInheritors + "\n" + RefactoringLocalize.pushDownWillDeleteMembers(); + int answer = Messages.showYesNoCancelDialog(message, JavaPushDownHandler.REFACTORING_NAME, UIUtil.getWarningIcon()); if (answer == DialogWrapper.OK_EXIT_CODE) { myCreateClassDlg = CreateSubclassAction.chooseSubclassToCreate(myClass); if (myCreateClassDlg != null) { @@ -138,9 +142,10 @@ else if (answer != 1) { } } } + @RequiredReadAction Runnable runnable = () -> { for (UsageInfo usage : usagesIn) { - final PsiElement element = usage.getElement(); + PsiElement element = usage.getElement(); if (element instanceof PsiClass psiClass) { pushDownConflicts.checkTargetClassConflicts(psiClass, usagesIn.length > 1, element); } @@ -156,29 +161,30 @@ else if (answer != 1) { return processFinished && showConflicts(pushDownConflicts.getConflicts(), usagesIn); } + @Override protected void refreshElements(PsiElement[] elements) { - if (elements.length == 1 && elements[0] instanceof PsiClass) { - myClass = (PsiClass)elements[0]; + if (elements.length == 1 && elements[0] instanceof PsiClass psiClass) { + myClass = psiClass; } else { LOG.assertTrue(false); } } + @Override @RequiredUIAccess protected void performRefactoring(@Nonnull UsageInfo[] usages) { try { encodeRefs(); if (myCreateClassDlg != null) { //usages.length == 0 - final PsiClass psiClass = + PsiClass psiClass = CreateSubclassAction.createSubclass(myClass, myCreateClassDlg.getTargetDirectory(), myCreateClassDlg.getClassName()); if (psiClass != null) { pushDownToClass(psiClass); } } for (UsageInfo usage : usages) { - if (usage.getElement() instanceof PsiClass) { - final PsiClass targetClass = (PsiClass)usage.getElement(); + if (usage.getElement() instanceof PsiClass targetClass) { pushDownToClass(targetClass); } } @@ -199,17 +205,19 @@ protected void encodeRefs() { } for (MemberInfo memberInfo : myMemberInfos) { - final PsiMember member = memberInfo.getMember(); + PsiMember member = memberInfo.getMember(); member.accept(new JavaRecursiveElementVisitor() { @Override + @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { encodeRef(expression, movedMembers, expression); super.visitReferenceExpression(expression); } @Override + @RequiredReadAction public void visitNewExpression(@Nonnull PsiNewExpression expression) { - final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); + PsiJavaCodeReferenceElement classReference = expression.getClassReference(); if (classReference != null) { encodeRef(classReference, movedMembers, expression); } @@ -217,8 +225,9 @@ public void visitNewExpression(@Nonnull PsiNewExpression expression) { } @Override - public void visitTypeElement(@Nonnull final PsiTypeElement type) { - final PsiJavaCodeReferenceElement referenceElement = type.getInnermostComponentReferenceElement(); + @RequiredReadAction + public void visitTypeElement(@Nonnull PsiTypeElement type) { + PsiJavaCodeReferenceElement referenceElement = type.getInnermostComponentReferenceElement(); if (referenceElement != null) { encodeRef(referenceElement, movedMembers, type); } @@ -230,12 +239,12 @@ public void visitTypeElement(@Nonnull final PsiTypeElement type) { } @RequiredReadAction - private void encodeRef(final PsiJavaCodeReferenceElement expression, final Set movedMembers, final PsiElement toPut) { - final PsiElement resolved = expression.resolve(); + private void encodeRef(PsiJavaCodeReferenceElement expression, Set movedMembers, PsiElement toPut) { + PsiElement resolved = expression.resolve(); if (resolved == null) { return; } - final PsiElement qualifier = expression.getQualifier(); + PsiElement qualifier = expression.getQualifier(); for (PsiMember movedMember : movedMembers) { if (movedMember.equals(resolved)) { if (qualifier == null) { @@ -255,7 +264,7 @@ else if (movedMember instanceof PsiClass movedClass } else { if (qualifier instanceof PsiThisExpression thisExpression) { - final PsiJavaCodeReferenceElement qElement = thisExpression.getQualifier(); + PsiJavaCodeReferenceElement qElement = thisExpression.getQualifier(); if (qElement != null && qElement.isReferenceTo(myClass)) { toPut.putCopyableUserData(REPLACE_QUALIFIER_KEY, myClass); } @@ -264,7 +273,7 @@ else if (movedMember instanceof PsiClass movedClass } } - private void decodeRefs(final PsiMember member, final PsiClass targetClass) { + private void decodeRefs(PsiMember member, final PsiClass targetClass) { try { ChangeContextUtil.decodeContextInfo(member, null, null); } @@ -275,14 +284,16 @@ private void decodeRefs(final PsiMember member, final PsiClass targetClass) { final PsiElementFactory factory = JavaPsiFacade.getInstance(myProject).getElementFactory(); member.accept(new JavaRecursiveElementWalkingVisitor() { @Override + @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { decodeRef(expression, factory, targetClass, expression); super.visitReferenceExpression(expression); } @Override + @RequiredReadAction public void visitNewExpression(@Nonnull PsiNewExpression expression) { - final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); + PsiJavaCodeReferenceElement classReference = expression.getClassReference(); if (classReference != null) { decodeRef(classReference, factory, targetClass, expression); } @@ -290,8 +301,9 @@ public void visitNewExpression(@Nonnull PsiNewExpression expression) { } @Override - public void visitTypeElement(@Nonnull final PsiTypeElement type) { - final PsiJavaCodeReferenceElement referenceElement = type.getInnermostComponentReferenceElement(); + @RequiredReadAction + public void visitTypeElement(@Nonnull PsiTypeElement type) { + PsiJavaCodeReferenceElement referenceElement = type.getInnermostComponentReferenceElement(); if (referenceElement != null) { decodeRef(referenceElement, factory, targetClass, type); } @@ -301,16 +313,11 @@ public void visitTypeElement(@Nonnull final PsiTypeElement type) { } @RequiredReadAction - private void decodeRef( - final PsiJavaCodeReferenceElement ref, - final PsiElementFactory factory, - final PsiClass targetClass, - final PsiElement toGet - ) { + private void decodeRef(PsiJavaCodeReferenceElement ref, PsiElementFactory factory, PsiClass targetClass, PsiElement toGet) { try { if (toGet.getCopyableUserData(REMOVE_QUALIFIER_KEY) != null) { toGet.putCopyableUserData(REMOVE_QUALIFIER_KEY, null); - final PsiElement qualifier = ref.getQualifier(); + PsiElement qualifier = ref.getQualifier(); if (qualifier != null) { qualifier.delete(); } @@ -330,12 +337,12 @@ else if (psiClass.getContainingClass() == myClass) { LOG.assertTrue(psiClass != null); } - if (!(qualifier instanceof PsiThisExpression) && ref instanceof PsiReferenceExpression referenceExpression) { - referenceExpression.setQualifierExpression(factory.createReferenceExpression(psiClass)); + if (!(qualifier instanceof PsiThisExpression) && ref instanceof PsiReferenceExpression refExpr) { + refExpr.setQualifierExpression(factory.createReferenceExpression(psiClass)); } else { - if (qualifier instanceof PsiThisExpression thisExpression) { - qualifier = thisExpression.getQualifier(); + if (qualifier instanceof PsiThisExpression thisExpr) { + qualifier = thisExpr.getQualifier(); } qualifier.replace(factory.createReferenceElementByType(factory.createType(psiClass))); } @@ -348,17 +355,17 @@ else if (psiClass.getContainingClass() == myClass) { } } + @RequiredWriteAction private void removeFromTargetClass() throws IncorrectOperationException { for (MemberInfo memberInfo : myMemberInfos) { - final PsiElement member = memberInfo.getMember(); + PsiElement member = memberInfo.getMember(); if (member instanceof PsiField) { member.delete(); } - else if (member instanceof PsiMethod) { + else if (member instanceof PsiMethod method) { if (memberInfo.isToAbstract()) { - final PsiMethod method = (PsiMethod)member; - if (method.hasModifierProperty(PsiModifier.PRIVATE)) { + if (method.isPrivate()) { PsiUtil.setModifierProperty(method, PsiModifier.PROTECTED, true); } RefactoringUtil.makeMethodAbstract(myClass, method); @@ -381,18 +388,18 @@ else if (member instanceof PsiClass psiClass) { @RequiredUIAccess protected void pushDownToClass(PsiClass targetClass) throws IncorrectOperationException { - final PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory(); - final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(myClass, targetClass, PsiSubstitutor.EMPTY); + PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory(); + PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(myClass, targetClass, PsiSubstitutor.EMPTY); for (MemberInfo memberInfo : myMemberInfos) { PsiMember member = memberInfo.getMember(); - final List refsToRebind = new ArrayList<>(); - final PsiModifierList list = member.getModifierList(); + List refsToRebind = new ArrayList<>(); + PsiModifierList list = member.getModifierList(); LOG.assertTrue(list != null); if (list.hasModifierProperty(PsiModifier.STATIC)) { - for (final PsiReference reference : ReferencesSearch.search(member)) { - final PsiElement element = reference.getElement(); + for (PsiReference reference : ReferencesSearch.search(member)) { + PsiElement element = reference.getElement(); if (element instanceof PsiReferenceExpression referenceExpression) { - final PsiExpression qualifierExpression = referenceExpression.getQualifierExpression(); + PsiExpression qualifierExpression = referenceExpression.getQualifierExpression(); if (qualifierExpression instanceof PsiReferenceExpression refExpr && !(refExpr.resolve() instanceof PsiClass)) { continue; } @@ -424,21 +431,21 @@ else if (member instanceof PsiMethod method) { } } else if (memberInfo.isToAbstract()) { - if (newMember.hasModifierProperty(PsiModifier.PRIVATE)) { + if (newMember.isPrivate()) { PsiUtil.setModifierProperty(newMember, PsiModifier.PROTECTED, true); } myJavaDocPolicy.processNewJavaDoc(((PsiMethod)newMember).getDocComment()); } } else { //abstract method: remove @Override - final PsiAnnotation annotation = AnnotationUtil.findAnnotation(methodBySignature, CommonClassNames.JAVA_LANG_OVERRIDE); + PsiAnnotation annotation = AnnotationUtil.findAnnotation(methodBySignature, CommonClassNames.JAVA_LANG_OVERRIDE); if (annotation != null && !leaveOverrideAnnotation(substitutor, method)) { annotation.delete(); } - final PsiDocComment oldDocComment = method.getDocComment(); + PsiDocComment oldDocComment = method.getDocComment(); if (oldDocComment != null) { - final PsiDocComment docComment = methodBySignature.getDocComment(); - final int policy = myJavaDocPolicy.getJavaDocPolicy(); + PsiDocComment docComment = methodBySignature.getDocComment(); + int policy = myJavaDocPolicy.getJavaDocPolicy(); if (policy == DocCommentPolicy.COPY || policy == DocCommentPolicy.MOVE) { if (docComment != null) { docComment.replace(oldDocComment); @@ -452,17 +459,18 @@ else if (memberInfo.isToAbstract()) { } else if (member instanceof PsiClass) { if (Boolean.FALSE.equals(memberInfo.getOverrides())) { - final PsiClass aClass = (PsiClass)memberInfo.getMember(); + PsiClass aClass = (PsiClass)memberInfo.getMember(); PsiClassType classType = null; if (!targetClass.isInheritor(aClass, false)) { - final PsiClassType[] types = memberInfo.getSourceReferenceList().getReferencedTypes(); + PsiClassType[] types = memberInfo.getSourceReferenceList().getReferencedTypes(); for (PsiClassType type : types) { if (type.resolve() == aClass) { classType = (PsiClassType)substitutor.substitute(type); } } PsiJavaCodeReferenceElement classRef = classType != null - ? factory.createReferenceElementByType(classType) : factory.createClassReferenceElement(aClass); + ? factory.createReferenceElementByType(classType) + : factory.createClassReferenceElement(aClass); if (aClass.isInterface()) { targetClass.getImplementsList().add(classRef); } @@ -483,25 +491,26 @@ else if (member instanceof PsiClass) { for (PsiReference psiReference : refsToRebind) { JavaCodeStyleManager.getInstance(myProject).shortenClassReferences(psiReference.bindToElement(newMember)); } - final JavaRefactoringListenerManager listenerManager = JavaRefactoringListenerManager.getInstance(newMember.getProject()); + JavaRefactoringListenerManager listenerManager = JavaRefactoringListenerManager.getInstance(newMember.getProject()); ((JavaRefactoringListenerManagerImpl)listenerManager).fireMemberMoved(myClass, newMember); } } } + @RequiredReadAction private boolean leaveOverrideAnnotation(PsiSubstitutor substitutor, PsiMethod method) { - final PsiMethod methodBySignature = MethodSignatureUtil.findMethodBySignature(myClass, method.getSignature(substitutor), false); + PsiMethod methodBySignature = MethodSignatureUtil.findMethodBySignature(myClass, method.getSignature(substitutor), false); if (methodBySignature == null) { return false; } - final PsiMethod[] superMethods = methodBySignature.findDeepestSuperMethods(); + PsiMethod[] superMethods = methodBySignature.findDeepestSuperMethods(); if (superMethods.length == 0) { return false; } - final boolean is15 = !PsiUtil.isLanguageLevel6OrHigher(methodBySignature); + boolean is15 = !PsiUtil.isLanguageLevel6OrHigher(methodBySignature); if (is15) { for (PsiMethod psiMethod : superMethods) { - final PsiClass aClass = psiMethod.getContainingClass(); + PsiClass aClass = psiMethod.getContainingClass(); if (aClass != null && aClass.isInterface()) { return false; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesUtil.java index 999c064c52..7167e8ddb2 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesUtil.java @@ -97,7 +97,7 @@ public static void findNonCodeUsages( boolean searchInNonJavaFiles, PsiElement element, String newQName, - ArrayList results + List results ) { String stringToSearch = getStringToSearch(element); if (stringToSearch == null) { diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java index 8e35a8b4ad..9891353c4c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/move/moveInner/MoveInnerProcessor.java @@ -24,6 +24,8 @@ import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import com.intellij.java.language.psi.codeStyle.VariableKind; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.fileEditor.FileEditorManager; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.CodeInsightUtilCore; @@ -53,10 +55,8 @@ import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.*; -import java.util.function.Function; /** * @author Jeka @@ -83,33 +83,39 @@ public MoveInnerProcessor(Project project, MoveCallback moveCallback) { myMoveCallback = moveCallback; } + @RequiredReadAction public MoveInnerProcessor( Project project, PsiClass innerClass, String name, boolean passOuterClass, String parameterName, - final PsiElement targetContainer + PsiElement targetContainer ) { super(project); setup(innerClass, name, passOuterClass, parameterName, true, true, targetContainer); } + @Nonnull + @Override protected String getCommandName() { return RefactoringLocalize.moveInnerClassCommand(myDescriptiveName).get(); } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new MoveInnerViewDescriptor(myInnerClass); } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { LOG.assertTrue(myTargetContainer != null); Collection innerClassRefs = ReferencesSearch.search(myInnerClass).findAll(); - ArrayList usageInfos = new ArrayList(innerClassRefs.size()); + List usageInfos = new ArrayList<>(innerClassRefs.size()); for (PsiReference innerClassRef : innerClassRefs) { PsiElement ref = innerClassRef.getElement(); if (!PsiTreeUtil.isAncestor(myInnerClass, ref, true)) { // do not show self-references @@ -117,15 +123,14 @@ protected UsageInfo[] findUsages() { } } - final String newQName; - if (myTargetContainer instanceof PsiDirectory) { - final PsiDirectory targetDirectory = (PsiDirectory)myTargetContainer; - final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(targetDirectory); + String newQName; + if (myTargetContainer instanceof PsiDirectory targetDirectory) { + PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(targetDirectory); LOG.assertTrue(aPackage != null); newQName = aPackage.getQualifiedName() + "." + myNewClassName; } - else if (myTargetContainer instanceof PsiClass) { - final String qName = ((PsiClass)myTargetContainer).getQualifiedName(); + else if (myTargetContainer instanceof PsiClass psiClass) { + String qName = psiClass.getQualifiedName(); if (qName != null) { newQName = qName + "." + myNewClassName; } @@ -146,6 +151,7 @@ else if (myTargetContainer instanceof PsiClass) { return usageInfos.toArray(new UsageInfo[usageInfos.size()]); } + @Override protected void refreshElements(PsiElement[] elements) { boolean condition = elements.length == 1 && elements[0] instanceof PsiClass; LOG.assertTrue(condition); @@ -168,11 +174,13 @@ public void setSearchInNonJavaFiles(boolean searchInNonJavaFiles) { mySearchInNonJavaFiles = searchInNonJavaFiles; } - protected void performRefactoring(final UsageInfo[] usages) { - final PsiManager manager = PsiManager.getInstance(myProject); - final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); + @Override + @RequiredWriteAction + protected void performRefactoring(@Nonnull UsageInfo[] usages) { + PsiManager manager = PsiManager.getInstance(myProject); + PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - final RefactoringElementListener elementListener = getTransaction().getElementListener(myInnerClass); + RefactoringElementListener elementListener = getTransaction().getElementListener(myInnerClass); try { PsiField field = null; if (myParameterNameOuterClass != null) { @@ -187,9 +195,9 @@ protected void performRefactoring(final UsageInfo[] usages) { myInnerClass = CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(myInnerClass); - final MoveInnerOptions moveInnerOptions = new MoveInnerOptions(myInnerClass, myOuterClass, myTargetContainer, myNewClassName); - final MoveInnerHandler handler = MoveInnerHandler.forLanguage(myInnerClass.getLanguage()); - final PsiClass newClass; + MoveInnerOptions moveInnerOptions = new MoveInnerOptions(myInnerClass, myOuterClass, myTargetContainer, myNewClassName); + MoveInnerHandler handler = MoveInnerHandler.forLanguage(myInnerClass.getLanguage()); + PsiClass newClass; try { newClass = handler.copyClass(moveInnerOptions); } @@ -201,18 +209,15 @@ protected void performRefactoring(final UsageInfo[] usages) { // replace references in a new class to old inner class with references to itself for (PsiReference ref : ReferencesSearch.search(myInnerClass, new LocalSearchScope(newClass), true)) { PsiElement element = ref.getElement(); - if (element.getParent() instanceof PsiJavaCodeReferenceElement) { - PsiJavaCodeReferenceElement parentRef = (PsiJavaCodeReferenceElement)element.getParent(); - PsiElement parentRefElement = parentRef.resolve(); - if (parentRefElement instanceof PsiClass) { // reference to inner class inside our inner - parentRef.getQualifier().delete(); - continue; - } + if (element.getParent() instanceof PsiJavaCodeReferenceElement parentRef && parentRef.resolve() instanceof PsiClass) { + // reference to inner class inside our inner + parentRef.getQualifier().delete(); + continue; } ref.bindToElement(newClass); } - List referencesToRebind = new ArrayList(); + List referencesToRebind = new ArrayList<>(); for (UsageInfo usage : usages) { if (usage.isNonCodeUsage) { continue; @@ -237,9 +242,7 @@ protected void performRefactoring(final UsageInfo[] usages) { if (myParameterNameOuterClass != null) { // should pass outer as parameter PsiElement refParent = refElement.getParent(); if (refParent instanceof PsiNewExpression || refParent instanceof PsiAnonymousClass) { - PsiNewExpression newExpr = refParent instanceof PsiNewExpression - ? (PsiNewExpression)refParent - : (PsiNewExpression)refParent.getParent(); + PsiNewExpression newExpr = refParent instanceof PsiNewExpression ne ? ne : (PsiNewExpression)refParent.getParent(); PsiExpressionList argList = newExpr.getArgumentList(); @@ -269,18 +272,14 @@ protected void performRefactoring(final UsageInfo[] usages) { } if (field != null) { - final PsiExpression paramAccessExpression = factory.createExpressionFromText(myParameterNameOuterClass, null); - for (final PsiMethod constructor : newClass.getConstructors()) { - final PsiStatement[] statements = constructor.getBody().getStatements(); - if (statements.length > 0) { - if (statements[0] instanceof PsiExpressionStatement) { - PsiExpression expression = ((PsiExpressionStatement)statements[0]).getExpression(); - if (expression instanceof PsiMethodCallExpression) { - @NonNls String text = ((PsiMethodCallExpression)expression).getMethodExpression().getText(); - if ("this".equals(text) || "super".equals(text)) { - ChangeContextUtil.decodeContextInfo(expression, myOuterClass, paramAccessExpression); - } - } + PsiExpression paramAccessExpression = factory.createExpressionFromText(myParameterNameOuterClass, null); + for (PsiMethod constructor : newClass.getConstructors()) { + PsiStatement[] statements = constructor.getBody().getStatements(); + if (statements.length > 0 && statements[0] instanceof PsiExpressionStatement exprStmt + && exprStmt.getExpression() instanceof PsiMethodCallExpression methodCall) { + String text = methodCall.getMethodExpression().getText(); + if ("this".equals(text) || "super".equals(text)) { + ChangeContextUtil.decodeContextInfo(methodCall, myOuterClass, paramAccessExpression); } } } @@ -304,10 +303,10 @@ protected void performRefactoring(final UsageInfo[] usages) { } elementListener.elementMoved(newClass); - List nonCodeUsages = new ArrayList(); + List nonCodeUsages = new ArrayList<>(); for (UsageInfo usage : usages) { - if (usage instanceof NonCodeUsageInfo) { - nonCodeUsages.add((NonCodeUsageInfo)usage); + if (usage instanceof NonCodeUsageInfo nonCodeUsageInfo) { + nonCodeUsages.add(nonCodeUsageInfo); } } myNonCodeUsages = nonCodeUsages.toArray(new NonCodeUsageInfo[nonCodeUsages.size()]); @@ -317,11 +316,12 @@ protected void performRefactoring(final UsageInfo[] usages) { } } + @RequiredWriteAction private PsiField addOuterField(PsiField field) { - final PsiMember[] members = PsiTreeUtil.getChildrenOfType(myInnerClass, PsiMember.class); + PsiMember[] members = PsiTreeUtil.getChildrenOfType(myInnerClass, PsiMember.class); if (members != null) { for (PsiMember member : members) { - if (!member.hasModifierProperty(PsiModifier.STATIC)) { + if (!member.isStatic()) { return (PsiField)myInnerClass.addBefore(field, member); } } @@ -330,6 +330,8 @@ private PsiField addOuterField(PsiField field) { return (PsiField)myInnerClass.add(field); } + @Override + @RequiredWriteAction protected void performPsiSpoilingRefactoring() { if (myNonCodeUsages != null) { RenameUtil.renameNonCodeUsages(myProject, myNonCodeUsages); @@ -339,23 +341,21 @@ protected void performPsiSpoilingRefactoring() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap(); - final HashMap> reported = new HashMap>(); + final MultiMap conflicts = new MultiMap<>(); + final Map> reported = new HashMap<>(); class Visitor extends JavaRecursiveElementWalkingVisitor { - - @Override + @RequiredReadAction public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - PsiElement resolved = reference.resolve(); - if (resolved instanceof PsiMember && - PsiTreeUtil.isAncestor(myInnerClass, resolved, true) && - becomesInaccessible((PsiMember)resolved)) { - registerConflict(reference, resolved, reported, conflicts); + if (reference.resolve() instanceof PsiMember member + && PsiTreeUtil.isAncestor(myInnerClass, member, true) + && becomesInaccessible(member)) { + registerConflict(reference, member, reported, conflicts); } } @Override - public void visitClass(PsiClass aClass) { + public void visitClass(@Nonnull PsiClass aClass) { if (aClass == myInnerClass) { return; } @@ -363,19 +363,19 @@ public void visitClass(PsiClass aClass) { } } -// if (myInnerClass.hasModifierProperty(PsiModifier.)) { + //if (myInnerClass.hasModifierProperty(PsiModifier.)) { myOuterClass.accept(new Visitor()); myInnerClass.accept(new JavaRecursiveElementWalkingVisitor() { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + @RequiredReadAction + public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); - final PsiElement resolve = reference.resolve(); - if (resolve instanceof PsiMember) { - if (PsiTreeUtil.isAncestor(myOuterClass, resolve, true) && !PsiTreeUtil.isAncestor(myInnerClass, resolve, false)) { - if (becomesInaccessible((PsiMember)resolve)) { - registerConflict(reference, resolve, reported, conflicts); - } - } + PsiElement resolve = reference.resolve(); + if (resolve instanceof PsiMember member + && PsiTreeUtil.isAncestor(myOuterClass, member, true) + && !PsiTreeUtil.isAncestor(myInnerClass, resolve, false) + && becomesInaccessible(member)) { + registerConflict(reference, member, reported, conflicts); } } }); @@ -386,12 +386,13 @@ public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { private static void registerConflict( PsiJavaCodeReferenceElement reference, PsiElement resolved, - HashMap> reported, MultiMap conflicts + Map> reported, + MultiMap conflicts ) { - final PsiElement container = ConflictsUtil.getContainer(reference); - HashSet containerSet = reported.get(container); + PsiElement container = ConflictsUtil.getContainer(reference); + Set containerSet = reported.get(container); if (containerSet == null) { - containerSet = new HashSet(); + containerSet = new HashSet<>(); reported.put(container, containerSet); } if (!containerSet.contains(resolved)) { @@ -401,12 +402,9 @@ private static void registerConflict( placesDescription = RefactoringUIUtil.getDescription(resolved, true); } else { - placesDescription = "
  1. " + StringUtil.join(containerSet, new Function() { - @Override - public String apply(PsiElement element) { - return RefactoringUIUtil.getDescription(element, true); - } - }, "
  2. ") + "
"; + placesDescription = "
  1. " + + StringUtil.join(containerSet, element -> RefactoringUIUtil.getDescription(element, true), "
  2. ") + + "
"; } LocalizeValue message = RefactoringLocalize.zeroWillBecomeInaccessibleFrom1(placesDescription, RefactoringUIUtil.getDescription(container, true)); @@ -415,25 +413,25 @@ public String apply(PsiElement element) { } private boolean becomesInaccessible(PsiMember element) { - final String visibilityModifier = VisibilityUtil.getVisibilityModifier(element.getModifierList()); + String visibilityModifier = VisibilityUtil.getVisibilityModifier(element.getModifierList()); if (PsiModifier.PRIVATE.equals(visibilityModifier)) { return true; } if (PsiModifier.PUBLIC.equals(visibilityModifier)) { return false; } - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); - if (myTargetContainer instanceof PsiDirectory) { - final PsiJavaPackage aPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)myTargetContainer); - assert aPackage != null : myTargetContainer; + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); + if (myTargetContainer instanceof PsiDirectory directory) { + PsiJavaPackage aPackage = JavaDirectoryService.getInstance().getPackage(directory); + assert aPackage != null : directory; return !psiFacade.isInPackage(myOuterClass, aPackage); } // target container is a class PsiFile targetFile = myTargetContainer.getContainingFile(); if (targetFile != null) { - final PsiDirectory containingDirectory = targetFile.getContainingDirectory(); + PsiDirectory containingDirectory = targetFile.getContainingDirectory(); if (containingDirectory != null) { - final PsiJavaPackage targetPackage = JavaDirectoryService.getInstance().getPackage(containingDirectory); + PsiJavaPackage targetPackage = JavaDirectoryService.getInstance().getPackage(containingDirectory); assert targetPackage != null : myTargetContainer; return psiFacade.isInPackage(myOuterClass, targetPackage); } @@ -441,14 +439,15 @@ private boolean becomesInaccessible(PsiMember element) { return false; } + @RequiredReadAction public void setup( - final PsiClass innerClass, - final String className, - final boolean passOuterClass, - final String parameterName, + PsiClass innerClass, + String className, + boolean passOuterClass, + String parameterName, boolean searchInComments, boolean searchInNonJava, - @Nonnull final PsiElement targetContainer + @Nonnull PsiElement targetContainer ) { myNewClassName = className; myInnerClass = innerClass; @@ -466,6 +465,7 @@ public void setup( mySearchInNonJavaFiles = searchInNonJava; } + @RequiredWriteAction private void addFieldInitializationToConstructors(PsiClass aClass, PsiField field, String parameterName) throws IncorrectOperationException { @@ -483,16 +483,12 @@ private void addFieldInitializationToConstructors(PsiClass aClass, PsiField fiel continue; } PsiStatement[] statements = body.getStatements(); - if (statements.length > 0) { - PsiStatement first = statements[0]; - if (first instanceof PsiExpressionStatement) { - PsiExpression expression = ((PsiExpressionStatement)first).getExpression(); - if (expression instanceof PsiMethodCallExpression) { - @NonNls String text = ((PsiMethodCallExpression)expression).getMethodExpression().getText(); - if ("this".equals(text)) { - continue; - } - } + if (statements.length > 0 + && statements[0] instanceof PsiExpressionStatement expressionStmt + && expressionStmt.getExpression() instanceof PsiMethodCallExpression methodCall) { + String text = methodCall.getMethodExpression().getText(); + if ("this".equals(text)) { + continue; } } createAssignmentStatement(constructor, field.getName(), parameterName); @@ -514,7 +510,7 @@ private PsiStatement createAssignmentStatement(PsiMethod constructor, String fie throws IncorrectOperationException { PsiElementFactory factory = JavaPsiFacade.getInstance(myProject).getElementFactory(); - @NonNls String pattern = fieldName + "=a;"; + String pattern = fieldName + "=a;"; if (fieldName.equals(parameterName)) { pattern = "this." + pattern; } @@ -536,20 +532,15 @@ private PsiStatement createAssignmentStatement(PsiMethod constructor, String fie } @Nullable + @RequiredReadAction private static PsiElement getAnchorElement(PsiCodeBlock body) { PsiStatement[] statements = body.getStatements(); - if (statements.length > 0) { - PsiStatement first = statements[0]; - if (first instanceof PsiExpressionStatement) { - - PsiExpression expression = ((PsiExpressionStatement)first).getExpression(); - if (expression instanceof PsiMethodCallExpression) { - PsiReferenceExpression methodCall = ((PsiMethodCallExpression)expression).getMethodExpression(); - @NonNls String text = methodCall.getText(); - if ("super".equals(text)) { - return first; - } - } + if (statements.length > 0 && statements[0] instanceof PsiExpressionStatement exprStmt + && exprStmt.getExpression() instanceof PsiMethodCallExpression methodCallExpr) { + PsiReferenceExpression methodCall = methodCallExpr.getMethodExpression(); + String text = methodCall.getText(); + if ("super".equals(text)) { + return exprStmt; } } return null; @@ -567,7 +558,6 @@ public boolean shouldPassParameter() { return myParameterNameOuterClass != null; } - public String getParameterName() { return myParameterNameOuterClass; }