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 a93cc3b0de..face5fa6a1 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 @@ -28,79 +28,79 @@ * To change this template use Options | File Templates. */ public class GlobalAnalyzer { - private static boolean stepOneEnd(MarkedNode currNode, LinkedList worklist, OneEndFunctor functor) { - boolean result = false; - - for (Iterator i = currNode.outIterator(); i.hasNext();) { - MarkedEdge currEdge = (MarkedEdge)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); - } + private static boolean stepOneEnd(MarkedNode currNode, LinkedList worklist, OneEndFunctor functor) { + boolean result = false; + + for (Iterator i = currNode.outIterator(); i.hasNext(); ) { + MarkedEdge currEdge = (MarkedEdge)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); + } + } + + return result; } - return result; - } + private static boolean stepTwoEnds(final MarkedNode currNode, final LinkedList worklist, final TwoEndsFunctor functor) { + boolean result = false; - private static boolean stepTwoEnds(final MarkedNode currNode, final LinkedList worklist, final 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()); - 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()); + final Mark leftMark = markPair.getFirst(); + final Mark rightMark = markPair.getSecond(); - final Mark leftMark = markPair.getFirst(); - final Mark rightMark = markPair.getSecond(); + if (!leftMark.coincidesWith(currNode.getMark())) { + result = true; + currNode.setMark(leftMark); + worklist.addFirst(currNode); + } - if (!leftMark.coincidesWith(currNode.getMark())) { - result = true; - currNode.setMark(leftMark); - worklist.addFirst(currNode); - } + if (!rightMark.coincidesWith(nextNode.getMark())) { + result = true; + nextNode.setMark(rightMark); + worklist.addFirst(nextNode); + } + } - if (!rightMark.coincidesWith(nextNode.getMark())) { - result = true; - nextNode.setMark(rightMark); - worklist.addFirst(nextNode); - } + return result; } - return result; - } + public static boolean doOneEnd(final LinkedList init, final OneEndFunctor functor) { + boolean result = false; - public static boolean doOneEnd(final LinkedList init, final OneEndFunctor functor) { - boolean result = false; + final LinkedList worklist = new LinkedList(); - final LinkedList worklist = new LinkedList(); + for (Iterator i = init.iterator(); i.hasNext(); ) { + result = stepOneEnd(i.next(), worklist, functor) || result; + } - for (Iterator i = init.iterator(); i.hasNext();) { - result = stepOneEnd(i.next(), worklist, functor) || result; - } + while (worklist.size() > 0) { + result = stepOneEnd(worklist.removeFirst(), worklist, functor) || result; + } - while (worklist.size() > 0) { - result = stepOneEnd(worklist.removeFirst(), worklist, functor) || result; + return result; } - return result; - } + public static boolean doTwoEnds(final LinkedList init, final TwoEndsFunctor functor) { + boolean result = false; - public static boolean doTwoEnds(final LinkedList init, final TwoEndsFunctor functor) { - boolean result = false; + final LinkedList worklist = new LinkedList(); - final LinkedList worklist = new LinkedList(); + for (Iterator i = init.iterator(); i.hasNext(); ) { + result = stepTwoEnds(i.next(), worklist, functor) || result; + } - for (Iterator i = init.iterator(); i.hasNext();) { - result = stepTwoEnds(i.next(), worklist, functor) || result; - } + while (worklist.size() > 0) { + result = stepTwoEnds(worklist.removeFirst(), worklist, functor) || result; + } - while (worklist.size() > 0) { - result = stepTwoEnds(worklist.removeFirst(), worklist, functor) || result; + return result; } - - return result; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java index cea397bfbb..e00ddcc1d5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java @@ -19,6 +19,7 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.ui.RefactoringUIUtil; import consulo.language.psi.PsiElement; @@ -121,6 +122,7 @@ protected UsageInfo[] findUsages() { } @Override + @RequiredWriteAction protected void performRefactoring(@Nonnull UsageInfo[] usages) { LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName()); try { @@ -134,6 +136,7 @@ protected void performRefactoring(@Nonnull UsageInfo[] usages) { } } + @RequiredWriteAction private void doRefactoring(UsageInfo[] usages) throws IncorrectOperationException { PsiTypeParameter[] typeParameters = myClass.getTypeParameters(); boolean[] toRemoveParms = detectRemovedParameters(typeParameters); @@ -162,6 +165,7 @@ public void visitTypeElement(@Nonnull PsiTypeElement typeElement) { changeClassSignature(typeParameters, toRemoveParms); } + @RequiredWriteAction private void changeClassSignature(PsiTypeParameter[] originalTypeParameters, boolean[] toRemoveParms) throws IncorrectOperationException { PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory(); @@ -190,6 +194,7 @@ private boolean[] detectRemovedParameters(PsiTypeParameter[] originaltypeParamet return toRemoveParms; } + @RequiredWriteAction private void processUsage(UsageInfo usage, PsiTypeParameter[] originalTypeParameters, boolean[] toRemoveParms) throws IncorrectOperationException { PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory(); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureProcessor.java index 78e815eec6..2c1a1ffa7b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureProcessor.java @@ -244,8 +244,7 @@ private void askToRemoveCovariantOverriders(Set usages) { if (PsiUtil.isLanguageLevel5OrHigher(myChangeInfo.getMethod())) { List covariantOverriderInfos = new ArrayList<>(); for (UsageInfo usageInfo : usages) { - if (usageInfo instanceof OverriderUsageInfo) { - OverriderUsageInfo info = (OverriderUsageInfo)usageInfo; + if (usageInfo instanceof OverriderUsageInfo info) { PsiMethod overrider = info.getElement(); PsiMethod baseMethod = info.getBaseMethod(); PsiSubstitutor substitutor = calculateSubstitutor(overrider, baseMethod); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureUtil.java index e2818df42f..af4849e726 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/changeSignature/ChangeSignatureUtil.java @@ -18,6 +18,7 @@ import com.intellij.java.language.psi.JavaTokenType; import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.PsiType; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.refactoring.RefactoringSupportProvider; import consulo.language.editor.refactoring.changeSignature.ChangeSignatureHandler; import consulo.language.editor.util.PsiUtilBase; @@ -39,11 +40,12 @@ public class ChangeSignatureUtil { private ChangeSignatureUtil() { } + @RequiredWriteAction public static void synchronizeList( Parent list, - final List newElements, + List newElements, ChildrenGenerator generator, - final boolean[] shouldRemoveChild + boolean[] shouldRemoveChild ) throws IncorrectOperationException { ArrayList elementsToRemove = null; List elements; @@ -89,7 +91,7 @@ else if (newElements.size() > 1 && (!elements.isEmpty() || index < newElements.s else { anchor = index - 1 < elements.size() ? elements.get(index - 1) : null; } - final PsiElement psi = Factory.createSingleLeafElement( + PsiElement psi = Factory.createSingleLeafElement( JavaTokenType.COMMA, ",", 0, @@ -114,7 +116,7 @@ else if (newElements.size() > 1 && (!elements.isEmpty() || index < newElements.s @RequiredUIAccess public static void invokeChangeSignatureOn(PsiMethod method, Project project) { - final ChangeSignatureHandler handler = RefactoringSupportProvider.forLanguage(method.getLanguage()).getChangeSignatureHandler(); + ChangeSignatureHandler handler = RefactoringSupportProvider.forLanguage(method.getLanguage()).getChangeSignatureHandler(); handler.invoke(project, new PsiElement[]{method}, null); } @@ -122,6 +124,7 @@ public static boolean deepTypeEqual(PsiType type1, PsiType type2) { if (type1 == type2) { return true; } + //noinspection SimplifiableIfStatement if (type1 == null || !type1.equals(type2)) { return false; } 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 5e174c3ab0..6aab275f23 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 @@ -142,17 +142,17 @@ else if (element instanceof PsiDocTagValue) { @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { UsageInfo[] usagesIn = refUsages.get(); - MultiMap conflicts = new MultiMap(); - final Set methods = Collections.singleton((PsiMember)myMethod); + MultiMap conflicts = new MultiMap<>(); + Set methods = Collections.singleton((PsiMember)myMethod); if (!myTargetClass.isInterface()) { RefactoringConflictsUtil.analyzeAccessibilityConflicts(methods, myTargetClass, conflicts, myNewVisibility); } else { - for (final UsageInfo usage : usagesIn) { - if (usage instanceof ImplementingClassUsageInfo) { + for (UsageInfo usage : usagesIn) { + if (usage instanceof ImplementingClassUsageInfo implementingClassUsageInfo) { RefactoringConflictsUtil.analyzeAccessibilityConflicts( methods, - ((ImplementingClassUsageInfo)usage).getPsiClass(), + implementingClassUsageInfo.getPsiClass(), conflicts, PsiModifier.PUBLIC ); @@ -160,11 +160,11 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag } } - for (final UsageInfo usageInfo : usagesIn) { - if (usageInfo instanceof MethodCallUsageInfo) { - final PsiMethodCallExpression methodCall = ((MethodCallUsageInfo)usageInfo).getMethodCall(); - final PsiExpression[] expressions = methodCall.getArgumentList().getExpressions(); - final int index = myMethod.getParameterList().getParameterIndex(myTargetParameter); + for (UsageInfo usageInfo : usagesIn) { + if (usageInfo instanceof MethodCallUsageInfo methodCallUsageInfo) { + PsiMethodCallExpression methodCall = methodCallUsageInfo.getMethodCall(); + PsiExpression[] expressions = methodCall.getArgumentList().getExpressions(); + int index = myMethod.getParameterList().getParameterIndex(myTargetParameter); if (index < expressions.length) { PsiExpression instanceValue = expressions[index]; instanceValue = RefactoringUtil.unparenthesizeExpression(instanceValue); @@ -182,7 +182,9 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag return showConflicts(conflicts, usagesIn); } - protected void performRefactoring(UsageInfo[] usages) { + @Override + @RequiredUIAccess + protected void performRefactoring(@Nonnull UsageInfo[] usages) { if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, myTargetClass)) { return; } @@ -200,12 +202,12 @@ protected void performRefactoring(UsageInfo[] usages) { private void doRefactoring(UsageInfo[] usages) throws IncorrectOperationException { myTypeParameterReplacements = buildTypeParameterReplacements(); - List inheritors = new ArrayList(); + List inheritors = new ArrayList<>(); CommonRefactoringUtil.sortDepthFirstRightLeftOrder(usages); // Process usages - for (final UsageInfo usage : usages) { + for (UsageInfo usage : usages) { if (usage instanceof MethodCallUsageInfo) { processMethodCall((MethodCallUsageInfo)usage); } @@ -225,15 +227,15 @@ else if (usage instanceof ImplementingClassUsageInfo) { fixVisibility(method, usages); } else { - final PsiMethod interfaceMethod = addMethodToClass(myTargetClass); - final PsiModifierList modifierList = interfaceMethod.getModifierList(); + PsiMethod interfaceMethod = addMethodToClass(myTargetClass); + PsiModifierList modifierList = interfaceMethod.getModifierList(); modifierList.setModifierProperty(PsiModifier.PRIVATE, false); modifierList.setModifierProperty(PsiModifier.PUBLIC, false); modifierList.setModifierProperty(PsiModifier.PROTECTED, false); RefactoringUtil.makeMethodAbstract(myTargetClass, interfaceMethod); - for (final PsiClass psiClass : inheritors) { - final PsiMethod newMethod = addMethodToClass(psiClass); + for (PsiClass psiClass : inheritors) { + PsiMethod newMethod = addMethodToClass(psiClass); PsiUtil.setModifierProperty( newMethod, myNewVisibility != null && !myNewVisibility.equals(VisibilityUtil.ESCALATE_VISIBILITY) ? myNewVisibility @@ -245,12 +247,12 @@ else if (usage instanceof ImplementingClassUsageInfo) { myMethod.delete(); } - private void fixVisibility(final PsiMethod method, final UsageInfo[] usages) throws IncorrectOperationException { - final PsiModifierList modifierList = method.getModifierList(); + private void fixVisibility(PsiMethod method, UsageInfo[] usages) throws IncorrectOperationException { + PsiModifierList modifierList = method.getModifierList(); if (VisibilityUtil.ESCALATE_VISIBILITY.equals(myNewVisibility)) { for (UsageInfo usage : usages) { if (usage instanceof MethodCallUsageInfo) { - final PsiElement place = usage.getElement(); + PsiElement place = usage.getElement(); if (place != null) { VisibilityUtil.escalateVisibility(method, place); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java index 997827f107..5ea51cb7b0 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java @@ -23,6 +23,7 @@ import com.intellij.java.language.psi.util.PsiFormatUtil; import com.intellij.java.language.psi.util.PsiFormatUtilBase; 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.RefactoringUIUtil; @@ -38,10 +39,10 @@ import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.usage.UsageInfo; import consulo.usage.UsageViewDescriptor; import consulo.usage.UsageViewUtil; -import consulo.util.collection.ContainerUtil; import consulo.util.collection.MultiMap; import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; @@ -79,46 +80,51 @@ public static void setNewFieldVisibility(PsiField field, EncapsulateFieldsDescri } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { FieldDescriptor[] fields = new FieldDescriptor[myFieldDescriptors.length]; System.arraycopy(myFieldDescriptors, 0, fields, 0, myFieldDescriptors.length); return new EncapsulateFieldsViewDescriptor(fields); } + @Nonnull + @Override + @RequiredReadAction protected String getCommandName() { return RefactoringLocalize.encapsulateFieldsCommandName(DescriptiveNameUtil.getDescriptiveName(myClass)).get(); } @Override + @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap(); + MultiMap conflicts = new MultiMap<>(); checkExistingMethods(conflicts, true); checkExistingMethods(conflicts, false); - final Collection classes = ClassInheritorsSearch.search(myClass).findAll(); + Collection classes = ClassInheritorsSearch.search(myClass).findAll(); for (FieldDescriptor fieldDescriptor : myFieldDescriptors) { - final Set setters = new HashSet(); - final Set getters = new HashSet(); + Set setters = new HashSet<>(); + Set getters = new HashSet<>(); for (PsiClass aClass : classes) { - final PsiMethod getterOverrider = + PsiMethod getterOverrider = myDescriptor.isToEncapsulateGet() ? aClass.findMethodBySignature(fieldDescriptor.getGetterPrototype(), false) : null; if (getterOverrider != null) { getters.add(getterOverrider); } - final PsiMethod setterOverrider = + PsiMethod setterOverrider = myDescriptor.isToEncapsulateSet() ? aClass.findMethodBySignature(fieldDescriptor.getSetterPrototype(), false) : null; if (setterOverrider != null) { setters.add(setterOverrider); } } if (!getters.isEmpty() || !setters.isEmpty()) { - final PsiField field = fieldDescriptor.getField(); + PsiField field = fieldDescriptor.getField(); for (PsiReference reference : ReferencesSearch.search(field)) { - final PsiElement place = reference.getElement(); + PsiElement place = reference.getElement(); LOG.assertTrue(place instanceof PsiReferenceExpression); - final PsiExpression qualifierExpression = ((PsiReferenceExpression)place).getQualifierExpression(); - final PsiClass ancestor; + PsiExpression qualifierExpression = ((PsiReferenceExpression)place).getQualifierExpression(); + PsiClass ancestor; if (qualifierExpression == null) { ancestor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false); } @@ -126,7 +132,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag ancestor = PsiUtil.resolveClassInType(qualifierExpression.getType()); } - final boolean isGetter = !PsiUtil.isAccessedForWriting((PsiExpression)place); + boolean isGetter = !PsiUtil.isAccessedForWriting((PsiExpression)place); for (PsiMethod overridden : isGetter ? getters : setters) { if (InheritanceUtil.isInheritorOrSelf(myClass, ancestor, true)) { conflicts.putValue(overridden, "There is already a " + @@ -142,6 +148,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag return showConflicts(conflicts, refUsages.get()); } + @RequiredReadAction private void checkExistingMethods(MultiMap conflicts, boolean isGetter) { if (isGetter) { if (!myDescriptor.isToEncapsulateGet()) { @@ -157,12 +164,12 @@ else if (!myDescriptor.isToEncapsulateSet()) { ? descriptor.getGetterPrototype() : descriptor.getSetterPrototype(); - final PsiType prototypeReturnType = prototype.getReturnType(); + PsiType prototypeReturnType = prototype.getReturnType(); PsiMethod existing = myClass.findMethodBySignature(prototype, true); if (existing != null) { - final PsiType returnType = existing.getReturnType(); + PsiType returnType = existing.getReturnType(); if (!RefactoringUtil.equivalentTypes(prototypeReturnType, returnType, myClass.getManager())) { - final String descr = PsiFormatUtil.formatMethod( + String descr = PsiFormatUtil.formatMethod( existing, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS | PsiFormatUtilBase.SHOW_TYPE, @@ -186,10 +193,10 @@ else if (!myDescriptor.isToEncapsulateSet()) { existing = containingClass.findMethodBySignature(prototype, true); if (existing != null) { for (PsiReference reference : ReferencesSearch.search(existing)) { - final PsiElement place = reference.getElement(); + PsiElement place = reference.getElement(); LOG.assertTrue(place instanceof PsiReferenceExpression); - final PsiExpression qualifierExpression = ((PsiReferenceExpression)place).getQualifierExpression(); - final PsiClass inheritor; + PsiExpression qualifierExpression = ((PsiReferenceExpression)place).getQualifierExpression(); + PsiClass inheritor; if (qualifierExpression == null) { inheritor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false); } @@ -216,16 +223,18 @@ else if (!myDescriptor.isToEncapsulateSet()) { } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { - ArrayList array = ContainerUtil.newArrayList(); + ArrayList array = new ArrayList<>(); for (FieldDescriptor fieldDescriptor : myFieldDescriptors) { - for (final PsiReference reference : ReferencesSearch.search(fieldDescriptor.getField())) { - final PsiElement element = reference.getElement(); + for (PsiReference reference : ReferencesSearch.search(fieldDescriptor.getField())) { + PsiElement element = reference.getElement(); if (element == null) { continue; } - final EncapsulateFieldHelper helper = EncapsulateFieldHelper.getHelper(element.getLanguage()); + EncapsulateFieldHelper helper = EncapsulateFieldHelper.forLanguage(element.getLanguage()); EncapsulateFieldUsageInfo usageInfo = helper.createUsage(myDescriptor, fieldDescriptor, reference); if (usageInfo != null) { array.add(usageInfo); @@ -236,6 +245,7 @@ protected UsageInfo[] findUsages() { return UsageViewUtil.removeDuplicatedUsages(usageInfos); } + @Override protected void refreshElements(PsiElement[] elements) { LOG.assertTrue(elements.length == myFieldDescriptors.length); @@ -250,7 +260,8 @@ protected void refreshElements(PsiElement[] elements) { myClass = myFieldDescriptors[0].getField().getContainingClass(); } - protected void performRefactoring(UsageInfo[] usages) { + @Override + protected void performRefactoring(@Nonnull UsageInfo[] usages) { updateFieldVisibility(); generateAccessors(); processUsagesPerFile(usages); @@ -268,24 +279,24 @@ private void updateFieldVisibility() { private void generateAccessors() { // generate accessors - myNameToGetter = new HashMap(); - myNameToSetter = new HashMap(); + myNameToGetter = new HashMap<>(); + myNameToSetter = new HashMap<>(); for (FieldDescriptor fieldDescriptor : myFieldDescriptors) { - final DocCommentPolicy commentPolicy = new DocCommentPolicy(myDescriptor.getJavadocPolicy()); + DocCommentPolicy commentPolicy = new DocCommentPolicy<>(myDescriptor.getJavadocPolicy()); PsiField field = fieldDescriptor.getField(); - final PsiDocComment docComment = field.getDocComment(); + PsiDocComment docComment = field.getDocComment(); if (myDescriptor.isToEncapsulateGet()) { - final PsiMethod prototype = fieldDescriptor.getGetterPrototype(); + PsiMethod prototype = fieldDescriptor.getGetterPrototype(); assert prototype != null; - final PsiMethod getter = addOrChangeAccessor(prototype, myNameToGetter); + PsiMethod getter = addOrChangeAccessor(prototype, myNameToGetter); if (docComment != null) { - final PsiDocComment getterJavadoc = (PsiDocComment)getter.addBefore(docComment, getter.getFirstChild()); + PsiDocComment getterJavadoc = (PsiDocComment)getter.addBefore(docComment, getter.getFirstChild()); commentPolicy.processNewJavaDoc(getterJavadoc); } } - if (myDescriptor.isToEncapsulateSet() && !field.hasModifierProperty(PsiModifier.FINAL)) { + if (myDescriptor.isToEncapsulateSet() && !field.isFinal()) { PsiMethod prototype = fieldDescriptor.getSetterPrototype(); assert prototype != null; addOrChangeAccessor(prototype, myNameToSetter); @@ -298,16 +309,16 @@ private void generateAccessors() { } private void processUsagesPerFile(UsageInfo[] usages) { - Map> usagesInFiles = new HashMap>(); + Map> usagesInFiles = new HashMap<>(); for (UsageInfo usage : usages) { PsiElement element = usage.getElement(); if (element == null) { continue; } - final PsiFile file = element.getContainingFile(); + PsiFile file = element.getContainingFile(); List usagesInFile = usagesInFiles.get(file); if (usagesInFile == null) { - usagesInFile = new ArrayList(); + usagesInFile = new ArrayList<>(); usagesInFiles.put(file, usagesInFile); } usagesInFile.add(((EncapsulateFieldUsageInfo)usage)); @@ -315,11 +326,11 @@ private void processUsagesPerFile(UsageInfo[] usages) { for (List usageInfos : usagesInFiles.values()) { //this is to avoid elements to become invalid as a result of processUsage - final EncapsulateFieldUsageInfo[] infos = usageInfos.toArray(new EncapsulateFieldUsageInfo[usageInfos.size()]); + EncapsulateFieldUsageInfo[] infos = usageInfos.toArray(new EncapsulateFieldUsageInfo[usageInfos.size()]); CommonRefactoringUtil.sortDepthFirstRightLeftOrder(infos); for (EncapsulateFieldUsageInfo info : infos) { - EncapsulateFieldHelper helper = EncapsulateFieldHelper.getHelper(info.getElement().getLanguage()); + EncapsulateFieldHelper helper = EncapsulateFieldHelper.forLanguage(info.getElement().getLanguage()); helper.processUsage( info, myDescriptor, diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java index 43e9e8d45d..4328ed1852 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/extractclass/ExtractClassProcessor.java @@ -38,7 +38,6 @@ import consulo.annotation.access.RequiredReadAction; import consulo.application.Application; import consulo.application.Result; -import consulo.ide.impl.idea.openapi.module.ModuleUtil; import consulo.java.localize.JavaRefactoringLocalize; import consulo.language.ast.IElementType; import consulo.language.codeStyle.CodeStyleManager; @@ -145,8 +144,8 @@ public ExtractClassProcessor( ContainerUtil.addAll(typeParams, sourceClass.getTypeParameters()); } else { - final Set typeParamSet = new HashSet<>(); - final TypeParametersVisitor visitor = new TypeParametersVisitor(typeParamSet); + Set typeParamSet = new HashSet<>(); + TypeParametersVisitor visitor = new TypeParametersVisitor(typeParamSet); for (PsiField field : fields) { field.accept(visitor); } @@ -174,7 +173,7 @@ public PsiClass getCreatedClass() { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final MultiMap conflicts = new MultiMap<>(); + MultiMap conflicts = new MultiMap<>(); myExtractEnumProcessor.findEnumConstantConflicts(refUsages); if (!DestinationFolderComboBox.isAccessible( myProject, @@ -187,9 +186,9 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag ); } Application.get().runWriteAction(myClass::delete); - final Project project = sourceClass.getProject(); - final GlobalSearchScope scope = GlobalSearchScope.allScope(project); - final PsiClass existingClass = + Project project = sourceClass.getProject(); + GlobalSearchScope scope = GlobalSearchScope.allScope(project); + PsiClass existingClass = JavaPsiFacade.getInstance(project).findClass(StringUtil.getQualifiedName(newPackageName, newClassName), scope); if (existingClass != null) { conflicts.putValue( @@ -202,15 +201,15 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag if (!myGenerateAccessors) { calculateInitializersConflicts(conflicts); - final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass(); - final NecessaryAccessorsVisitor srcVisitor = checkNecessaryGettersSetters4SourceClass(); - final Set fieldsNeedingGetter = new LinkedHashSet<>(); + NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass(); + NecessaryAccessorsVisitor srcVisitor = checkNecessaryGettersSetters4SourceClass(); + Set fieldsNeedingGetter = new LinkedHashSet<>(); fieldsNeedingGetter.addAll(visitor.getFieldsNeedingGetter()); fieldsNeedingGetter.addAll(srcVisitor.getFieldsNeedingGetter()); for (PsiField field : fieldsNeedingGetter) { conflicts.putValue(field, LocalizeValue.localizeTODO("Field \'" + field.getName() + "\' needs getter").get()); } - final Set fieldsNeedingSetter = new LinkedHashSet<>(); + Set fieldsNeedingSetter = new LinkedHashSet<>(); fieldsNeedingSetter.addAll(visitor.getFieldsNeedingSetter()); fieldsNeedingSetter.addAll(srcVisitor.getFieldsNeedingSetter()); for (PsiField field : fieldsNeedingSetter) { @@ -223,7 +222,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag private void calculateInitializersConflicts(MultiMap conflicts) { - final PsiClassInitializer[] initializers = sourceClass.getInitializers(); + PsiClassInitializer[] initializers = sourceClass.getInitializers(); for (PsiClassInitializer initializer : initializers) { if (initializerDependsOnMoved(initializer)) { conflicts.putValue(initializer, LocalizeValue.localizeTODO("Class initializer requires moved members").get()); @@ -241,7 +240,7 @@ private boolean initializerDependsOnMoved(PsiElement initializer) { initializer.accept(new JavaRecursiveElementWalkingVisitor() { @Override @RequiredReadAction - public void visitReferenceExpression(final PsiReferenceExpression expression) { + public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); if (expression.resolve() instanceof PsiMember member) { dependsOnMoved[0] |= !member.isStatic() && isInMovedElement(member); @@ -252,10 +251,10 @@ public void visitReferenceExpression(final PsiReferenceExpression expression) { } private String calculateDelegateFieldName() { - final Project project = sourceClass.getProject(); - final JavaCodeStyleSettings settings = JavaCodeStyleSettings.getInstance(sourceClass.getContainingFile()); + Project project = sourceClass.getProject(); + JavaCodeStyleSettings settings = JavaCodeStyleSettings.getInstance(sourceClass.getContainingFile()); - final String baseName = settings.FIELD_NAME_PREFIX.length() == 0 ? StringUtil.decapitalize(newClassName) : newClassName; + String baseName = settings.FIELD_NAME_PREFIX.length() == 0 ? StringUtil.decapitalize(newClassName) : newClassName; String name = settings.FIELD_NAME_PREFIX + baseName + settings.FIELD_NAME_SUFFIX; if (!existsFieldWithName(name) && !PsiNameHelper.getInstance(project).isKeyword(name)) { return name; @@ -271,7 +270,7 @@ private String calculateDelegateFieldName() { } private boolean existsFieldWithName(String name) { - final PsiField[] allFields = sourceClass.getAllFields(); + PsiField[] allFields = sourceClass.getAllFields(); for (PsiField field : allFields) { if (name.equals(field.getName()) && !fields.contains(field)) { return true; @@ -295,7 +294,7 @@ protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usa @Override @RequiredReadAction protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { - final PsiClass psiClass = buildClass(); + PsiClass psiClass = buildClass(); if (psiClass == null) { return; } @@ -305,16 +304,16 @@ protected void performRefactoring(@Nonnull UsageInfo[] usageInfos) { myExtractEnumProcessor.performEnumConstantTypeMigration(usageInfos); final Set members = new HashSet<>(); for (PsiMethod method : methods) { - final PsiMethod member = psiClass.findMethodBySignature(method, false); + PsiMethod member = psiClass.findMethodBySignature(method, false); if (member != null) { members.add(member); } } for (PsiField field : fields) { - final PsiField member = psiClass.findFieldByName(field.getName(), false); + PsiField member = psiClass.findFieldByName(field.getName(), false); if (member != null) { members.add(member); - final PsiExpression initializer = member.getInitializer(); + PsiExpression initializer = member.getInitializer(); if (initializer != null) { final boolean[] moveInitializerToConstructor = new boolean[1]; initializer.accept(new JavaRecursiveElementWalkingVisitor() { @@ -329,7 +328,7 @@ public void visitReferenceExpression(PsiReferenceExpression expression) { }); if (moveInitializerToConstructor[0]) { - final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject); + PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject); PsiMethod[] constructors = psiClass.getConstructors(); if (constructors.length == 0) { PsiMethod constructor = (PsiMethod)elementFactory.createConstructor().setName(psiClass.getName()); @@ -740,7 +739,7 @@ private PsiClass buildClass() { directory = myMoveDestination.getTargetDirectory(containingDirectory); } else { - Module module = ModuleUtil.findModuleForPsiElement(containingFile); + Module module = containingFile.getModule(); assert module != null; directory = PackageUtil.findOrCreateDirectoryForPackage(module, newPackageName, containingDirectory, false, true); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java index 4790363717..cf2ca85822 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java @@ -32,6 +32,8 @@ import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.util.*; import com.intellij.java.language.util.VisibilityUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.ide.impl.find.PsiElement2UsageTargetAdapter; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.refactoring.BaseRefactoringProcessor; @@ -55,7 +57,6 @@ import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.*; @@ -85,7 +86,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { private final boolean myIsInnerClassNeeded; private Set myClassInheritors; private HashSet myAbstractDelegatedMethods; - private final Map mySuperClassesToSubstitutors = new HashMap(); + private final Map mySuperClassesToSubstitutors = new HashMap<>(); public InheritanceToDelegationProcessor( Project project, @@ -119,15 +120,15 @@ public InheritanceToDelegationProcessor( myFieldName = fieldName; - final String propertyName = JavaCodeStyleManager.getInstance(myProject).variableNameToPropertyName(myFieldName, VariableKind.FIELD); + String propertyName = JavaCodeStyleManager.getInstance(myProject).variableNameToPropertyName(myFieldName, VariableKind.FIELD); myGetterName = PropertyUtil.suggestGetterName(propertyName, myBaseClassType); myGenerateGetter = generateGetter; - myDelegatedInterfaces = new LinkedHashSet(); + myDelegatedInterfaces = new LinkedHashSet<>(); addAll(myDelegatedInterfaces, delegatedInterfaces); - myDelegatedMethods = new LinkedHashSet(); + myDelegatedMethods = new LinkedHashSet<>(); addAll(myDelegatedMethods, delegatedMethods); - myDelegatedMethodsVisibility = new HashMap(); + myDelegatedMethodsVisibility = new HashMap<>(); for (PsiMethod method : myDelegatedMethods) { MethodSignature signature = method.getSignature(getSuperSubstitutor(method.getContainingClass())); PsiMethod overridingMethod = MethodSignatureUtil.findMethodBySignature(myClass, signature, false); @@ -139,7 +140,7 @@ public InheritanceToDelegationProcessor( myOverriddenMethods = getOverriddenMethods(); } - private PsiSubstitutor getSuperSubstitutor(final PsiClass superClass) { + private PsiSubstitutor getSuperSubstitutor(PsiClass superClass) { PsiSubstitutor result = mySuperClassesToSubstitutors.get(superClass); if (result == null) { result = TypeConversionUtil.getSuperClassSubstitutor(superClass, myClass, PsiSubstitutor.EMPTY); @@ -149,21 +150,23 @@ private PsiSubstitutor getSuperSubstitutor(final PsiClass superClass) { } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new InheritanceToDelegationViewDescriptor(myClass); } @Nonnull + @Override protected UsageInfo[] findUsages() { - ArrayList usages = new ArrayList(); - final PsiClass[] inheritors = ClassInheritorsSearch.search(myClass, true).toArray(PsiClass.EMPTY_ARRAY); - myClassInheritors = new HashSet(); + ArrayList usages = new ArrayList<>(); + PsiClass[] inheritors = ClassInheritorsSearch.search(myClass, true).toArray(PsiClass.EMPTY_ARRAY); + myClassInheritors = new HashSet<>(); myClassInheritors.add(myClass); addAll(myClassInheritors, inheritors); { ClassReferenceScanner scanner = new ClassReferenceSearchingScanner(myClass); - final MyClassInstanceReferenceVisitor instanceReferenceVisitor = new MyClassInstanceReferenceVisitor(myClass, usages); + MyClassInstanceReferenceVisitor instanceReferenceVisitor = new MyClassInstanceReferenceVisitor(myClass, usages); scanner.processReferences(new ClassInstanceScanner(myClass, instanceReferenceVisitor)); MyClassMemberReferencesVisitor visitor = new MyClassMemberReferencesVisitor(usages, instanceReferenceVisitor); @@ -190,14 +193,14 @@ private FieldAccessibility getFieldAccessibility(PsiElement element) { @Override @RequiredUIAccess protected boolean preprocessUsages(@Nonnull SimpleReference refUsages) { - final UsageInfo[] usagesIn = refUsages.get(); - ArrayList oldUsages = new ArrayList(); + UsageInfo[] usagesIn = refUsages.get(); + List oldUsages = new ArrayList<>(); addAll(oldUsages, usagesIn); - final ObjectUpcastedUsageInfo[] objectUpcastedUsageInfos = objectUpcastedUsages(usagesIn); + ObjectUpcastedUsageInfo[] objectUpcastedUsageInfos = objectUpcastedUsages(usagesIn); if (myPrepareSuccessfulSwingThreadCallback != null) { - MultiMap conflicts = new MultiMap(); + MultiMap conflicts = new MultiMap<>(); if (objectUpcastedUsageInfos.length > 0) { - final LocalizeValue message = RefactoringLocalize.instancesOf0UpcastedTo1WereFound( + LocalizeValue message = RefactoringLocalize.instancesOf0UpcastedTo1WereFound( RefactoringUIUtil.getDescription(myClass, true), CommonRefactoringUtil.htmlEmphasize(CommonClassNames.JAVA_LANG_OBJECT) ); @@ -222,24 +225,24 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag setPreviewUsages(true); } } - ArrayList filteredUsages = filterUsages(oldUsages); + List filteredUsages = filterUsages(oldUsages); refUsages.set(filteredUsages.toArray(new UsageInfo[filteredUsages.size()])); prepareSuccessful(); return true; } + @RequiredReadAction private void analyzeConflicts(UsageInfo[] usage, MultiMap conflicts) { - HashMap> reportedNonDelegatedUsages = new HashMap>(); - HashMap> reportedUpcasts = new HashMap>(); - //HashSet reportedObjectUpcasts = new HashSet(); + Map> reportedNonDelegatedUsages = new HashMap<>(); + Map> reportedUpcasts = new HashMap<>(); + //Set reportedObjectUpcasts = new HashSet(); - //final String nameJavaLangObject = ConflictsUtil.htmlEmphasize(CommonClassNames.JAVA_LANG_OBJECT); - final String classDescription = RefactoringUIUtil.getDescription(myClass, false); + //String nameJavaLangObject = ConflictsUtil.htmlEmphasize(CommonClassNames.JAVA_LANG_OBJECT); + String classDescription = RefactoringUIUtil.getDescription(myClass, false); for (UsageInfo aUsage : usage) { - final PsiElement element = aUsage.getElement(); - if (aUsage instanceof InheritanceToDelegationUsageInfo) { - InheritanceToDelegationUsageInfo usageInfo = (InheritanceToDelegationUsageInfo)aUsage; + PsiElement element = aUsage.getElement(); + if (aUsage instanceof InheritanceToDelegationUsageInfo usageInfo) { /*if (usageInfo instanceof ObjectUpcastedUsageInfo) { PsiElement container = ConflictsUtil.getContainer(usageInfo.element); if (!reportedObjectUpcasts.contains(container)) { @@ -250,14 +253,14 @@ private void analyzeConflicts(UsageInfo[] usage, MultiMap co } } else*/ if (!myIsDelegateOtherMembers && !usageInfo.getDelegateFieldAccessible().isAccessible()) { - if (usageInfo instanceof NonDelegatedMemberUsageInfo) { - final PsiElement nonDelegatedMember = ((NonDelegatedMemberUsageInfo)usageInfo).nonDelegatedMember; - HashSet reportedContainers = reportedNonDelegatedUsages.get(nonDelegatedMember); + if (usageInfo instanceof NonDelegatedMemberUsageInfo nonDelegatedMemberUsageInfo) { + PsiElement nonDelegatedMember = nonDelegatedMemberUsageInfo.nonDelegatedMember; + Set reportedContainers = reportedNonDelegatedUsages.get(nonDelegatedMember); if (reportedContainers == null) { - reportedContainers = new HashSet(); + reportedContainers = new HashSet<>(); reportedNonDelegatedUsages.put(nonDelegatedMember, reportedContainers); } - final PsiElement container = ConflictsUtil.getContainer(element); + PsiElement container = ConflictsUtil.getContainer(element); if (!reportedContainers.contains(container)) { LocalizeValue message = RefactoringLocalize.zeroUses1OfAnInstanceOfA2( RefactoringUIUtil.getDescription(container, true), @@ -268,14 +271,14 @@ private void analyzeConflicts(UsageInfo[] usage, MultiMap co reportedContainers.add(container); } } - else if (usageInfo instanceof UpcastedUsageInfo) { - final PsiClass upcastedTo = ((UpcastedUsageInfo)usageInfo).upcastedTo; - HashSet reportedContainers = reportedUpcasts.get(upcastedTo); + else if (usageInfo instanceof UpcastedUsageInfo upcastedUsageInfo) { + PsiClass upcastedTo = upcastedUsageInfo.upcastedTo; + Set reportedContainers = reportedUpcasts.get(upcastedTo); if (reportedContainers == null) { - reportedContainers = new HashSet(); + reportedContainers = new HashSet<>(); reportedUpcasts.put(upcastedTo, reportedContainers); } - final PsiElement container = ConflictsUtil.getContainer(element); + PsiElement container = ConflictsUtil.getContainer(element); if (!reportedContainers.contains(container)) { LocalizeValue message = RefactoringLocalize.zeroUpcastsAnInstanceOf1To2( RefactoringUIUtil.getDescription(container, true), @@ -299,20 +302,20 @@ else if (aUsage instanceof NoLongerOverridingSubClassMethodUsageInfo info) { } private static ObjectUpcastedUsageInfo[] objectUpcastedUsages(UsageInfo[] usages) { - ArrayList result = new ArrayList(); + List result = new ArrayList<>(); for (UsageInfo usage : usages) { - if (usage instanceof ObjectUpcastedUsageInfo) { - result.add(((ObjectUpcastedUsageInfo)usage)); + if (usage instanceof ObjectUpcastedUsageInfo objectUpcastedUsageInfo) { + result.add(objectUpcastedUsageInfo); } } return result.toArray(new ObjectUpcastedUsageInfo[result.size()]); } - private ArrayList filterUsages(ArrayList usages) { - ArrayList result = new ArrayList(); + private List filterUsages(List usages) { + List result = new ArrayList<>(); for (UsageInfo usageInfo : usages) { - if (!(usageInfo instanceof InheritanceToDelegationUsageInfo)) { + if (!(usageInfo instanceof InheritanceToDelegationUsageInfo inheritanceToDelegationUsageInfo)) { continue; } if (usageInfo instanceof ObjectUpcastedUsageInfo) { @@ -320,8 +323,7 @@ private ArrayList filterUsages(ArrayList usages) { } if (!myIsDelegateOtherMembers) { - final FieldAccessibility delegateFieldAccessible = - ((InheritanceToDelegationUsageInfo)usageInfo).getDelegateFieldAccessible(); + FieldAccessibility delegateFieldAccessible = inheritanceToDelegationUsageInfo.getDelegateFieldAccessible(); if (!delegateFieldAccessible.isAccessible()) { continue; } @@ -334,7 +336,7 @@ private ArrayList filterUsages(ArrayList usages) { private void processClass(PsiClass inheritor, ArrayList usages) { ClassReferenceScanner scanner = new ClassReferenceSearchingScanner(inheritor); - final MyClassInstanceReferenceVisitor instanceVisitor = new MyClassInstanceReferenceVisitor(inheritor, usages); + MyClassInstanceReferenceVisitor instanceVisitor = new MyClassInstanceReferenceVisitor(inheritor, usages); scanner.processReferences(new ClassInstanceScanner(inheritor, instanceVisitor)); MyClassInheritorMemberReferencesVisitor classMemberVisitor = new MyClassInheritorMemberReferencesVisitor(inheritor, usages, instanceVisitor); @@ -343,18 +345,17 @@ private void processClass(PsiClass inheritor, ArrayList usages) { PsiMethod[] methods = inheritor.getMethods(); for (PsiMethod method : methods) { - final PsiMethod baseMethod = findSuperMethodInBaseClass(method); + PsiMethod baseMethod = findSuperMethodInBaseClass(method); if (baseMethod != null) { - if (!baseMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + if (!baseMethod.isAbstract()) { usages.add(new NoLongerOverridingSubClassMethodUsageInfo(method, baseMethod)); } else { - final PsiMethod[] methodsByName = myClass.findMethodsByName(method.getName(), false); - for (final PsiMethod classMethod : methodsByName) { - final MethodSignature signature = classMethod.getSignature(inheritorSubstitutor); - if (signature.equals(method.getSignature(PsiSubstitutor.EMPTY))) { - if (!classMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + PsiMethod[] methodsByName = myClass.findMethodsByName(method.getName(), false); + for (PsiMethod classMethod : methodsByName) { + MethodSignature signature = classMethod.getSignature(inheritorSubstitutor); + if (signature.equals(method.getSignature(PsiSubstitutor.EMPTY)) && !classMethod.isAbstract()) { usages.add(new NoLongerOverridingSubClassMethodUsageInfo(method, baseMethod)); break; } @@ -363,27 +364,26 @@ private void processClass(PsiClass inheritor, ArrayList usages) { } } } - } + @Override + @RequiredWriteAction protected void performRefactoring(UsageInfo[] usages) { try { for (UsageInfo aUsage : usages) { - InheritanceToDelegationUsageInfo usage = (InheritanceToDelegationUsageInfo)aUsage; - - - if (usage instanceof UnqualifiedNonDelegatedMemberUsageInfo) { + if (aUsage instanceof UnqualifiedNonDelegatedMemberUsageInfo unqualifiedNonDelegatedMemberUsageInfo) { delegateUsageFromClass( - usage.getElement(), - ((NonDelegatedMemberUsageInfo)usage).nonDelegatedMember, - usage.getDelegateFieldAccessible() + unqualifiedNonDelegatedMemberUsageInfo.getElement(), + unqualifiedNonDelegatedMemberUsageInfo.nonDelegatedMember, + unqualifiedNonDelegatedMemberUsageInfo.getDelegateFieldAccessible() ); } else { + InheritanceToDelegationUsageInfo usage = (InheritanceToDelegationUsageInfo)aUsage; upcastToDelegation(usage.getElement(), usage.getDelegateFieldAccessible()); } } - myAbstractDelegatedMethods = new HashSet(); + myAbstractDelegatedMethods = new HashSet<>(); addInnerClass(); addField(usages); delegateMethods(); @@ -394,16 +394,17 @@ protected void performRefactoring(UsageInfo[] usages) { } } + @RequiredWriteAction private void addInnerClass() throws IncorrectOperationException { if (!myIsInnerClassNeeded) { return; } PsiClass innerClass = myFactory.createClass(myInnerClassName); - final PsiSubstitutor superClassSubstitutor = + PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(myBaseClass, myClass, PsiSubstitutor.EMPTY); - final PsiClassType superClassType = myFactory.createType(myBaseClass, superClassSubstitutor); - final PsiJavaCodeReferenceElement baseClassReferenceElement = myFactory.createReferenceElementByType(superClassType); + PsiClassType superClassType = myFactory.createType(myBaseClass, superClassSubstitutor); + PsiJavaCodeReferenceElement baseClassReferenceElement = myFactory.createReferenceElementByType(superClassType); if (!myBaseClass.isInterface()) { innerClass.getExtendsList().add(baseClassReferenceElement); } @@ -419,19 +420,19 @@ private void addInnerClass() throws IncorrectOperationException { } } + @RequiredWriteAction private void delegateUsageFromClass( PsiElement element, PsiElement nonDelegatedMember, FieldAccessibility fieldAccessibility ) throws IncorrectOperationException { - if (element instanceof PsiReferenceExpression) { - PsiReferenceExpression referenceExpression = (PsiReferenceExpression)element; - if (referenceExpression.getQualifierExpression() != null) { - upcastToDelegation(referenceExpression.getQualifierExpression(), fieldAccessibility); + if (element instanceof PsiReferenceExpression refExpr) { + if (refExpr.getQualifierExpression() != null) { + upcastToDelegation(refExpr.getQualifierExpression(), fieldAccessibility); } else { - final String name = ((PsiNamedElement)nonDelegatedMember).getName(); - final String qualifier; + String name = ((PsiNamedElement)nonDelegatedMember).getName(); + String qualifier; if (isStatic(nonDelegatedMember)) { qualifier = myBaseClass.getName(); } @@ -448,16 +449,15 @@ else if (!fieldAccessibility.isAccessible() && myGenerateGetter) { } } else if (element instanceof PsiJavaCodeReferenceElement) { - final String name = ((PsiNamedElement)nonDelegatedMember).getName(); + String name = ((PsiNamedElement)nonDelegatedMember).getName(); PsiElement parent = element.getParent(); - if (!isStatic(nonDelegatedMember) && parent instanceof PsiNewExpression) { - final PsiNewExpression newExpr = (PsiNewExpression)parent; + if (!isStatic(nonDelegatedMember) && parent instanceof PsiNewExpression newExpr) { if (newExpr.getQualifier() != null) { upcastToDelegation(newExpr.getQualifier(), fieldAccessibility); } else { - final String qualifier; + String qualifier; if (!fieldAccessibility.isAccessible() && myGenerateGetter) { qualifier = myGetterName + "()"; } @@ -468,7 +468,7 @@ else if (element instanceof PsiJavaCodeReferenceElement) { } } else { - final String qualifier = myBaseClass.getName(); + String qualifier = myBaseClass.getName(); PsiJavaCodeReferenceElement newRef = myFactory.createFQClassNameReferenceElement(qualifier + "." + name, element.getResolveScope()); //newRef = (PsiJavaCodeReferenceElement) CodeStyleManager.getInstance(myProject).reformat(newRef); @@ -481,25 +481,22 @@ else if (element instanceof PsiJavaCodeReferenceElement) { } private static boolean isStatic(PsiElement member) { - if (member instanceof PsiModifierListOwner) { - final PsiModifierListOwner method = (PsiModifierListOwner)member; - return method.hasModifierProperty(PsiModifier.STATIC); + return member instanceof PsiModifierListOwner method && method.hasModifierProperty(PsiModifier.STATIC); } - return false; - } + @RequiredWriteAction private void upcastToDelegation(PsiElement element, FieldAccessibility fieldAccessibility) throws IncorrectOperationException { - final PsiExpression expression = (PsiExpression)element; + PsiExpression expression = (PsiExpression)element; - final PsiExpression newExpr; - final PsiReferenceExpression ref; - @NonNls final String delegateQualifier; + PsiExpression newExpr; + PsiReferenceExpression ref; + String delegateQualifier; if (!(expression instanceof PsiThisExpression || expression instanceof PsiSuperExpression)) { delegateQualifier = "a."; } else { PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(myProject).getResolveHelper(); - final PsiVariable psiVariable = resolveHelper.resolveReferencedVariable(myFieldName, element); + PsiVariable psiVariable = resolveHelper.resolveReferencedVariable(myFieldName, element); if (psiVariable == null) { delegateQualifier = ""; } @@ -524,6 +521,7 @@ private void upcastToDelegation(PsiElement element, FieldAccessibility fieldAcce // LOG.debug("upcastToDelegation:" + element + ":replaced = " + replaced); } + @RequiredWriteAction private void delegateMethods() throws IncorrectOperationException { for (PsiMethod method : myDelegatedMethods) { if (!myAbstractDelegatedMethods.contains(method)) { @@ -539,21 +537,22 @@ private void delegateMethods() throws IncorrectOperationException { } } + @RequiredWriteAction private PsiMethod delegateMethod( - @NonNls String delegationTarget, + String delegationTarget, PsiMethod method, PsiSubstitutor substitutor ) throws IncorrectOperationException { substitutor = OverrideImplementUtil.correctSubstitutor(method, substitutor); PsiMethod methodToAdd = GenerateMembersUtil.substituteGenericMethod(method, substitutor); - final PsiModifierList modifierList = methodToAdd.getModifierList(); - final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); + PsiModifierList modifierList = methodToAdd.getModifierList(); + NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); NullableNotNullManager.getInstance(myProject).copyNullableOrNotNullAnnotation(method, methodToAdd); - final String delegationBody = getDelegationBody(methodToAdd, delegationTarget); + String delegationBody = getDelegationBody(methodToAdd, delegationTarget); PsiCodeBlock newBody = myFactory.createCodeBlockFromText(delegationBody, method); PsiCodeBlock oldBody = methodToAdd.getBody(); @@ -573,7 +572,7 @@ private PsiMethod delegateMethod( } private static String getDelegationBody(PsiMethod methodToAdd, String delegationTarget) { - @NonNls final StringBuffer buffer = new StringBuffer(); + StringBuilder buffer = new StringBuilder(); buffer.append("{\n"); if (!PsiType.VOID.equals(methodToAdd.getReturnType())) { @@ -596,8 +595,9 @@ private static String getDelegationBody(PsiMethod methodToAdd, String delegation return buffer.toString(); } + @RequiredWriteAction private void addImplementingInterfaces() throws IncorrectOperationException { - final PsiReferenceList implementsList = myClass.getImplementsList(); + PsiReferenceList implementsList = myClass.getImplementsList(); LOG.assertTrue(implementsList != null); for (PsiClass delegatedInterface : myDelegatedInterfaces) { if (!myClassImplementedInterfaces.contains(delegatedInterface)) { @@ -606,14 +606,14 @@ private void addImplementingInterfaces() throws IncorrectOperationException { } if (!myBaseClass.isInterface()) { - final PsiReferenceList extendsList = myClass.getExtendsList(); + PsiReferenceList extendsList = myClass.getExtendsList(); LOG.assertTrue(extendsList != null); extendsList.getReferenceElements()[0].delete(); } else { - final PsiJavaCodeReferenceElement[] interfaceRefs = implementsList.getReferenceElements(); + PsiJavaCodeReferenceElement[] interfaceRefs = implementsList.getReferenceElements(); for (PsiJavaCodeReferenceElement interfaceRef : interfaceRefs) { - final PsiElement resolved = interfaceRef.resolve(); + PsiElement resolved = interfaceRef.resolve(); if (myManager.areElementsEquivalent(myBaseClass, resolved)) { interfaceRef.delete(); break; @@ -622,17 +622,18 @@ private void addImplementingInterfaces() throws IncorrectOperationException { } } + @RequiredWriteAction private void addField(UsageInfo[] usages) throws IncorrectOperationException { - final String fieldVisibility = getFieldVisibility(usages); + String fieldVisibility = getFieldVisibility(usages); - final boolean fieldInitializerNeeded = isFieldInitializerNeeded(); + boolean fieldInitializerNeeded = isFieldInitializerNeeded(); PsiField field = createField(fieldVisibility, fieldInitializerNeeded, defaultClassFieldType()); if (!myIsInnerClassNeeded) { field.getTypeElement().replace(myFactory.createTypeElement(myBaseClassType)); if (fieldInitializerNeeded) { - final PsiJavaCodeReferenceElement classReferenceElement = myFactory.createReferenceElementByType(myBaseClassType); + PsiJavaCodeReferenceElement classReferenceElement = myFactory.createReferenceElementByType(myBaseClassType); PsiNewExpression newExpression = (PsiNewExpression)field.getInitializer(); newExpression.getClassReference().replace(classReferenceElement); } @@ -645,8 +646,8 @@ private void addField(UsageInfo[] usages) throws IncorrectOperationException { } if (myGenerateGetter) { - final String getterVisibility = PsiModifier.PUBLIC; - @NonNls StringBuffer getterBuffer = new StringBuffer(); + String getterVisibility = PsiModifier.PUBLIC; + StringBuilder getterBuffer = new StringBuilder(); getterBuffer.append(getterVisibility); getterBuffer.append(" Object "); getterBuffer.append(myGetterName); @@ -667,7 +668,7 @@ private String getFieldVisibility(UsageInfo[] usages) { for (UsageInfo aUsage : usages) { InheritanceToDelegationUsageInfo usage = (InheritanceToDelegationUsageInfo)aUsage; - final FieldAccessibility delegateFieldAccessible = usage.getDelegateFieldAccessible(); + FieldAccessibility delegateFieldAccessible = usage.getDelegateFieldAccessible(); if (delegateFieldAccessible.isAccessible() && delegateFieldAccessible.getContainingClass() != myClass) { return PsiModifier.PROTECTED; } @@ -675,39 +676,36 @@ private String getFieldVisibility(UsageInfo[] usages) { return PsiModifier.PRIVATE; } - private - @NonNls - String defaultClassFieldType() { + private String defaultClassFieldType() { return (myIsInnerClassNeeded ? myInnerClassName : "Object"); } - private PsiField createField( - final String fieldVisibility, - final boolean fieldInitializerNeeded, - String defaultTypeName - ) throws IncorrectOperationException { - @NonNls StringBuffer buffer = new StringBuffer(); + @RequiredWriteAction + private PsiField createField(String fieldVisibility, boolean fieldInitializerNeeded, String defaultTypeName) + throws IncorrectOperationException { + StringBuilder buffer = new StringBuilder(); buffer.append(fieldVisibility); - buffer.append(" final " + defaultTypeName + " "); + buffer.append(" final ").append(defaultTypeName).append(" "); buffer.append(myFieldName); if (fieldInitializerNeeded) { - buffer.append(" = new " + defaultTypeName + "()"); + buffer.append(" = new ").append(defaultTypeName).append("()"); } buffer.append(";"); return myFactory.createFieldFromText(buffer.toString(), myClass); } + @RequiredWriteAction private void fixConstructors() throws IncorrectOperationException { if (myBaseClass.isInterface()) { return; } - final PsiJavaCodeReferenceElement baseClassReference = myFactory.createClassReferenceElement(myBaseClass); + PsiJavaCodeReferenceElement baseClassReference = myFactory.createClassReferenceElement(myBaseClass); PsiMethod[] constructors = myClass.getConstructors(); for (PsiMethod constructor : constructors) { PsiCodeBlock body = constructor.getBody(); - final PsiStatement[] statements = body.getStatements(); - @NonNls String fieldQualifier = ""; + PsiStatement[] statements = body.getStatements(); + String fieldQualifier = ""; PsiParameter[] constructorParams = constructor.getParameterList().getParameters(); for (PsiParameter constructorParam : constructorParams) { if (myFieldName.equals(constructorParam.getName())) { @@ -715,17 +713,17 @@ private void fixConstructors() throws IncorrectOperationException { break; } } - final @NonNls String assignmentText = fieldQualifier + myFieldName + "= new " + defaultClassFieldType() + "()"; + String assignmentText = fieldQualifier + myFieldName + "= new " + defaultClassFieldType() + "()"; if (statements.length < 1 || !JavaHighlightUtil.isSuperOrThisCall(statements[0], true, true) || myBaseClass.isInterface()) { PsiExpressionStatement assignmentStatement = (PsiExpressionStatement)myFactory.createStatementFromText( assignmentText, body ); if (!myIsInnerClassNeeded) { - final PsiAssignmentExpression assignmentExpr = (PsiAssignmentExpression)assignmentStatement.getExpression(); - final PsiNewExpression newExpression = (PsiNewExpression)assignmentExpr.getRExpression(); + PsiAssignmentExpression assignmentExpr = (PsiAssignmentExpression)assignmentStatement.getExpression(); + PsiNewExpression newExpression = (PsiNewExpression)assignmentExpr.getRExpression(); assert newExpression != null; - final PsiJavaCodeReferenceElement classRef = newExpression.getClassReference(); + PsiJavaCodeReferenceElement classRef = newExpression.getClassReference(); assert classRef != null; classRef.replace(baseClassReference); } @@ -744,16 +742,12 @@ private void fixConstructors() throws IncorrectOperationException { } } else { - final PsiExpressionStatement callStatement = ((PsiExpressionStatement)statements[0]); + PsiExpressionStatement callStatement = ((PsiExpressionStatement)statements[0]); if (!JavaHighlightUtil.isSuperOrThisCall(callStatement, false, true)) { - final PsiMethodCallExpression superConstructorCall = - (PsiMethodCallExpression)callStatement.getExpression(); + PsiMethodCallExpression superConstructorCall = (PsiMethodCallExpression)callStatement.getExpression(); PsiAssignmentExpression assignmentExpression = - (PsiAssignmentExpression)myFactory.createExpressionFromText( - assignmentText, superConstructorCall - ); - PsiNewExpression newExpression = - (PsiNewExpression)assignmentExpression.getRExpression(); + (PsiAssignmentExpression)myFactory.createExpressionFromText(assignmentText, superConstructorCall); + PsiNewExpression newExpression = (PsiNewExpression)assignmentExpression.getRExpression(); if (!myIsInnerClassNeeded) { newExpression.getClassReference().replace(baseClassReference); } @@ -771,7 +765,7 @@ private boolean isFieldInitializerNeeded() { } PsiMethod[] constructors = myClass.getConstructors(); for (PsiMethod constructor : constructors) { - final PsiStatement[] statements = constructor.getBody().getStatements(); + PsiStatement[] statements = constructor.getBody().getStatements(); if (statements.length > 0 && JavaHighlightUtil.isSuperOrThisCall(statements[0], true, false)) { return false; } @@ -779,20 +773,21 @@ private boolean isFieldInitializerNeeded() { return true; } + @RequiredReadAction private List getInnerClassMethods() { - ArrayList result = new ArrayList(); + ArrayList result = new ArrayList<>(); // find all neccessary constructors if (!myBaseClass.isInterface()) { PsiMethod[] constructors = myClass.getConstructors(); for (PsiMethod constructor : constructors) { - final PsiStatement[] statements = constructor.getBody().getStatements(); + PsiStatement[] statements = constructor.getBody().getStatements(); if (statements.length > 0 && JavaHighlightUtil.isSuperOrThisCall(statements[0], true, false)) { - final PsiMethodCallExpression superConstructorCall = + PsiMethodCallExpression superConstructorCall = (PsiMethodCallExpression)((PsiExpressionStatement)statements[0]).getExpression(); - PsiElement superConstructor = superConstructorCall.getMethodExpression().resolve(); - if (superConstructor instanceof PsiMethod && ((PsiMethod)superConstructor).isConstructor()) { - result.add(new InnerClassConstructor((PsiMethod)superConstructor)); + if (superConstructorCall.getMethodExpression().resolve() instanceof PsiMethod superConstructor + && superConstructor.isConstructor()) { + result.add(new InnerClassConstructor(superConstructor)); } } } @@ -805,11 +800,12 @@ public InnerClassOverridingMethod(PsiMethod method) { super(method); } + @Override public void createMethod(PsiClass innerClass) throws IncorrectOperationException { OverriddenMethodClassMemberReferencesVisitor visitor = new OverriddenMethodClassMemberReferencesVisitor(); myClass.accept(visitor); - final List actions = visitor.getPsiActions(); + List actions = visitor.getPsiActions(); for (PsiAction action : actions) { action.run(); } @@ -829,28 +825,30 @@ public void createMethod(PsiClass innerClass) class InnerClassAbstractMethod extends InnerClassMethod { private final boolean myImplicitImplementation; - public InnerClassAbstractMethod(PsiMethod method, final boolean implicitImplementation) { + public InnerClassAbstractMethod(PsiMethod method, boolean implicitImplementation) { super(method); myImplicitImplementation = implicitImplementation; } + @Override + @RequiredWriteAction public void createMethod(PsiClass innerClass) throws IncorrectOperationException { PsiSubstitutor substitutor = getSuperSubstitutor(myMethod.getContainingClass()); PsiMethod method = delegateMethod(myClass.getName() + ".this", myMethod, substitutor); - final PsiClass containingClass = myMethod.getContainingClass(); + PsiClass containingClass = myMethod.getContainingClass(); if (myBaseClass.isInterface() || containingClass.isInterface()) { PsiUtil.setModifierProperty(method, PsiModifier.PUBLIC, true); } innerClass.add(method); if (!myImplicitImplementation) { - final MethodSignature signature = myMethod.getSignature(substitutor); + MethodSignature signature = myMethod.getSignature(substitutor); PsiMethod outerMethod = MethodSignatureUtil.findMethodBySignature(myClass, signature, false); if (outerMethod == null) { String visibility = checkOuterClassAbstractMethod(signature); PsiMethod newOuterMethod = (PsiMethod)myClass.add(myMethod); PsiUtil.setModifierProperty(newOuterMethod, visibility, true); - final PsiDocComment docComment = newOuterMethod.getDocComment(); + PsiDocComment docComment = newOuterMethod.getDocComment(); if (docComment != null) { docComment.delete(); } @@ -861,10 +859,10 @@ public void createMethod(PsiClass innerClass) PsiMethod[] methods = myBaseClass.getAllMethods(); for (PsiMethod method : methods) { - if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { - final MethodSignature signature = method.getSignature(getSuperSubstitutor(method.getContainingClass())); + if (method.isAbstract()) { + MethodSignature signature = method.getSignature(getSuperSubstitutor(method.getContainingClass())); PsiMethod classMethod = MethodSignatureUtil.findMethodBySignature(myClass, signature, true); - if (classMethod == null || classMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + if (classMethod == null || classMethod.isAbstract()) { result.add(new InnerClassAbstractMethod(method, false)); } else if ((myBaseClass.isInterface() && classMethod.getContainingClass() != myClass)) { // IDEADEV-19675 @@ -878,13 +876,14 @@ else if ((myBaseClass.isInterface() && classMethod.getContainingClass() != myCla return result; } - private void showObjectUpcastedUsageView(final ObjectUpcastedUsageInfo[] usages) { + @RequiredReadAction + private void showObjectUpcastedUsageView(ObjectUpcastedUsageInfo[] usages) { UsageViewPresentation presentation = new UsageViewPresentation(); - presentation.setTargetsNodeText(RefactoringLocalize.replacingInheritanceWithDelegation().get()); - presentation.setCodeUsagesString(RefactoringLocalize.instancesCastedToJavaLangObject().get()); - final LocalizeValue upcastedString = RefactoringLocalize.instancesUpcastedToObject(); - presentation.setUsagesString(upcastedString.get()); - presentation.setTabText(upcastedString.get()); + presentation.setTargetsNodeText(RefactoringLocalize.replacingInheritanceWithDelegation()); + presentation.setCodeUsagesString(RefactoringLocalize.instancesCastedToJavaLangObject()); + LocalizeValue upcastedString = RefactoringLocalize.instancesUpcastedToObject(); + presentation.setUsagesString(upcastedString); + presentation.setTabText(upcastedString); UsageViewManager manager = UsageViewManager.getInstance(myProject); manager.showUsages( @@ -918,7 +917,7 @@ private String checkOuterClassAbstractMethod(MethodSignature methodSignature) { } private Set getOverriddenMethods() { - LinkedHashSet result = new LinkedHashSet(); + LinkedHashSet result = new LinkedHashSet<>(); PsiMethod[] methods = myClass.getMethods(); for (PsiMethod method : methods) { @@ -931,7 +930,7 @@ private Set getOverriddenMethods() { @Nullable private PsiMethod findSuperMethodInBaseClass(PsiMethod method) { - final PsiMethod[] superMethods = method.findSuperMethods(); + PsiMethod[] superMethods = method.findSuperMethods(); for (PsiMethod superMethod : superMethods) { PsiClass containingClass = superMethod.getContainingClass(); if (InheritanceUtil.isInheritorOrSelf(myBaseClass, containingClass, true)) { @@ -944,13 +943,15 @@ private PsiMethod findSuperMethodInBaseClass(PsiMethod method) { return null; } - + @Nonnull + @Override + @RequiredReadAction protected String getCommandName() { return RefactoringLocalize.replaceInheritanceWithDelegationCommand(DescriptiveNameUtil.getDescriptiveName(myClass)).get(); } private Set getAllBaseClassMembers() { - HashSet result = new HashSet(); + Set result = new HashSet<>(); addAll(result, myBaseClass.getAllFields()); addAll(result, myBaseClass.getAllInnerClasses()); addAll(result, myBaseClass.getAllMethods()); @@ -966,23 +967,20 @@ private Set getAllBaseClassMembers() { } private Set getAllBases() { - HashSet temp = new HashSet(); + Set temp = new HashSet<>(); InheritanceUtil.getSuperClasses(myBaseClass, temp, true); temp.add(myBaseClass); return Collections.unmodifiableSet(temp); } private static void addAll(Collection collection, T[] objs) { - for (T obj : objs) { - collection.add(obj); + Collections.addAll(collection, objs); } - } private boolean isDelegated(PsiMember classMember) { - if (!(classMember instanceof PsiMethod)) { + if (!(classMember instanceof PsiMethod method)) { return false; } - final PsiMethod method = (PsiMethod)classMember; for (PsiMethod delegatedMethod : myDelegatedMethods) { //methods reside in base class, so no substitutor needed if (MethodSignatureUtil.areSignaturesEqual( @@ -1010,14 +1008,16 @@ private class MyClassInheritorMemberReferencesVisitor extends ClassMemberReferen myInstanceVisitor = instanceScanner; } + @Override + @RequiredReadAction protected void visitClassMemberReferenceElement(PsiMember classMember, PsiJavaCodeReferenceElement classMemberReference) { if ("super".equals(classMemberReference.getText()) && classMemberReference.getParent() instanceof PsiMethodCallExpression) { return; } if (classMember != null && myBaseClassMembers.contains(classMember) && !isDelegated(classMember)) { - final FieldAccessibility delegateFieldVisibility = new FieldAccessibility(true, getPsiClass()); - final InheritanceToDelegationUsageInfo usageInfo; + FieldAccessibility delegateFieldVisibility = new FieldAccessibility(true, getPsiClass()); + InheritanceToDelegationUsageInfo usageInfo; if (classMemberReference instanceof PsiReferenceExpression referenceExpression) { if (referenceExpression.getQualifierExpression() == null) { usageInfo = new UnqualifiedNonDelegatedMemberUsageInfo(classMemberReference, classMember, delegateFieldVisibility); @@ -1038,7 +1038,7 @@ protected void visitClassMemberReferenceElement(PsiMember classMember, PsiJavaCo } @Override - public void visitThisExpression(PsiThisExpression expression) { + public void visitThisExpression(@Nonnull PsiThisExpression expression) { ClassInstanceScanner.processNonArrayExpression(myInstanceVisitor, expression, null); } } @@ -1052,7 +1052,7 @@ private class MyClassMemberReferencesVisitor extends MyClassInheritorMemberRefer } @Override - public void visitMethod(PsiMethod method) { + public void visitMethod(@Nonnull PsiMethod method) { if (!myOverriddenMethods.contains(method)) { super.visitMethod(method); } @@ -1072,8 +1072,8 @@ private class OverriddenMethodClassMemberReferencesVisitor extends ClassMemberRe OverriddenMethodClassMemberReferencesVisitor() throws IncorrectOperationException { super(myClass); - myPsiActions = new ArrayList(); - final PsiJavaCodeReferenceElement classReferenceElement = myFactory.createClassReferenceElement(myClass); + myPsiActions = new ArrayList<>(); + PsiJavaCodeReferenceElement classReferenceElement = myFactory.createClassReferenceElement(myClass); myQualifiedThis = (PsiThisExpression)myFactory.createExpressionFromText("A.this", null); myQualifiedThis.getQualifier().replace(classReferenceElement); } @@ -1089,6 +1089,7 @@ class QualifyThis implements PsiAction { myThisExpression = thisExpression; } + @Override public void run() throws IncorrectOperationException { myThisExpression.replace(myQualifiedThis); } @@ -1103,6 +1104,7 @@ class QualifyName implements PsiAction { myReferencedName = name; } + @Override public void run() throws IncorrectOperationException { PsiReferenceExpression newRef = (PsiReferenceExpression)myFactory.createExpressionFromText("a." + myReferencedName, null); @@ -1115,11 +1117,13 @@ class QualifyWithField implements PsiAction { private final PsiReferenceExpression myReference; private final String myReferencedName; - public QualifyWithField(final PsiReferenceExpression reference, final String name) { + public QualifyWithField(PsiReferenceExpression reference, String name) { myReference = reference; myReferencedName = name; } + @Override + @RequiredWriteAction public void run() throws IncorrectOperationException { PsiReferenceExpression newRef = (PsiReferenceExpression)myFactory.createExpressionFromText(myFieldName + "." + myReferencedName, null); @@ -1127,32 +1131,28 @@ public void run() throws IncorrectOperationException { } } + @Override protected void visitClassMemberReferenceExpression(PsiMember classMember, PsiReferenceExpression classMemberReference) { - if (classMember instanceof PsiField) { - final PsiField field = (PsiField)classMember; - + if (classMember instanceof PsiField field) { if (field.getContainingClass().equals(myClass)) { - final String name = field.getName(); - final PsiField baseField = myBaseClass.findFieldByName(name, true); + String name = field.getName(); + PsiField baseField = myBaseClass.findFieldByName(name, true); if (baseField != null) { myPsiActions.add(new QualifyName(classMemberReference, name)); } - else if (classMemberReference.getQualifierExpression() instanceof PsiThisExpression) { - myPsiActions.add(new QualifyThis((PsiThisExpression)classMemberReference.getQualifierExpression())); + else if (classMemberReference.getQualifierExpression() instanceof PsiThisExpression thisExpr) { + myPsiActions.add(new QualifyThis(thisExpr)); } } } - else if (classMember instanceof PsiMethod) { - final PsiMethod method = (PsiMethod)classMember; - - if (method.getContainingClass().equals(myClass)) { + else if (classMember instanceof PsiMethod method && method.getContainingClass().equals(myClass)) { if (!myOverriddenMethods.contains(method)) { - final PsiMethod baseMethod = findSuperMethodInBaseClass(method); + PsiMethod baseMethod = findSuperMethodInBaseClass(method); if (baseMethod != null) { myPsiActions.add(new QualifyName(classMemberReference, baseMethod.getName())); } - else if (classMemberReference.getQualifierExpression() instanceof PsiThisExpression) { - myPsiActions.add(new QualifyThis((PsiThisExpression)classMemberReference.getQualifierExpression())); + else if (classMemberReference.getQualifierExpression() instanceof PsiThisExpression thisExpr) { + myPsiActions.add(new QualifyThis(thisExpr)); } } else if (!myDelegatedMethods.contains(method)) { @@ -1160,15 +1160,16 @@ else if (!myDelegatedMethods.contains(method)) { } } } - } @Override - public void visitThisExpression(final PsiThisExpression expression) { + public void visitThisExpression(@Nonnull final PsiThisExpression expression) { class Visitor implements ClassInstanceScanner.ClassInstanceReferenceVisitor { + @Override public void visitQualifier(PsiReferenceExpression qualified, PsiExpression instanceRef, PsiElement referencedInstance) { LOG.assertTrue(false); } + @Override public void visitTypeCast( PsiTypeCastExpression typeCastExpression, PsiExpression instanceRef, @@ -1177,16 +1178,18 @@ public void visitTypeCast( processType(typeCastExpression.getCastType().getType()); } + @Override public void visitReadUsage(PsiExpression instanceRef, PsiType expectedType, PsiElement referencedInstance) { processType(expectedType); } + @Override public void visitWriteUsage(PsiExpression instanceRef, PsiType assignedType, PsiElement referencedInstance) { LOG.assertTrue(false); } private void processType(PsiType type) { - final PsiClass resolved = PsiUtil.resolveClassInType(type); + PsiClass resolved = PsiUtil.resolveClassInType(type); if (resolved != null && !myBaseClassBases.contains(resolved)) { myPsiActions.add(new QualifyThis(expression)); } @@ -1196,6 +1199,7 @@ private void processType(PsiType type) { ClassInstanceScanner.processNonArrayExpression(visitor, expression, null); } + @Override protected void visitClassMemberReferenceElement(PsiMember classMember, PsiJavaCodeReferenceElement classMemberReference) { } } @@ -1213,9 +1217,9 @@ public MyClassInstanceReferenceVisitor(PsiClass aClass, List usageInf public Set getImplementedInterfaces() { PsiClass aClass = myClass; - HashSet result = new HashSet(); + HashSet result = new HashSet<>(); while (aClass != null && !myManager.areElementsEquivalent(aClass, myBaseClass)) { - final PsiClassType[] implementsTypes = aClass.getImplementsListTypes(); + PsiClassType[] implementsTypes = aClass.getImplementsListTypes(); for (PsiClassType implementsType : implementsTypes) { PsiClass resolved = implementsType.resolve(); if (resolved != null && !myManager.areElementsEquivalent(resolved, myBaseClass)) { @@ -1229,9 +1233,10 @@ public Set getImplementedInterfaces() { return result; } - + @Override + @RequiredReadAction public void visitQualifier(PsiReferenceExpression qualified, PsiExpression instanceRef, PsiElement referencedInstance) { - final PsiExpression qualifierExpression = qualified.getQualifierExpression(); + PsiExpression qualifierExpression = qualified.getQualifierExpression(); // do not add usages inside a class if (qualifierExpression == null @@ -1247,20 +1252,22 @@ public void visitQualifier(PsiReferenceExpression qualified, PsiExpression insta } } + @Override public void visitTypeCast(PsiTypeCastExpression typeCastExpression, PsiExpression instanceRef, PsiElement referencedInstance) { processTypedUsage(typeCastExpression.getCastType().getType(), instanceRef); } - + @Override public void visitReadUsage(PsiExpression instanceRef, PsiType expectedType, PsiElement referencedInstance) { processTypedUsage(expectedType, instanceRef); } + @Override public void visitWriteUsage(PsiExpression instanceRef, PsiType assignedType, PsiElement referencedInstance) { } private void processTypedUsage(PsiType type, PsiExpression instanceRef) { - final PsiClass aClass = PsiUtil.resolveClassInType(type); + PsiClass aClass = PsiUtil.resolveClassInType(type); if (aClass == null) { return; } 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 1e5e732f67..e340b72f47 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 @@ -105,6 +105,7 @@ protected boolean isPreviewUsages(@Nonnull UsageInfo[] usages) { } private static class UsageFromJavaDoc extends UsageInfo { + @RequiredReadAction private UsageFromJavaDoc(@Nonnull PsiElement element) { super(element, true); } 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 e9e49013ae..afa8afa147 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 @@ -33,6 +33,8 @@ import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.PsiTypesUtil; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.codeEditor.Editor; import consulo.codeEditor.LogicalPosition; import consulo.language.Language; @@ -69,7 +71,6 @@ import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.*; @@ -94,6 +95,7 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { private PsiMethod myMethodCopy; private Map myInliners; + @RequiredReadAction public InlineMethodProcessor( @Nonnull Project project, @Nonnull PsiMethod method, @@ -104,6 +106,7 @@ public InlineMethodProcessor( this(project, method, reference, editor, isInlineThisOnly, false, false); } + @RequiredReadAction public InlineMethodProcessor( @Nonnull Project project, @Nonnull PsiMethod method, @@ -128,21 +131,26 @@ public InlineMethodProcessor( myDescriptiveName = DescriptiveNameUtil.getDescriptiveName(myMethod); } + @Nonnull + @Override protected String getCommandName() { return RefactoringLocalize.inlineMethodCommand(myDescriptiveName).get(); } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new InlineViewDescriptor(myMethod); } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { if (myInlineThisOnly) { return new UsageInfo[]{new UsageInfo(myReference)}; } - Set usages = new HashSet(); + Set usages = new HashSet<>(); if (myReference != null) { usages.add(new UsageInfo(myReference)); } @@ -151,7 +159,7 @@ protected UsageInfo[] findUsages() { } if (mySearchInComments || mySearchForTextOccurrences) { - final NonCodeUsageInfoFactory infoFactory = new NonCodeUsageInfoFactory(myMethod, myMethod.getName()) { + NonCodeUsageInfoFactory infoFactory = new NonCodeUsageInfoFactory(myMethod, myMethod.getName()) { @Override public UsageInfo createUsageInfo(@Nonnull PsiElement usage, int startOffset, int endOffset) { if (PsiTreeUtil.isAncestor(myMethod, usage, false)) { @@ -186,6 +194,7 @@ protected boolean isPreviewUsages(UsageInfo[] usages) { return super.isPreviewUsages(usages); } + @Override protected void refreshElements(PsiElement[] elements) { boolean condition = elements.length == 1 && elements[0] instanceof PsiMethod; LOG.assertTrue(condition); @@ -200,20 +209,20 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag return false; } } - final UsageInfo[] usagesIn = refUsages.get(); - final MultiMap conflicts = new MultiMap(); + UsageInfo[] usagesIn = refUsages.get(); + MultiMap conflicts = new MultiMap<>(); if (!myInlineThisOnly) { - final PsiMethod[] superMethods = myMethod.findSuperMethods(); + PsiMethod[] superMethods = myMethod.findSuperMethods(); for (PsiMethod method : superMethods) { - final LocalizeValue message = method.hasModifierProperty(PsiModifier.ABSTRACT) + LocalizeValue message = method.isAbstract() ? RefactoringLocalize.inlinedMethodImplementsMethodFrom0(method.getContainingClass().getQualifiedName()) : RefactoringLocalize.inlinedMethodOverridesMethodFrom0(method.getContainingClass().getQualifiedName()); conflicts.putValue(method, message.get()); } for (UsageInfo info : usagesIn) { - final PsiElement element = info.getElement(); + PsiElement element = info.getElement(); if (element instanceof PsiDocMethodOrFieldRef && !PsiTreeUtil.isAncestor(myMethod, element, false)) { conflicts.putValue(element, "Inlined method is used in javadoc"); } @@ -221,7 +230,7 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag conflicts.putValue(element, "Inlined method is used in method reference"); } - final String errorMessage = checkCalledInSuperOrThisExpr(myMethod.getBody(), element); + String errorMessage = checkCalledInSuperOrThisExpr(myMethod.getBody(), element); if (errorMessage != null) { conflicts.putValue(element, errorMessage); } @@ -235,11 +244,12 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag myInliners.put(JavaLanguage.INSTANCE, new InlineHandler.Inliner() { @Nullable @Override - public MultiMap getConflicts(PsiReference reference, PsiElement referenced) { + public MultiMap getConflicts(@Nonnull PsiReference reference, @Nonnull PsiElement referenced) { return MultiMap.empty(); } @Override + @RequiredReadAction public void inlineUsage(@Nonnull UsageInfo usage, @Nonnull PsiElement referenced) { if (usage instanceof NonCodeUsageInfo) { return; @@ -247,7 +257,8 @@ public void inlineUsage(@Nonnull UsageInfo usage, @Nonnull PsiElement referenced throw new UnsupportedOperationException( "usage: " + usage.getClass().getName() + ", referenced: " + referenced.getClass() - .getName() + "text: " + referenced.getText()); + .getName() + "text: " + referenced.getText() + ); } }); @@ -255,7 +266,7 @@ public void inlineUsage(@Nonnull UsageInfo usage, @Nonnull PsiElement referenced GenericInlineHandler.collectConflicts(ref, myMethod, myInliners, conflicts); } - final PsiReturnStatement[] returnStatements = RefactoringUtil.findReturnStatements(myMethod); + PsiReturnStatement[] returnStatements = RefactoringUtil.findReturnStatements(myMethod); for (PsiReturnStatement statement : returnStatements) { PsiExpression value = statement.getReturnValue(); if (value != null && !(value instanceof PsiCallExpression)) { @@ -279,10 +290,11 @@ public void inlineUsage(@Nonnull UsageInfo usage, @Nonnull PsiElement referenced return showConflicts(conflicts, usagesIn); } + @RequiredReadAction private static ArrayList convertUsagesToRefs(UsageInfo[] usagesIn) { - ArrayList refs = new ArrayList(); + ArrayList refs = new ArrayList<>(); for (UsageInfo info : usagesIn) { - final PsiReference ref = info.getReference(); + PsiReference ref = info.getReference(); if (ref != null) { //ref can be null if it is conflict usage info refs.add(ref); } @@ -298,35 +310,33 @@ private void addInaccessibleSuperCallsConflicts(final UsageInfo[] usagesIn, fina myMethod.accept(new JavaRecursiveElementWalkingVisitor() { @Override - public void visitClass(PsiClass aClass) { + public void visitClass(@Nonnull PsiClass aClass) { } @Override - public void visitAnonymousClass(PsiAnonymousClass aClass) { + public void visitAnonymousClass(@Nonnull PsiAnonymousClass aClass) { } @Override - public void visitSuperExpression(PsiSuperExpression expression) { + @RequiredReadAction + public void visitSuperExpression(@Nonnull PsiSuperExpression expression) { super.visitSuperExpression(expression); - final PsiType type = expression.getType(); - final PsiClass superClass = PsiUtil.resolveClassInType(type); + PsiType type = expression.getType(); + PsiClass superClass = PsiUtil.resolveClassInType(type); if (superClass != null) { - final Set targetContainingClasses = new HashSet(); + Set targetContainingClasses = new HashSet<>(); for (UsageInfo info : usagesIn) { - final PsiElement element = info.getElement(); + PsiElement element = info.getElement(); if (element != null) { - final PsiClass targetContainingClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); - if (targetContainingClass != null && !InheritanceUtil.isInheritorOrSelf( - targetContainingClass, - superClass, - true - )) { + PsiClass targetContainingClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); + if (targetContainingClass != null + && !InheritanceUtil.isInheritorOrSelf(targetContainingClass, superClass, true)) { targetContainingClasses.add(targetContainingClass); } } } if (!targetContainingClasses.isEmpty()) { - final PsiMethodCallExpression methodCallExpression = + PsiMethodCallExpression methodCallExpression = PsiTreeUtil.getParentOfType(expression, PsiMethodCallExpression.class); LOG.assertTrue(methodCallExpression != null); conflicts.putValue( @@ -340,21 +350,22 @@ public void visitSuperExpression(PsiSuperExpression expression) { }); } + @RequiredReadAction public static void addInaccessibleMemberConflicts( - final PsiElement element, - final UsageInfo[] usages, - final ReferencedElementsCollector collector, - final MultiMap conflicts + PsiElement element, + UsageInfo[] usages, + ReferencedElementsCollector collector, + MultiMap conflicts ) { element.accept(collector); - final Map> containersToReferenced = getInaccessible(collector.myReferencedMembers, usages, element); + Map> containersToReferenced = getInaccessible(collector.myReferencedMembers, usages, element); - final Set containers = containersToReferenced.keySet(); + Set containers = containersToReferenced.keySet(); for (PsiMember container : containers) { Set referencedInaccessible = containersToReferenced.get(container); for (PsiMember referenced : referencedInaccessible) { - final String referencedDescription = RefactoringUIUtil.getDescription(referenced, true); - final String containerDescription = RefactoringUIUtil.getDescription(container, true); + String referencedDescription = RefactoringUIUtil.getDescription(referenced, true); + String containerDescription = RefactoringUIUtil.getDescription(container, true); LocalizeValue message = RefactoringLocalize.zeroThatIsUsedInInlinedMethodIsNotAccessibleFromCallSiteSIn1( referencedDescription, containerDescription @@ -372,26 +383,27 @@ public static void addInaccessibleMemberConflicts( * @param usages * @param elementToInline */ + @RequiredReadAction private static Map> getInaccessible( HashSet referencedElements, UsageInfo[] usages, PsiElement elementToInline ) { - Map> result = new HashMap>(); + Map> result = new HashMap<>(); for (UsageInfo usage : usages) { - final PsiElement usageElement = usage.getElement(); + PsiElement usageElement = usage.getElement(); if (usageElement == null) { continue; } - final PsiElement container = ConflictsUtil.getContainer(usageElement); + PsiElement container = ConflictsUtil.getContainer(usageElement); if (!(container instanceof PsiMember)) { continue; // usage in import statement } PsiMember memberContainer = (PsiMember)container; Set inaccessibleReferenced = result.get(memberContainer); if (inaccessibleReferenced == null) { - inaccessibleReferenced = new HashSet(); + inaccessibleReferenced = new HashSet<>(); result.put(memberContainer, inaccessibleReferenced); for (PsiMember member : referencedElements) { if (PsiTreeUtil.isAncestor(elementToInline, member, false)) { @@ -407,7 +419,9 @@ private static Map> getInaccessible( return result; } - protected void performRefactoring(UsageInfo[] usages) { + @Override + @RequiredWriteAction + protected void performRefactoring(@Nonnull UsageInfo[] usages) { int col = -1; int line = -1; if (myEditor != null) { @@ -431,6 +445,7 @@ protected void performRefactoring(UsageInfo[] usages) { } } + @RequiredWriteAction private void doRefactoring(UsageInfo[] usages) { try { if (myInlineThisOnly) { @@ -450,14 +465,14 @@ private void doRefactoring(UsageInfo[] usages) { if (myMethod.isConstructor()) { for (UsageInfo usage : usages) { PsiElement element = usage.getElement(); - if (element instanceof PsiJavaCodeReferenceElement) { - PsiCall constructorCall = RefactoringUtil.getEnclosingConstructorCall((PsiJavaCodeReferenceElement)element); + if (element instanceof PsiJavaCodeReferenceElement codeRefElem) { + PsiCall constructorCall = RefactoringUtil.getEnclosingConstructorCall(codeRefElem); if (constructorCall != null) { inlineConstructorCall(constructorCall); } } - else if (element instanceof PsiEnumConstant) { - inlineConstructorCall((PsiEnumConstant)element); + else if (element instanceof PsiEnumConstant enumConst) { + inlineConstructorCall(enumConst); } else { GenericInlineHandler.inlineReference(usage, myMethod, myInliners); @@ -466,12 +481,12 @@ else if (element instanceof PsiEnumConstant) { myMethod.delete(); } else { - List refExprList = new ArrayList(); - final List imports2Delete = new ArrayList(); - for (final UsageInfo usage : usages) { - final PsiElement element = usage.getElement(); - if (element instanceof PsiReferenceExpression) { - refExprList.add((PsiReferenceExpression)element); + List refExprList = new ArrayList<>(); + List imports2Delete = new ArrayList<>(); + for (UsageInfo usage : usages) { + PsiElement element = usage.getElement(); + if (element instanceof PsiReferenceExpression refExpr) { + refExprList.add(refExpr); } else if (element instanceof PsiImportStaticReferenceElement) { imports2Delete.add(PsiTreeUtil.getParentOfType(element, PsiImportStaticStatement.class)); @@ -505,17 +520,18 @@ else if (JavaLanguage.INSTANCE != element.getLanguage()) { } } + @RequiredWriteAction public static void inlineConstructorCall(PsiCall constructorCall) { - final PsiMethod oldConstructor = constructorCall.resolveMethod(); + PsiMethod oldConstructor = constructorCall.resolveMethod(); LOG.assertTrue(oldConstructor != null); PsiExpression[] instanceCreationArguments = constructorCall.getArgumentList().getExpressions(); if (oldConstructor.isVarArgs()) { //wrap with explicit array - final PsiParameter[] parameters = oldConstructor.getParameterList().getParameters(); - final PsiType varargType = parameters[parameters.length - 1].getType(); - if (varargType instanceof PsiEllipsisType) { - final PsiType arrayType = - constructorCall.resolveMethodGenerics().getSubstitutor().substitute(((PsiEllipsisType)varargType).getComponentType()); - final PsiExpression[] exprs = new PsiExpression[parameters.length]; + PsiParameter[] parameters = oldConstructor.getParameterList().getParameters(); + PsiType varargType = parameters[parameters.length - 1].getType(); + if (varargType instanceof PsiEllipsisType ellipsisType) { + PsiType arrayType = + constructorCall.resolveMethodGenerics().getSubstitutor().substitute(ellipsisType.getComponentType()); + PsiExpression[] exprs = new PsiExpression[parameters.length]; System.arraycopy(instanceCreationArguments, 0, exprs, 0, parameters.length - 1); StringBuilder varargs = new StringBuilder(); for (int i = parameters.length - 1; i < instanceCreationArguments.length; i++) { @@ -533,19 +549,19 @@ public static void inlineConstructorCall(PsiCall constructorCall) { } PsiStatement[] statements = oldConstructor.getBody().getStatements(); - LOG.assertTrue(statements.length == 1 && statements[0] instanceof PsiExpressionStatement); + LOG.assertTrue(statements.length == 1 && statements[0] instanceof PsiExpressionStatement exprStmt); PsiExpression expression = ((PsiExpressionStatement)statements[0]).getExpression(); LOG.assertTrue(expression instanceof PsiMethodCallExpression); ChangeContextUtil.encodeContextInfo(expression, true); PsiMethodCallExpression methodCall = (PsiMethodCallExpression)expression.copy(); - final PsiExpression[] args = methodCall.getArgumentList().getExpressions(); + PsiExpression[] args = methodCall.getArgumentList().getExpressions(); for (PsiExpression arg : args) { replaceParameterReferences(arg, oldConstructor, instanceCreationArguments); } try { - final PsiExpressionList exprList = (PsiExpressionList)constructorCall.getArgumentList().replace(methodCall.getArgumentList()); + PsiExpressionList exprList = (PsiExpressionList)constructorCall.getArgumentList().replace(methodCall.getArgumentList()); ChangeContextUtil.decodeContextInfo(exprList, PsiTreeUtil.getParentOfType(constructorCall, PsiClass.class), null); } catch (IncorrectOperationException e) { @@ -554,28 +570,26 @@ public static void inlineConstructorCall(PsiCall constructorCall) { ChangeContextUtil.clearContextInfo(expression); } + @RequiredWriteAction private static void replaceParameterReferences( - final PsiElement element, - final PsiMethod oldConstructor, - final PsiExpression[] instanceCreationArguments + PsiElement element, + PsiMethod oldConstructor, + PsiExpression[] instanceCreationArguments ) { boolean isParameterReference = false; - if (element instanceof PsiReferenceExpression) { - final PsiReferenceExpression expression = (PsiReferenceExpression)element; - PsiElement resolved = expression.resolve(); - if (resolved instanceof PsiParameter && - element.getManager().areElementsEquivalent(((PsiParameter)resolved).getDeclarationScope(), oldConstructor)) { - isParameterReference = true; - PsiElement declarationScope = ((PsiParameter)resolved).getDeclarationScope(); - PsiParameter[] declarationParameters = ((PsiMethod)declarationScope).getParameterList().getParameters(); - for (int j = 0; j < declarationParameters.length; j++) { - if (declarationParameters[j] == resolved) { - try { - expression.replace(instanceCreationArguments[j]); - } - catch (IncorrectOperationException e) { - LOG.error(e); - } + if (element instanceof PsiReferenceExpression expression + && expression.resolve() instanceof PsiParameter parameter + && element.getManager().areElementsEquivalent(parameter.getDeclarationScope(), oldConstructor)) { + isParameterReference = true; + PsiElement declarationScope = parameter.getDeclarationScope(); + PsiParameter[] declarationParameters = ((PsiMethod)declarationScope).getParameterList().getParameters(); + for (int j = 0; j < declarationParameters.length; j++) { + if (declarationParameters[j] == parameter) { + try { + expression.replace(instanceCreationArguments[j]); + } + catch (IncorrectOperationException e) { + LOG.error(e); } } } @@ -590,6 +604,7 @@ private static void replaceParameterReferences( } } + @RequiredWriteAction public void inlineMethodCall(PsiReferenceExpression ref) throws IncorrectOperationException { InlineUtil.TailCallType tailCall = InlineUtil.getTailCallType(ref); ChangeContextUtil.encodeContextInfo(myMethod, false); @@ -624,20 +639,20 @@ public void inlineMethodCall(PsiReferenceExpression ref) throws IncorrectOperati PsiStatement[] statements = blockData.block.getStatements(); if (statements.length > 0) { int last = statements.length - 1; - /*PsiElement first = statements[0]; - PsiElement last = statements[statements.length - 1];*/ + /*PsiElement first = statements[0]; + PsiElement last = statements[statements.length - 1];*/ - if (statements.length > 0 && statements[statements.length - 1] instanceof PsiReturnStatement && - tailCall != InlineUtil.TailCallType.Return) { + if (statements.length > 0 && statements[statements.length - 1] instanceof PsiReturnStatement + && tailCall != InlineUtil.TailCallType.Return) { last--; } int first = 0; if (first <= last) { - final PsiElement rBraceOrReturnStatement = + PsiElement rBraceOrReturnStatement = PsiTreeUtil.skipSiblingsForward(statements[last], PsiWhiteSpace.class, PsiComment.class); LOG.assertTrue(rBraceOrReturnStatement != null); - final PsiElement beforeRBraceStatement = rBraceOrReturnStatement.getPrevSibling(); + PsiElement beforeRBraceStatement = rBraceOrReturnStatement.getPrevSibling(); LOG.assertTrue(beforeRBraceStatement != null); PsiElement firstAdded = anchorParent.addRangeBefore(statements[first], beforeRBraceStatement, anchor); @@ -659,11 +674,12 @@ public void inlineMethodCall(PsiReferenceExpression ref) throws IncorrectOperati } } if (statements.length > 0) { - final PsiStatement lastStatement = statements[statements.length - 1]; - if (lastStatement instanceof PsiReturnStatement && tailCall != InlineUtil.TailCallType.Return) { - final PsiExpression returnValue = ((PsiReturnStatement)lastStatement).getReturnValue(); + if (statements[statements.length - 1] instanceof PsiReturnStatement returnStmt + && tailCall != InlineUtil.TailCallType.Return) { + PsiExpression returnValue = returnStmt.getReturnValue(); if (returnValue != null && PsiUtil.isStatement(returnValue)) { - PsiExpressionStatement exprStatement = (PsiExpressionStatement)myFactory.createStatementFromText("a;", null); + PsiExpressionStatement exprStatement = + (PsiExpressionStatement)myFactory.createStatementFromText("a;", null); exprStatement.getExpression().replace(returnValue); anchorParent.addBefore(exprStatement, anchor); } @@ -671,7 +687,6 @@ public void inlineMethodCall(PsiReferenceExpression ref) throws IncorrectOperati } } - PsiClass thisClass = myMethod.getContainingClass(); PsiExpression thisAccessExpr; if (thisVar != null) { @@ -706,10 +721,10 @@ else if (methodCall.getParent() instanceof PsiExpressionStatement || tailCall == if (thisVar != null) { inlineParmOrThisVariable(thisVar, false); } - final PsiParameter[] parameters = myMethod.getParameterList().getParameters(); + PsiParameter[] parameters = myMethod.getParameterList().getParameters(); for (int i = 0; i < parmVars.length; i++) { - final PsiParameter parameter = parameters[i]; - final boolean strictlyFinal = parameter.hasModifierProperty(PsiModifier.FINAL) && isStrictlyFinal(parameter); + PsiParameter parameter = parameters[i]; + boolean strictlyFinal = parameter.hasModifierProperty(PsiModifier.FINAL) && isStrictlyFinal(parameter); inlineParmOrThisVariable(parmVars[i], strictlyFinal); } if (resultVar != null) { @@ -727,8 +742,8 @@ private PsiSubstitutor getCallSubstitutor(PsiMethodCallExpression methodCall) { Iterator newTypeParameters = PsiUtil.typeParametersIterator(myMethodCopy); PsiSubstitutor substitutor = resolveResult.getSubstitutor(); while (newTypeParameters.hasNext()) { - final PsiTypeParameter newTypeParameter = newTypeParameters.next(); - final PsiTypeParameter oldTypeParameter = oldTypeParameters.next(); + PsiTypeParameter newTypeParameter = newTypeParameters.next(); + PsiTypeParameter oldTypeParameter = oldTypeParameters.next(); substitutor = substitutor.put(newTypeParameter, resolveResult.getSubstitutor().substitute(oldTypeParameter)); } return substitutor; @@ -737,14 +752,15 @@ private PsiSubstitutor getCallSubstitutor(PsiMethodCallExpression methodCall) { return PsiSubstitutor.EMPTY; } - private void substituteMethodTypeParams(PsiElement scope, final PsiSubstitutor substitutor) { + private void substituteMethodTypeParams(PsiElement scope, PsiSubstitutor substitutor) { InlineUtil.substituteTypeParams(scope, substitutor, myFactory); } + @RequiredReadAction private boolean isStrictlyFinal(PsiParameter parameter) { for (PsiReference reference : ReferencesSearch.search(parameter, GlobalSearchScope.projectScope(myProject), false)) { - final PsiElement refElement = reference.getElement(); - final PsiElement anonymousClass = PsiTreeUtil.getParentOfType(refElement, PsiAnonymousClass.class); + PsiElement refElement = reference.getElement(); + PsiElement anonymousClass = PsiTreeUtil.getParentOfType(refElement, PsiAnonymousClass.class); if (anonymousClass != null && PsiTreeUtil.isAncestor(myMethod, anonymousClass, true)) { return true; } @@ -752,37 +768,36 @@ private boolean isStrictlyFinal(PsiParameter parameter) { return false; } - - private boolean syncNeeded(final PsiReferenceExpression ref) { + private boolean syncNeeded(PsiReferenceExpression ref) { if (!myMethod.hasModifierProperty(PsiModifier.SYNCHRONIZED)) { return false; } - final PsiMethod containingMethod = Util.getContainingMethod(ref); + PsiMethod containingMethod = Util.getContainingMethod(ref); if (containingMethod == null) { return true; } if (!containingMethod.hasModifierProperty(PsiModifier.SYNCHRONIZED)) { return true; } - final PsiClass sourceContainingClass = myMethod.getContainingClass(); - final PsiClass targetContainingClass = containingMethod.getContainingClass(); + PsiClass sourceContainingClass = myMethod.getContainingClass(); + PsiClass targetContainingClass = containingMethod.getContainingClass(); return !sourceContainingClass.equals(targetContainingClass); } + @RequiredReadAction private BlockData prepareBlock( PsiReferenceExpression ref, - final PsiSubstitutor callSubstitutor, - final PsiExpressionList argumentList, - final InlineUtil.TailCallType tailCallType - ) - throws IncorrectOperationException { - final PsiCodeBlock block = myMethodCopy.getBody(); - final PsiStatement[] originalStatements = block.getStatements(); + PsiSubstitutor callSubstitutor, + PsiExpressionList argumentList, + InlineUtil.TailCallType tailCallType + ) throws IncorrectOperationException { + PsiCodeBlock block = myMethodCopy.getBody(); + PsiStatement[] originalStatements = block.getStatements(); PsiLocalVariable resultVar = null; PsiType returnType = callSubstitutor.substitute(myMethod.getReturnType()); String resultName = null; - final int applicabilityLevel = PsiUtil.getApplicabilityLevel(myMethod, callSubstitutor, argumentList); + int applicabilityLevel = PsiUtil.getApplicabilityLevel(myMethod, callSubstitutor, argumentList); if (returnType != null && !PsiType.VOID.equals(returnType) && tailCallType == InlineUtil.TailCallType.None) { resultName = myJavaCodeStyle.propertyNameToVariableName("result", VariableKind.LOCAL_VARIABLE); resultName = myJavaCodeStyle.suggestUniqueVariableName(resultName, block.getFirstChild(), true); @@ -804,9 +819,8 @@ private BlockData prepareBlock( } RefactoringUtil.renameVariableReferences(parm, name, new LocalSearchScope(myMethodCopy.getBody()), true); PsiType paramType = parm.getType(); - @NonNls String defaultValue; - if (paramType instanceof PsiEllipsisType) { - final PsiEllipsisType ellipsisType = (PsiEllipsisType)paramType; + String defaultValue; + if (paramType instanceof PsiEllipsisType ellipsisType) { paramType = callSubstitutor.substitute(ellipsisType.toArrayType()); if (applicabilityLevel == MethodCandidateInfo.ApplicabilityLevel.VARARGS) { defaultValue = "new " + ((PsiArrayType)paramType).getComponentType().getCanonicalText() + "[]{}"; @@ -829,7 +843,7 @@ private BlockData prepareBlock( PsiLocalVariable thisVar = null; PsiClass containingClass = myMethod.getContainingClass(); - if (!myMethod.hasModifierProperty(PsiModifier.STATIC) && containingClass != null) { + if (!myMethod.isStatic() && containingClass != null) { PsiType thisType = myFactory.createType(containingClass, callSubstitutor); String[] names = myJavaCodeStyle.suggestVariableName(VariableKind.LOCAL_VARIABLE, null, null, thisType) .names; @@ -845,7 +859,7 @@ private BlockData prepareBlock( if (thisVar != null) { lockName = thisVar.getName(); } - else if (myMethod.hasModifierProperty(PsiModifier.STATIC) && containingClass != null) { + else if (myMethod.isStatic() && containingClass != null) { lockName = containingClass.getQualifiedName() + ".class"; } @@ -854,8 +868,8 @@ else if (myMethod.hasModifierProperty(PsiModifier.STATIC) && containingClass != (PsiSynchronizedStatement)myFactory.createStatementFromText("synchronized(" + lockName + "){}", block); synchronizedStatement = (PsiSynchronizedStatement)CodeStyleManager.getInstance(myProject).reformat(synchronizedStatement); synchronizedStatement = (PsiSynchronizedStatement)block.add(synchronizedStatement); - final PsiCodeBlock synchronizedBody = synchronizedStatement.getBody(); - for (final PsiStatement originalStatement : originalStatements) { + PsiCodeBlock synchronizedBody = synchronizedStatement.getBody(); + for (PsiStatement originalStatement : originalStatements) { synchronizedBody.add(originalStatement); originalStatement.delete(); } @@ -864,14 +878,14 @@ else if (myMethod.hasModifierProperty(PsiModifier.STATIC) && containingClass != if (resultName != null || tailCallType == InlineUtil.TailCallType.Simple) { PsiReturnStatement[] returnStatements = RefactoringUtil.findReturnStatements(myMethodCopy); for (PsiReturnStatement returnStatement : returnStatements) { - final PsiExpression returnValue = returnStatement.getReturnValue(); + PsiExpression returnValue = returnStatement.getReturnValue(); if (returnValue == null) { continue; } PsiStatement statement; if (tailCallType == InlineUtil.TailCallType.Simple) { - if (returnValue instanceof PsiExpression && returnStatement.getNextSibling() == myMethodCopy.getBody() - .getLastBodyElement()) { + if (returnValue instanceof PsiExpression + && returnStatement.getNextSibling() == myMethodCopy.getBody().getLastBodyElement()) { PsiExpressionStatement exprStatement = (PsiExpressionStatement)myFactory.createStatementFromText("a;", null); exprStatement.getExpression().replace(returnValue); returnStatement.getParent().addBefore(exprStatement, returnStatement); @@ -894,10 +908,10 @@ else if (myMethod.hasModifierProperty(PsiModifier.STATIC) && containingClass != return new BlockData(block, thisVar, parmVars, resultVar); } - private void solveVariableNameConflicts(PsiElement scope, final PsiElement placeToInsert) throws IncorrectOperationException { - if (scope instanceof PsiVariable) { - PsiVariable var = (PsiVariable)scope; - String name = var.getName(); + @RequiredWriteAction + private void solveVariableNameConflicts(PsiElement scope, PsiElement placeToInsert) throws IncorrectOperationException { + if (scope instanceof PsiVariable variable) { + String name = variable.getName(); String oldName = name; while (true) { String newName = myJavaCodeStyle.suggestUniqueVariableName(name, placeToInsert, true); @@ -905,15 +919,15 @@ private void solveVariableNameConflicts(PsiElement scope, final PsiElement place break; } name = newName; - newName = myJavaCodeStyle.suggestUniqueVariableName(name, var, true); + newName = myJavaCodeStyle.suggestUniqueVariableName(name, variable, true); if (newName.equals(name)) { break; } name = newName; } if (!name.equals(oldName)) { - RefactoringUtil.renameVariableReferences(var, name, new LocalSearchScope(myMethodCopy.getBody()), true); - var.getNameIdentifier().replace(myFactory.createIdentifier(name)); + RefactoringUtil.renameVariableReferences(variable, name, new LocalSearchScope(myMethodCopy.getBody()), true); + variable.getNameIdentifier().replace(myFactory.createIdentifier(name)); } } @@ -923,15 +937,17 @@ private void solveVariableNameConflicts(PsiElement scope, final PsiElement place } } + @RequiredWriteAction private void addParmAndThisVarInitializers(BlockData blockData, PsiMethodCallExpression methodCall) throws IncorrectOperationException { PsiExpression[] args = methodCall.getArgumentList().getExpressions(); if (blockData.parmVars.length > 0) { for (int i = 0; i < args.length; i++) { int j = Math.min(i, blockData.parmVars.length - 1); - final PsiExpression initializer = blockData.parmVars[j].getInitializer(); + PsiExpression initializer = blockData.parmVars[j].getInitializer(); LOG.assertTrue(initializer != null); - if (initializer instanceof PsiNewExpression && ((PsiNewExpression)initializer).getArrayInitializer() != null) { //varargs initializer - final PsiArrayInitializerExpression arrayInitializer = ((PsiNewExpression)initializer).getArrayInitializer(); + if (initializer instanceof PsiNewExpression newExpr && newExpr.getArrayInitializer() != null) { + //varargs initializer + PsiArrayInitializerExpression arrayInitializer = newExpr.getArrayInitializer(); arrayInitializer.add(args[i]); continue; } @@ -945,18 +961,14 @@ private void addParmAndThisVarInitializers(BlockData blockData, PsiMethodCallExp if (qualifier == null) { PsiElement parent = methodCall.getContext(); while (true) { - if (parent instanceof PsiClass) { - break; - } - if (parent instanceof PsiFile) { + if (parent instanceof PsiClass || parent instanceof PsiFile) { break; } assert parent != null : methodCall; parent = parent.getContext(); } - if (parent instanceof PsiClass) { - PsiClass parentClass = (PsiClass)parent; - final PsiClass containingClass = myMethod.getContainingClass(); + if (parent instanceof PsiClass parentClass) { + PsiClass containingClass = myMethod.getContainingClass(); if (InheritanceUtil.isInheritorOrSelf(parentClass, containingClass, true)) { qualifier = myFactory.createExpressionFromText("this", null); } @@ -975,7 +987,7 @@ private void addParmAndThisVarInitializers(BlockData blockData, PsiMethodCallExp parentClass = PsiTreeUtil.getParentOfType(parentClass, PsiClass.class, true); if (InheritanceUtil.isInheritorOrSelf(parentClass, containingClass, true)) { LOG.assertTrue(parentClass != null); - final String childClassName = parentClass.getName(); + String childClassName = parentClass.getName(); qualifier = myFactory.createExpressionFromText( childClassName != null ? childClassName + ".this" : "this", null @@ -998,14 +1010,12 @@ else if (qualifier instanceof PsiSuperExpression) { } } + @RequiredReadAction private boolean canInlineParmOrThisVariable(PsiLocalVariable variable) { boolean isAccessedForWriting = false; for (PsiReference ref : ReferencesSearch.search(variable)) { - PsiElement refElement = ref.getElement(); - if (refElement instanceof PsiExpression) { - if (PsiUtil.isAccessedForWriting((PsiExpression)refElement)) { - isAccessedForWriting = true; - } + if (ref.getElement() instanceof PsiExpression expression && PsiUtil.isAccessedForWriting(expression)) { + isAccessedForWriting = true; } } @@ -1020,6 +1030,7 @@ private boolean canInlineParmOrThisVariable(PsiLocalVariable variable) { ); } + @RequiredWriteAction private void inlineParmOrThisVariable(PsiLocalVariable variable, boolean strictlyFinal) throws IncorrectOperationException { PsiReference firstRef = ReferencesSearch.search(variable).findFirst(); @@ -1030,13 +1041,10 @@ private void inlineParmOrThisVariable(PsiLocalVariable variable, boolean strictl boolean isAccessedForWriting = false; - final Collection refs = ReferencesSearch.search(variable).findAll(); + Collection refs = ReferencesSearch.search(variable).findAll(); for (PsiReference ref : refs) { - PsiElement refElement = ref.getElement(); - if (refElement instanceof PsiExpression) { - if (PsiUtil.isAccessedForWriting((PsiExpression)refElement)) { - isAccessedForWriting = true; - } + if (ref.getElement() instanceof PsiExpression expression && PsiUtil.isAccessedForWriting(expression)) { + isAccessedForWriting = true; } } @@ -1047,9 +1055,9 @@ private void inlineParmOrThisVariable(PsiLocalVariable variable, boolean strictl declareUsedLocalsFinal(initializer, strictlyFinal); } for (PsiReference ref : refs) { - final PsiJavaCodeReferenceElement javaRef = (PsiJavaCodeReferenceElement)ref; - if (initializer instanceof PsiThisExpression && ((PsiThisExpression)initializer).getQualifier() == null) { - final PsiClass varThisClass = RefactoringChangeUtil.getThisClass(variable); + PsiJavaCodeReferenceElement javaRef = (PsiJavaCodeReferenceElement)ref; + if (initializer instanceof PsiThisExpression thisExpr && thisExpr.getQualifier() == null) { + PsiClass varThisClass = RefactoringChangeUtil.getThisClass(variable); if (RefactoringChangeUtil.getThisClass(javaRef) != varThisClass) { initializer = JavaPsiFacade.getInstance(myManager.getProject()) .getElementFactory() @@ -1062,19 +1070,16 @@ private void inlineParmOrThisVariable(PsiLocalVariable variable, boolean strictl InlineUtil.tryToInlineArrayCreationForVarargs(expr); //Q: move the following code to some util? (addition to inline?) - if (expr instanceof PsiThisExpression) { - if (expr.getParent() instanceof PsiReferenceExpression) { - PsiReferenceExpression refExpr = (PsiReferenceExpression)expr.getParent(); - PsiElement refElement = refExpr.resolve(); - PsiExpression exprCopy = (PsiExpression)refExpr.copy(); - refExpr = - (PsiReferenceExpression)refExpr.replace(myFactory.createExpressionFromText(refExpr.getReferenceName(), null)); - if (refElement != null) { - PsiElement newRefElement = refExpr.resolve(); - if (!refElement.equals(newRefElement)) { - // change back - refExpr.replace(exprCopy); - } + if (expr instanceof PsiThisExpression && expr.getParent() instanceof PsiReferenceExpression refExpr) { + PsiElement refElement = refExpr.resolve(); + PsiExpression exprCopy = (PsiExpression)refExpr.copy(); + refExpr = + (PsiReferenceExpression)refExpr.replace(myFactory.createExpressionFromText(refExpr.getReferenceName(), null)); + if (refElement != null) { + PsiElement newRefElement = refExpr.resolve(); + if (!refElement.equals(newRefElement)) { + // change back + refExpr.replace(exprCopy); } } } @@ -1083,6 +1088,7 @@ private void inlineParmOrThisVariable(PsiLocalVariable variable, boolean strictl } } + @RequiredReadAction private boolean canInlineParmOrThisVariable( PsiExpression initializer, boolean shouldBeFinal, @@ -1095,8 +1101,9 @@ class CanAllLocalsBeDeclaredFinal extends JavaRecursiveElementWalkingVisitor { boolean success = true; @Override + @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { - final PsiElement psiElement = expression.resolve(); + PsiElement psiElement = expression.resolve(); if (psiElement instanceof PsiLocalVariable || psiElement instanceof PsiParameter) { if (!RefactoringUtil.canBeDeclaredFinal((PsiVariable)psiElement)) { success = false; @@ -1112,7 +1119,7 @@ public void visitElement(PsiElement element) { } } - final CanAllLocalsBeDeclaredFinal canAllLocalsBeDeclaredFinal = new CanAllLocalsBeDeclaredFinal(); + CanAllLocalsBeDeclaredFinal canAllLocalsBeDeclaredFinal = new CanAllLocalsBeDeclaredFinal(); initializer.accept(canAllLocalsBeDeclaredFinal); if (!canAllLocalsBeDeclaredFinal.success) { return false; @@ -1121,8 +1128,8 @@ public void visitElement(PsiElement element) { if (initializer instanceof PsiMethodReferenceExpression) { return true; } - if (initializer instanceof PsiReferenceExpression) { - PsiVariable refVar = (PsiVariable)((PsiReferenceExpression)initializer).resolve(); + if (initializer instanceof PsiReferenceExpression refExpr) { + PsiVariable refVar = (PsiVariable)refExpr.resolve(); if (refVar == null) { return !isAccessedForWriting; } @@ -1150,10 +1157,7 @@ public void visitElement(PsiElement element) { return refs.length == 1; //TODO: control flow } else { - if (shouldBeFinal) { - return refVar.hasModifierProperty(PsiModifier.FINAL) || RefactoringUtil.canBeDeclaredFinal(refVar); - } - return true; + return !shouldBeFinal || refVar.hasModifierProperty(PsiModifier.FINAL) || RefactoringUtil.canBeDeclaredFinal(refVar); } } } @@ -1164,8 +1168,8 @@ else if (initializer instanceof PsiCallExpression) { if (accessCount > 1) { return false; } - if (initializer instanceof PsiNewExpression) { - final PsiArrayInitializerExpression arrayInitializer = ((PsiNewExpression)initializer).getArrayInitializer(); + if (initializer instanceof PsiNewExpression newExpr) { + PsiArrayInitializerExpression arrayInitializer = newExpr.getArrayInitializer(); if (arrayInitializer != null) { for (PsiExpression expression : arrayInitializer.getInitializers()) { if (!canInlineParmOrThisVariable(expression, shouldBeFinal, strictlyFinal, accessCount, false)) { @@ -1175,11 +1179,11 @@ else if (initializer instanceof PsiCallExpression) { return true; } } - final PsiExpressionList argumentList = ((PsiCallExpression)initializer).getArgumentList(); + PsiExpressionList argumentList = ((PsiCallExpression)initializer).getArgumentList(); if (argumentList == null) { return false; } - final PsiExpression[] expressions = argumentList.getExpressions(); + PsiExpression[] expressions = argumentList.getExpressions(); for (PsiExpression expression : expressions) { if (!canInlineParmOrThisVariable(expression, shouldBeFinal, strictlyFinal, accessCount, false)) { return false; @@ -1190,22 +1194,21 @@ else if (initializer instanceof PsiCallExpression) { else if (initializer instanceof PsiLiteralExpression) { return true; } - else if (initializer instanceof PsiArrayAccessExpression) { - final PsiExpression arrayExpression = ((PsiArrayAccessExpression)initializer).getArrayExpression(); - final PsiExpression indexExpression = ((PsiArrayAccessExpression)initializer).getIndexExpression(); - return canInlineParmOrThisVariable(arrayExpression, shouldBeFinal, strictlyFinal, accessCount, false) && - canInlineParmOrThisVariable(indexExpression, shouldBeFinal, strictlyFinal, accessCount, false); + else if (initializer instanceof PsiArrayAccessExpression arrayAccess) { + PsiExpression arrayExpression = arrayAccess.getArrayExpression(); + PsiExpression indexExpression = arrayAccess.getIndexExpression(); + return canInlineParmOrThisVariable(arrayExpression, shouldBeFinal, strictlyFinal, accessCount, false) + && canInlineParmOrThisVariable(indexExpression, shouldBeFinal, strictlyFinal, accessCount, false); } - else if (initializer instanceof PsiParenthesizedExpression) { - PsiExpression expr = ((PsiParenthesizedExpression)initializer).getExpression(); + else if (initializer instanceof PsiParenthesizedExpression parenthesized) { + PsiExpression expr = parenthesized.getExpression(); return expr == null || canInlineParmOrThisVariable(expr, shouldBeFinal, strictlyFinal, accessCount, false); } - else if (initializer instanceof PsiTypeCastExpression) { - PsiExpression operand = ((PsiTypeCastExpression)initializer).getOperand(); + else if (initializer instanceof PsiTypeCastExpression typeCast) { + PsiExpression operand = typeCast.getOperand(); return operand != null && canInlineParmOrThisVariable(operand, shouldBeFinal, strictlyFinal, accessCount, false); } - else if (initializer instanceof PsiPolyadicExpression) { - PsiPolyadicExpression binExpr = (PsiPolyadicExpression)initializer; + else if (initializer instanceof PsiPolyadicExpression binExpr) { for (PsiExpression op : binExpr.getOperands()) { if (!canInlineParmOrThisVariable(op, shouldBeFinal, strictlyFinal, accessCount, false)) { return false; @@ -1227,9 +1230,10 @@ else if (initializer instanceof PsiSuperExpression) { } } + @RequiredWriteAction private static void declareUsedLocalsFinal(PsiElement expr, boolean strictlyFinal) throws IncorrectOperationException { - if (expr instanceof PsiReferenceExpression) { - PsiElement refElement = ((PsiReferenceExpression)expr).resolve(); + if (expr instanceof PsiReferenceExpression refExpr) { + PsiElement refElement = refExpr.resolve(); if (refElement instanceof PsiLocalVariable || refElement instanceof PsiParameter) { if (strictlyFinal || RefactoringUtil.canBeDeclaredFinal((PsiVariable)refElement)) { PsiUtil.setModifierProperty(((PsiVariable)refElement), PsiModifier.FINAL, true); @@ -1242,44 +1246,47 @@ private static void declareUsedLocalsFinal(PsiElement expr, boolean strictlyFina } } - /* - private boolean isFieldNonModifiable(PsiField field) { - if (field.hasModifierProperty(PsiModifier.FINAL)){ - return true; - } - PsiElement[] refs = myManager.getSearchHelper().findReferences(field, null, false); - for(int i = 0; i < refs.length; i++){ - PsiReferenceExpression ref = (PsiReferenceExpression)refs[i]; - if (PsiUtil.isAccessedForWriting(ref)) { - PsiElement container = ref.getParent(); - while(true){ - if (container instanceof PsiMethod || - container instanceof PsiField || - container instanceof PsiClassInitializer || - container instanceof PsiFile) break; - container = container.getParent(); - } - if (container instanceof PsiMethod && ((PsiMethod)container).isConstructor()) continue; - return false; - } + /* + private boolean isFieldNonModifiable(PsiField field) { + if (field.hasModifierProperty(PsiModifier.FINAL)){ + return true; + } + PsiElement[] refs = myManager.getSearchHelper().findReferences(field, null, false); + for(int i = 0; i < refs.length; i++){ + PsiReferenceExpression ref = (PsiReferenceExpression)refs[i]; + if (PsiUtil.isAccessedForWriting(ref)) { + PsiElement container = ref.getParent(); + while(true){ + if (container instanceof PsiMethod + || container instanceof PsiField + || container instanceof PsiClassInitializer + || container instanceof PsiFile) { + break; + } + container = container.getParent(); + } + if (container instanceof PsiMethod method && method.isConstructor()) continue; + return false; + } + } + return true; } - return true; - } - */ + */ + @RequiredWriteAction private void inlineResultVariable(PsiVariable resultVar) throws IncorrectOperationException { PsiAssignmentExpression assignment = null; PsiReferenceExpression resultUsage = null; for (PsiReference ref1 : ReferencesSearch.search(resultVar, GlobalSearchScope.projectScope(myProject), false)) { PsiReferenceExpression ref = (PsiReferenceExpression)ref1; - if (ref.getParent() instanceof PsiAssignmentExpression - && ((PsiAssignmentExpression)ref.getParent()).getLExpression().equals(ref)) { + if (ref.getParent() instanceof PsiAssignmentExpression assignmentExpr + && assignmentExpr.getLExpression().equals(ref)) { if (assignment != null) { assignment = null; break; } else { - assignment = (PsiAssignmentExpression)ref.getParent(); + assignment = assignmentExpr; } } else { @@ -1329,8 +1336,9 @@ private void inlineResultVariable(PsiVariable resultVar) throws IncorrectOperati } else { PsiExpression rExpression = assignment.getRExpression(); - while (rExpression instanceof PsiReferenceExpression) - rExpression = ((PsiReferenceExpression)rExpression).getQualifierExpression(); + while (rExpression instanceof PsiReferenceExpression refExpr) { + rExpression = refExpr.getQualifierExpression(); + } if (rExpression == null || !PsiUtil.isStatement(rExpression)) { assignment.delete(); } @@ -1343,10 +1351,11 @@ private void inlineResultVariable(PsiVariable resultVar) throws IncorrectOperati private static final Key MARK_KEY = Key.create(""); + @RequiredWriteAction private PsiReferenceExpression[] addBracesWhenNeeded(PsiReferenceExpression[] refs) throws IncorrectOperationException { - ArrayList refsVector = new ArrayList(); - ArrayList addedBracesVector = new ArrayList(); - myAddedClassInitializers = new HashMap(); + List refsVector = new ArrayList<>(); + List addedBracesVector = new ArrayList<>(); + myAddedClassInitializers = new HashMap<>(); for (PsiReferenceExpression ref : refs) { ref.putCopyableUserData(MARK_KEY, ""); @@ -1376,23 +1385,24 @@ private PsiReferenceExpression[] addBracesWhenNeeded(PsiReferenceExpression[] re } parent = parent.getParent(); } - final PsiElement lambdaExpr = parentStatement.getParent(); - if (lambdaExpr instanceof PsiLambdaExpression) { - final PsiLambdaExpression newLambdaExpr = (PsiLambdaExpression)myFactory.createExpressionFromText( - ((PsiLambdaExpression)lambdaExpr).getParameterList().getText() + " -> " + "{\n}", lambdaExpr); - final PsiStatement statementFromText; - if (PsiType.VOID.equals(LambdaUtil.getFunctionalInterfaceReturnType((PsiLambdaExpression)lambdaExpr))) { - statementFromText = myFactory.createStatementFromText("a;", lambdaExpr); + if (parentStatement.getParent() instanceof PsiLambdaExpression lambda) { + PsiLambdaExpression newLambdaExpr = (PsiLambdaExpression)myFactory.createExpressionFromText( + lambda.getParameterList().getText() + " -> " + "{\n}", + lambda + ); + PsiStatement statementFromText; + if (PsiType.VOID.equals(LambdaUtil.getFunctionalInterfaceReturnType(lambda))) { + statementFromText = myFactory.createStatementFromText("a;", lambda); ((PsiExpressionStatement)statementFromText).getExpression().replace(parentStatement); } else { - statementFromText = myFactory.createStatementFromText("return a;", lambdaExpr); + statementFromText = myFactory.createStatementFromText("return a;", lambda); ((PsiReturnStatement)statementFromText).getReturnValue().replace(parentStatement); } newLambdaExpr.getBody().add(statementFromText); - final PsiCodeBlock body = (PsiCodeBlock)((PsiLambdaExpression)lambdaExpr.replace(newLambdaExpr)).getBody(); + PsiCodeBlock body = (PsiCodeBlock)((PsiLambdaExpression)lambda.replace(newLambdaExpr)).getBody(); PsiElement newStatement = body.getStatements()[0]; addMarkedElements(refsVector, newStatement); addedBracesVector.add(body); @@ -1401,28 +1411,28 @@ private PsiReferenceExpression[] addBracesWhenNeeded(PsiReferenceExpression[] re } } else { - final PsiField field = PsiTreeUtil.getParentOfType(ref, PsiField.class); + PsiField field = PsiTreeUtil.getParentOfType(ref, PsiField.class); if (field != null) { if (field instanceof PsiEnumConstant) { inlineEnumConstantParameter(refsVector, ref); continue; } field.normalizeDeclaration(); - final PsiExpression initializer = field.getInitializer(); + PsiExpression initializer = field.getInitializer(); LOG.assertTrue(initializer != null); PsiClassInitializer classInitializer = myFactory.createClassInitializer(); - final PsiClass containingClass = field.getContainingClass(); + PsiClass containingClass = field.getContainingClass(); classInitializer = (PsiClassInitializer)containingClass.addAfter(classInitializer, field); containingClass.addAfter(CodeEditUtil.createLineFeed(field.getManager()), field); - final PsiCodeBlock body = classInitializer.getBody(); + PsiCodeBlock body = classInitializer.getBody(); PsiExpressionStatement statement = (PsiExpressionStatement)myFactory.createStatementFromText(field.getName() + " = 0;", body); statement = (PsiExpressionStatement)body.add(statement); - final PsiAssignmentExpression assignment = (PsiAssignmentExpression)statement.getExpression(); + PsiAssignmentExpression assignment = (PsiAssignmentExpression)statement.getExpression(); assignment.getLExpression().replace(RenameJavaVariableProcessor.createMemberReference(field, assignment)); assignment.getRExpression().replace(initializer); addMarkedElements(refsVector, statement); - if (field.hasModifierProperty(PsiModifier.STATIC)) { + if (field.isStatic()) { PsiUtil.setModifierProperty(classInitializer, PsiModifier.STATIC, true); } myAddedClassInitializers.put(field, classInitializer); @@ -1441,9 +1451,10 @@ private PsiReferenceExpression[] addBracesWhenNeeded(PsiReferenceExpression[] re return refsVector.toArray(new PsiReferenceExpression[refsVector.size()]); } + @RequiredWriteAction private void inlineEnumConstantParameter( final List refsVector, - final PsiReferenceExpression ref + PsiReferenceExpression ref ) throws IncorrectOperationException { PsiExpression expr = getSimpleReturnedExpression(myMethod); if (expr != null) { @@ -1451,21 +1462,22 @@ private void inlineEnumConstantParameter( } else { PsiCall call = PsiTreeUtil.getParentOfType(ref, PsiCall.class); - @NonNls String text = + String text = "new Object() { " + myMethod.getReturnTypeElement().getText() + " evaluate() { return " + call.getText() + ";}}.evaluate"; PsiExpression callExpr = JavaPsiFacade.getInstance(myProject).getParserFacade().createExpressionFromText(text, call); PsiElement classExpr = ref.replace(callExpr); classExpr.accept(new JavaRecursiveElementWalkingVisitor() { - public void visitReturnStatement(final PsiReturnStatement statement) { + @Override + public void visitReturnStatement(@Nonnull PsiReturnStatement statement) { super.visitReturnStatement(statement); PsiExpression expr = statement.getReturnValue(); - if (expr instanceof PsiMethodCallExpression) { - refsVector.add(((PsiMethodCallExpression)expr).getMethodExpression()); + if (expr instanceof PsiMethodCallExpression methodCall) { + refsVector.add(methodCall.getMethodExpression()); } } }); - if (classExpr.getParent() instanceof PsiMethodCallExpression) { - PsiExpressionList args = ((PsiMethodCallExpression)classExpr.getParent()).getArgumentList(); + if (classExpr.getParent() instanceof PsiMethodCallExpression methodCall) { + PsiExpressionList args = methodCall.getArgumentList(); PsiExpression[] argExpressions = args.getExpressions(); if (argExpressions.length > 0) { args.deleteChildRange(argExpressions[0], argExpressions[argExpressions.length - 1]); @@ -1475,7 +1487,7 @@ public void visitReturnStatement(final PsiReturnStatement statement) { } @Nullable - private static PsiExpression getSimpleReturnedExpression(final PsiMethod method) { + private static PsiExpression getSimpleReturnedExpression(PsiMethod method) { PsiCodeBlock body = method.getBody(); if (body == null) { return null; @@ -1504,6 +1516,7 @@ public void visitElement(PsiElement element) { }); } + @RequiredWriteAction private void removeAddedBracesWhenPossible() throws IncorrectOperationException { if (myAddedBraces == null) { return; @@ -1512,16 +1525,16 @@ private void removeAddedBracesWhenPossible() throws IncorrectOperationException for (PsiCodeBlock codeBlock : myAddedBraces) { PsiStatement[] statements = codeBlock.getStatements(); if (statements.length == 1) { - final PsiElement codeBlockParent = codeBlock.getParent(); + PsiElement codeBlockParent = codeBlock.getParent(); if (codeBlockParent instanceof PsiLambdaExpression) { - if (statements[0] instanceof PsiReturnStatement) { - final PsiExpression returnValue = ((PsiReturnStatement)statements[0]).getReturnValue(); + if (statements[0] instanceof PsiReturnStatement returnStmt) { + PsiExpression returnValue = returnStmt.getReturnValue(); if (returnValue != null) { codeBlock.replace(returnValue); } } - else if (statements[0] instanceof PsiExpressionStatement) { - codeBlock.replace(((PsiExpressionStatement)statements[0]).getExpression()); + else if (statements[0] instanceof PsiExpressionStatement expression) { + codeBlock.replace(expression.getExpression()); } } else if (codeBlockParent instanceof PsiBlockStatement) { @@ -1533,11 +1546,11 @@ else if (codeBlockParent instanceof PsiBlockStatement) { } } - final Set fields = myAddedClassInitializers.keySet(); + Set fields = myAddedClassInitializers.keySet(); for (PsiField psiField : fields) { - final PsiClassInitializer classInitializer = myAddedClassInitializers.get(psiField); - final PsiExpression initializer = getSimpleFieldInitializer(psiField, classInitializer); + PsiClassInitializer classInitializer = myAddedClassInitializers.get(psiField); + PsiExpression initializer = getSimpleFieldInitializer(psiField, classInitializer); if (initializer != null) { psiField.getInitializer().replace(initializer); classInitializer.delete(); @@ -1549,30 +1562,17 @@ else if (codeBlockParent instanceof PsiBlockStatement) { } @Nullable + @RequiredReadAction private PsiExpression getSimpleFieldInitializer(PsiField field, PsiClassInitializer initializer) { - final PsiStatement[] statements = initializer.getBody().getStatements(); - if (statements.length != 1) { - return null; - } - if (!(statements[0] instanceof PsiExpressionStatement)) { - return null; - } - final PsiExpression expression = ((PsiExpressionStatement)statements[0]).getExpression(); - if (!(expression instanceof PsiAssignmentExpression)) { - return null; - } - final PsiExpression lExpression = ((PsiAssignmentExpression)expression).getLExpression(); - if (!(lExpression instanceof PsiReferenceExpression)) { - return null; - } - final PsiElement resolved = ((PsiReferenceExpression)lExpression).resolve(); - if (!myManager.areElementsEquivalent(field, resolved)) { - return null; - } - return ((PsiAssignmentExpression)expression).getRExpression(); + PsiStatement[] statements = initializer.getBody().getStatements(); + return statements.length == 1 + && statements[0] instanceof PsiExpressionStatement expressionStmt + && expressionStmt.getExpression() instanceof PsiAssignmentExpression assignment + && assignment.getLExpression() instanceof PsiReferenceExpression lExpression + && myManager.areElementsEquivalent(field, lExpression.resolve()) ? assignment.getRExpression() : null; } - public static String checkCalledInSuperOrThisExpr(PsiCodeBlock methodBody, final PsiElement element) { + public static String checkCalledInSuperOrThisExpr(PsiCodeBlock methodBody, PsiElement element) { if (methodBody.getStatements().length > 1) { PsiExpression expr = PsiTreeUtil.getParentOfType(element, PsiExpression.class); while (expr != null) { @@ -1603,7 +1603,7 @@ public static boolean checkBadReturns(PsiMethod method) { LOG.debug(controlFlow.toString()); } - List instructions = new ArrayList(controlFlow.getInstructions()); + List instructions = new ArrayList<>(controlFlow.getInstructions()); // temporary replace all return's with empty statements in the flow for (PsiReturnStatement aReturn : returns) { @@ -1623,11 +1623,11 @@ public static boolean checkBadReturns(PsiMethod method) { break; } Instruction instruction = instructions.get(offset); - if (instruction instanceof GoToInstruction) { - offset = ((GoToInstruction)instruction).offset; + if (instruction instanceof GoToInstruction goToInsn) { + offset = goToInsn.offset; } - else if (instruction instanceof ThrowToInstruction) { - offset = ((ThrowToInstruction)instruction).offset; + else if (instruction instanceof ThrowToInstruction throwToInsn) { + offset = throwToInsn.offset; } else if (instruction instanceof ConditionalThrowToInstruction) { // In case of "conditional throw to", control flow will not be altered @@ -1659,7 +1659,8 @@ public BlockData(PsiCodeBlock block, PsiLocalVariable thisVar, PsiLocalVariable[ } @Nonnull - protected Collection getElementsToWrite(@Nonnull final UsageViewDescriptor descriptor) { + @Override + protected Collection getElementsToWrite(@Nonnull UsageViewDescriptor descriptor) { if (myInlineThisOnly) { return Collections.singletonList(myReference); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineToAnonymousClassProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineToAnonymousClassProcessor.java index 5bf1d61062..3feec9d80e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineToAnonymousClassProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/inline/InlineToAnonymousClassProcessor.java @@ -17,6 +17,8 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; +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.rename.NonCodeUsageInfoFactory; @@ -56,10 +58,10 @@ public class InlineToAnonymousClassProcessor extends BaseRefactoringProcessor { protected InlineToAnonymousClassProcessor( Project project, PsiClass psiClass, - @Nullable final PsiCall callToInline, + @Nullable PsiCall callToInline, boolean inlineThisOnly, - final boolean searchInComments, - final boolean searchInNonJavaFiles + boolean searchInComments, + boolean searchInNonJavaFiles ) { super(project); myClass = psiClass; @@ -73,23 +75,26 @@ protected InlineToAnonymousClassProcessor( } @Nonnull - protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { + @Override + protected UsageViewDescriptor createUsageViewDescriptor(@Nonnull UsageInfo[] usages) { return new InlineViewDescriptor(myClass); } @Nonnull + @Override + @RequiredReadAction protected UsageInfo[] findUsages() { if (myInlineThisOnly) { return new UsageInfo[]{new UsageInfo(myCallToInline)}; } - Set usages = new HashSet(); + Set usages = new HashSet<>(); for (PsiReference reference : ReferencesSearch.search(myClass)) { usages.add(new UsageInfo(reference.getElement())); } - final String qName = myClass.getQualifiedName(); + String qName = myClass.getQualifiedName(); if (qName != null) { - List nonCodeUsages = new ArrayList(); + List nonCodeUsages = new ArrayList<>(); if (mySearchInComments) { TextOccurrencesUtil.addUsagesInStringsAndComments(myClass, qName, nonCodeUsages, new NonCodeUsageInfoFactory(myClass, qName) @@ -108,12 +113,15 @@ protected UsageInfo[] findUsages() { return usages.toArray(new UsageInfo[usages.size()]); } + @Override protected void refreshElements(PsiElement[] elements) { assert elements.length == 1; myClass = (PsiClass)elements[0]; } - protected boolean isPreviewUsages(UsageInfo[] usages) { + @Override + @RequiredReadAction + protected boolean isPreviewUsages(@Nonnull UsageInfo[] usages) { if (super.isPreviewUsages(usages)) { return true; } @@ -127,7 +135,8 @@ protected boolean isPreviewUsages(UsageInfo[] usages) { return false; } - private static boolean isForcePreview(final UsageInfo usage) { + @RequiredReadAction + private static boolean isForcePreview(UsageInfo usage) { if (usage.isNonCodeUsage) { return true; } @@ -151,16 +160,18 @@ protected boolean preprocessUsages(@Nonnull SimpleReference refUsag return super.preprocessUsages(refUsages); } - public MultiMap getConflicts(final UsageInfo[] usages) { - final MultiMap result = new MultiMap(); + @RequiredReadAction + public MultiMap getConflicts(UsageInfo[] usages) { + final MultiMap result = new MultiMap<>(); ReferencedElementsCollector collector = new ReferencedElementsCollector() { - protected void checkAddMember(@Nonnull final PsiMember member) { + @Override + protected void checkAddMember(@Nonnull PsiMember member) { if (PsiTreeUtil.isAncestor(myClass, member, false)) { return; } - final PsiModifierList modifierList = member.getModifierList(); - if (member.getContainingClass() == myClass.getSuperClass() && modifierList != null && - modifierList.hasModifierProperty(PsiModifier.PROTECTED)) { + PsiModifierList modifierList = member.getModifierList(); + if (member.getContainingClass() == myClass.getSuperClass() && modifierList != null + && modifierList.hasModifierProperty(PsiModifier.PROTECTED)) { // ignore access to protected members of superclass - they'll be accessible anyway return; } @@ -170,28 +181,26 @@ protected void checkAddMember(@Nonnull final PsiMember member) { InlineMethodProcessor.addInaccessibleMemberConflicts(myClass, usages, collector, result); myClass.accept(new JavaRecursiveElementVisitor() { @Override - public void visitParameter(PsiParameter parameter) { + @RequiredReadAction + public void visitParameter(@Nonnull PsiParameter parameter) { super.visitParameter(parameter); if (PsiUtil.resolveClassInType(parameter.getType()) != myClass) { return; } for (PsiReference psiReference : ReferencesSearch.search(parameter)) { - final PsiElement refElement = psiReference.getElement(); + PsiElement refElement = psiReference.getElement(); if (refElement instanceof PsiExpression) { - final PsiReferenceExpression referenceExpression = + PsiReferenceExpression referenceExpression = PsiTreeUtil.getParentOfType(refElement, PsiReferenceExpression.class); if (referenceExpression != null && referenceExpression.getQualifierExpression() == refElement) { - final PsiElement resolvedMember = referenceExpression.resolve(); + PsiElement resolvedMember = referenceExpression.resolve(); if (resolvedMember != null && PsiTreeUtil.isAncestor(myClass, resolvedMember, false)) { - if (resolvedMember instanceof PsiMethod) { - if (myClass.findMethodsBySignature( - (PsiMethod)resolvedMember, - true - ).length > 1) { //skip inherited methods + if (resolvedMember instanceof PsiMethod method + && myClass.findMethodsBySignature(method, true).length > 1) { + //skip inherited methods continue; } - } result.putValue(refElement, "Class cannot be inlined because a call to its member inside body"); } } @@ -200,7 +209,7 @@ public void visitParameter(PsiParameter parameter) { } @Override - public void visitNewExpression(PsiNewExpression expression) { + public void visitNewExpression(@Nonnull PsiNewExpression expression) { super.visitNewExpression(expression); if (PsiUtil.resolveClassInType(expression.getType()) != myClass) { return; @@ -209,16 +218,16 @@ public void visitNewExpression(PsiNewExpression expression) { } @Override - public void visitMethodCallExpression(PsiMethodCallExpression expression) { + @RequiredReadAction + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); + PsiReferenceExpression methodExpression = expression.getMethodExpression(); + PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); if (qualifierExpression != null && PsiUtil.resolveClassInType(qualifierExpression.getType()) != myClass) { return; } - final PsiElement resolved = methodExpression.resolve(); - if (resolved instanceof PsiMethod) { - final PsiMethod method = (PsiMethod)resolved; + PsiElement resolved = methodExpression.resolve(); + if (resolved instanceof PsiMethod method) { if ("getClass".equals(method.getName()) && method.getParameterList().getParametersCount() == 0) { result.putValue(methodExpression, "Result of getClass() invocation would be changed"); } @@ -228,18 +237,20 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { return result; } + @Override + @RequiredWriteAction protected void performRefactoring(UsageInfo[] usages) { - final PsiClassType superType = getSuperType(myClass); + PsiClassType superType = getSuperType(myClass); LOG.assertTrue(superType != null); - List elementsToDelete = new ArrayList(); - List newExpressions = new ArrayList(); + List elementsToDelete = new ArrayList<>(); + List newExpressions = new ArrayList<>(); for (UsageInfo info : usages) { - final PsiElement element = info.getElement(); - if (element instanceof PsiNewExpression) { - newExpressions.add((PsiNewExpression)element); + PsiElement element = info.getElement(); + if (element instanceof PsiNewExpression newExpr) { + newExpressions.add(newExpr); } - else if (element.getParent() instanceof PsiNewExpression) { - newExpressions.add((PsiNewExpression)element.getParent()); + else if (element.getParent() instanceof PsiNewExpression newExpr) { + newExpressions.add(newExpr); } else { PsiImportStatement statement = PsiTreeUtil.getParentOfType(element, PsiImportStatement.class); @@ -280,7 +291,8 @@ else if (element.getParent() instanceof PsiNewExpression) { } } - private void replaceNewOrType(final PsiNewExpression psiNewExpression, final PsiClassType superType) { + @RequiredWriteAction + private void replaceNewOrType(PsiNewExpression psiNewExpression, PsiClassType superType) { try { if (psiNewExpression.getArrayDimensions().length == 0 && psiNewExpression.getArrayInitializer() == null) { new InlineToAnonymousConstructorProcessor(myClass, psiNewExpression, superType).run(); @@ -296,7 +308,8 @@ private void replaceNewOrType(final PsiNewExpression psiNewExpression, final Psi } } - private void replaceWithSuperType(final PsiTypeElement typeElement, final PsiClassType superType) { + @RequiredWriteAction + private void replaceWithSuperType(PsiTypeElement typeElement, PsiClassType superType) { PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory(); PsiClassType psiType = (PsiClassType)typeElement.getType(); PsiClassType.ClassResolveResult classResolveResult = psiType.resolveGenerics(); @@ -311,7 +324,7 @@ private void replaceWithSuperType(final PsiTypeElement typeElement, final PsiCla } @Nullable - public static PsiClassType getSuperType(final PsiClass aClass) { + public static PsiClassType getSuperType(PsiClass aClass) { PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); PsiClassType superType; @@ -336,6 +349,8 @@ public static PsiClassType getSuperType(final PsiClass aClass) { return superType; } + @Nonnull + @Override protected String getCommandName() { return RefactoringLocalize.inlineToAnonymousCommandName(myClass.getQualifiedName()).get(); }