diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AdjustFunctionContextFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AdjustFunctionContextFix.java index a398f0baf080..f7d3980e8aa4 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AdjustFunctionContextFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AdjustFunctionContextFix.java @@ -2,10 +2,10 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.daemon.QuickFixBundle; -import com.intellij.codeInsight.intention.HighPriorityAction; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.codeInsight.intention.PriorityAction; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandAction; import com.intellij.psi.*; import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.PsiTreeUtil; @@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable; import java.util.function.Function; -public class AdjustFunctionContextFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction { +public class AdjustFunctionContextFix extends PsiUpdateModCommandAction { private static final Function> MAP_NAME_ADJUSTER = (PsiMethodCallExpression call) -> (PsiType type) -> { PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); @@ -56,27 +56,21 @@ public class AdjustFunctionContextFix extends LocalQuickFixAndIntentionActionOnP private final String myOriginalName; private final String myNewName; - protected AdjustFunctionContextFix(@NotNull PsiMethodCallExpression call, @NotNull String targetMethodName) { + private AdjustFunctionContextFix(@NotNull PsiMethodCallExpression call, @NotNull String targetMethodName) { super(call); myOriginalName = call.getMethodExpression().getReferenceName(); myNewName = targetMethodName; } @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - PsiMethodCallExpression call = ObjectUtils.tryCast(startElement, PsiMethodCallExpression.class); - if (call == null) return; + protected void invoke(@NotNull ActionContext context, @NotNull PsiMethodCallExpression call, @NotNull EditorUpdater updater) { ExpressionUtils.bindCallTo(call, myNewName); } - @NotNull @Override - public String getText() { - return QuickFixBundle.message("adjust.method.accepting.functional.expression.fix.text", myOriginalName, myNewName); + protected @Nullable Presentation getPresentation(@NotNull ActionContext context, @NotNull PsiMethodCallExpression element) { + return Presentation.of(QuickFixBundle.message("adjust.method.accepting.functional.expression.fix.text", myOriginalName, myNewName)).withPriority( + PriorityAction.Priority.HIGH).withFixAllOption(this); } @Nls @@ -88,7 +82,7 @@ public class AdjustFunctionContextFix extends LocalQuickFixAndIntentionActionOnP @Contract("null -> null") @Nullable - public static AdjustFunctionContextFix createFix(PsiElement context) { + public static IntentionAction createFix(PsiElement context) { if (!(context instanceof PsiExpression expression)) return null; PsiFunctionalExpression fn = PsiTreeUtil.getParentOfType(context, PsiFunctionalExpression.class, false); if (fn == null) return null; @@ -105,6 +99,6 @@ public class AdjustFunctionContextFix extends LocalQuickFixAndIntentionActionOnP } String targetMethodName = remapper.apply(actualReturnType); if (targetMethodName == null) return null; - return new AdjustFunctionContextFix(call, targetMethodName); + return new AdjustFunctionContextFix(call, targetMethodName).asIntention(); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/intention/AddTypeAnnotationFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/intention/AddTypeAnnotationFix.java index df5543ed3e89..d26008749c83 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/intention/AddTypeAnnotationFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/intention/AddTypeAnnotationFix.java @@ -1,21 +1,21 @@ -// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInsight.intention; -import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandQuickFix; import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiElement; import com.intellij.psi.PsiTypeElement; import com.intellij.util.ObjectUtils; import org.jetbrains.annotations.NotNull; import java.util.Collection; -public class AddTypeAnnotationFix implements LocalQuickFix { +public class AddTypeAnnotationFix extends PsiUpdateModCommandQuickFix { private final @NotNull String myAnnotationToAdd; - @SafeFieldForPreview private final @NotNull Collection myAnnotationsToRemove; public AddTypeAnnotationFix(@NotNull String annotationToAdd, @NotNull Collection annotationsToRemove) { @@ -34,9 +34,8 @@ public class AddTypeAnnotationFix implements LocalQuickFix { } @Override - public void applyFix(@NotNull Project project, - @NotNull ProblemDescriptor descriptor) { - PsiTypeElement typeElement = ObjectUtils.tryCast(descriptor.getStartElement(), PsiTypeElement.class); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + PsiTypeElement typeElement = ObjectUtils.tryCast(element, PsiTypeElement.class); if (typeElement == null || !typeElement.acceptsAnnotations()) return; for (PsiAnnotation annotation : typeElement.getAnnotations()) { if (myAnnotationsToRemove.contains(annotation.getQualifiedName())) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java index b067ed1ed283..5639b38f047e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java @@ -258,7 +258,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect } /** - * Try convert given method of given anonymous class into lambda and replace given element. + * Try to convert given method of given anonymous class into lambda and replace given element. * * @param anonymousClass physical anonymous class containing method * @param method physical method to convert with non-empty body @@ -375,7 +375,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect return variable == null || variable instanceof PsiField; } - private static class ReplaceWithLambdaFix implements LocalQuickFix, HighPriorityAction { + private static class ReplaceWithLambdaFix extends PsiUpdateModCommandQuickFix implements HighPriorityAction { @NotNull @Override public String getFamilyName() { @@ -383,11 +383,8 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - if (element != null) { - replacePsiElementWithLambda(element, false, false); - } + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + replacePsiElementWithLambda(element, false, false); } private static void giveUniqueNames(Project project, @@ -455,7 +452,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect } public static boolean functionalInterfaceMethodReferenced(PsiMethod psiMethod, - PsiAnonymousClass anonymClass, + PsiAnonymousClass anonymousClass, PsiCallExpression callExpression) { if (psiMethod != null && !psiMethod.hasModifierProperty(PsiModifier.STATIC)) { final PsiClass containingClass = psiMethod.getContainingClass(); @@ -469,8 +466,8 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect return false; } - if (InheritanceUtil.isInheritorOrSelf(anonymClass, containingClass, true) && - !InheritanceUtil.hasEnclosingInstanceInScope(containingClass, anonymClass.getParent(), true, true)) { + if (InheritanceUtil.isInheritorOrSelf(anonymousClass, containingClass, true) && + !InheritanceUtil.hasEnclosingInstanceInScope(containingClass, anonymousClass.getParent(), true, true)) { return true; } } @@ -491,11 +488,11 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect private boolean myBodyContainsForbiddenRefs; private final PsiMethod myMethod; - private final PsiAnonymousClass myAnonymClass; + private final PsiAnonymousClass myAnonymousClass; ForbiddenRefsChecker(PsiMethod method, PsiAnonymousClass aClass) { myMethod = method; - myAnonymClass = aClass; + myAnonymousClass = aClass; } @Override @@ -505,7 +502,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect super.visitMethodCallExpression(methodCallExpression); final PsiMethod psiMethod = methodCallExpression.resolveMethod(); if (psiMethod == myMethod || - functionalInterfaceMethodReferenced(psiMethod, myAnonymClass, methodCallExpression)) { + functionalInterfaceMethodReferenced(psiMethod, myAnonymousClass, methodCallExpression)) { myBodyContainsForbiddenRefs = true; } } @@ -541,7 +538,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect super.visitReferenceExpression(expression); if (!(expression.getParent() instanceof PsiMethodCallExpression)) { - final PsiMember member = PsiTreeUtil.getParentOfType(myAnonymClass, PsiMember.class); + final PsiMember member = PsiTreeUtil.getParentOfType(myAnonymousClass, PsiMember.class); if (member instanceof PsiField || member instanceof PsiClassInitializer) { final PsiElement resolved = expression.resolve(); final PsiClass memberContainingClass = member.getContainingClass(); @@ -552,12 +549,12 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect final PsiExpression initializer = ((PsiField)resolved).getInitializer(); if (initializer == null || resolved == member || - initializer.getTextOffset() > myAnonymClass.getTextOffset() && ((PsiField)resolved).hasModifierProperty(PsiModifier.STATIC) == member.hasModifierProperty(PsiModifier.STATIC)) { + initializer.getTextOffset() > myAnonymousClass.getTextOffset() && ((PsiField)resolved).hasModifierProperty(PsiModifier.STATIC) == member.hasModifierProperty(PsiModifier.STATIC)) { myBodyContainsForbiddenRefs = true; } } } else { - final PsiMethod method = PsiTreeUtil.getParentOfType(myAnonymClass, PsiMethod.class); + final PsiMethod method = PsiTreeUtil.getParentOfType(myAnonymousClass, PsiMethod.class); if (method != null && method.isConstructor()) { final PsiElement resolved = expression.resolve(); if (resolved instanceof PsiField && @@ -568,7 +565,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect final PsiCodeBlock constructorBody = method.getBody(); if (constructorBody != null) { final ControlFlow flow = HighlightControlFlowUtil.getControlFlowNoConstantEvaluate(constructorBody); - final int startOffset = flow.getStartOffset(myAnonymClass); + final int startOffset = flow.getStartOffset(myAnonymousClass); final Collection writtenVariables = ControlFlowUtil.getWrittenVariables(flow, 0, startOffset, false); if (!writtenVariables.contains(resolved)) { myBodyContainsForbiddenRefs = true; diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java index 3e426d4b0f85..762b072034ab 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java @@ -1,4 +1,4 @@ -// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInspection; import com.intellij.java.analysis.JavaAnalysisBundle; @@ -70,7 +70,7 @@ public class AnonymousHasLambdaAlternativeInspection extends AbstractBaseJavaLoc } @Contract("null, _ -> null") - private AnonymousLambdaAlternative getAlternative(PsiClass type, PsiMethod method) { + private static AnonymousLambdaAlternative getAlternative(PsiClass type, PsiMethod method) { if(type == null) return null; for(AnonymousLambdaAlternative alternative : ALTERNATIVES) { if(alternative.myClassName.equals(type.getQualifiedName()) && alternative.myMethodName.equals(method.getName())) { @@ -82,7 +82,7 @@ public class AnonymousHasLambdaAlternativeInspection extends AbstractBaseJavaLoc }; } - static class ReplaceWithLambdaAlternativeFix implements LocalQuickFix { + static class ReplaceWithLambdaAlternativeFix extends PsiUpdateModCommandQuickFix { @SafeFieldForPreview private final @NotNull AnonymousLambdaAlternative myAlternative; @@ -105,10 +105,9 @@ public class AnonymousHasLambdaAlternativeInspection extends AbstractBaseJavaLoc } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getStartElement(); - if(!(element instanceof PsiNewExpression)) return; - PsiAnonymousClass aClass = ((PsiNewExpression)element).getAnonymousClass(); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + if(!(element instanceof PsiNewExpression newExpression)) return; + PsiAnonymousClass aClass = newExpression.getAnonymousClass(); if(aClass == null) return; PsiMethod[] methods = aClass.getMethods(); if(methods.length != 1) return; diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java index 25570149a974..524a3a299e48 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java @@ -1,4 +1,4 @@ -// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInspection; import com.intellij.java.analysis.JavaAnalysisBundle; @@ -83,7 +83,7 @@ public class BlockMarkerCommentsInspection extends AbstractBaseJavaLocalInspecti }; } - private static class DeleteBlockMarkerCommentFix implements LocalQuickFix { + private static class DeleteBlockMarkerCommentFix extends PsiUpdateModCommandQuickFix { @NotNull @Override public String getFamilyName() { @@ -91,8 +91,8 @@ public class BlockMarkerCommentsInspection extends AbstractBaseJavaLocalInspecti } @Override - public void applyFix(@NotNull final Project project, @NotNull final ProblemDescriptor descriptor) { - descriptor.getPsiElement().delete(); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + element.delete(); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/ClassGetClassInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/ClassGetClassInspection.java index c51e579dcdca..33551c9c47e0 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/ClassGetClassInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/ClassGetClassInspection.java @@ -1,4 +1,4 @@ -// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInspection; import com.intellij.java.analysis.JavaAnalysisBundle; @@ -39,7 +39,7 @@ public class ClassGetClassInspection extends AbstractBaseJavaLocalInspectionTool }; } - private static class RemoveGetClassCallFix implements LocalQuickFix { + private static class RemoveGetClassCallFix extends PsiUpdateModCommandQuickFix { @Nls(capitalization = Nls.Capitalization.Sentence) @NotNull @Override @@ -48,8 +48,8 @@ public class ClassGetClassInspection extends AbstractBaseJavaLocalInspectionTool } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(descriptor.getStartElement(), PsiMethodCallExpression.class); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class); if (call == null) return; PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); if (qualifier == null) return; @@ -57,7 +57,7 @@ public class ClassGetClassInspection extends AbstractBaseJavaLocalInspectionTool } } - private static class ReplaceWithClassClassFix implements LocalQuickFix { + private static class ReplaceWithClassClassFix extends PsiUpdateModCommandQuickFix { @Nls(capitalization = Nls.Capitalization.Sentence) @NotNull @Override @@ -66,8 +66,8 @@ public class ClassGetClassInspection extends AbstractBaseJavaLocalInspectionTool } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(descriptor.getStartElement(), PsiMethodCallExpression.class); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class); if (call == null) return; CommentTracker ct = new CommentTracker(); ct.replaceAndRestoreComments(call, "java.lang.Class.class"); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/canBeFinal/CanBeFinalInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/canBeFinal/CanBeFinalInspection.java index 13fe1114ece9..f4d2ac856883 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/canBeFinal/CanBeFinalInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/canBeFinal/CanBeFinalInspection.java @@ -173,8 +173,7 @@ public class CanBeFinalInspection extends GlobalJavaBatchInspectionTool { return SHORT_NAME; } - private static class AcceptSuggested implements LocalQuickFix { - @SafeFieldForPreview + private static class AcceptSuggested extends PsiUpdateModCommandQuickFix { private final RefManager myManager; AcceptSuggested(final RefManager manager) { @@ -188,8 +187,7 @@ public class CanBeFinalInspection extends GlobalJavaBatchInspectionTool { } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { final PsiModifierListOwner psiElement = PsiTreeUtil.getParentOfType(element, PsiModifierListOwner.class); if (psiElement != null) { RefJavaElement refElement = (RefJavaElement)(myManager != null ? myManager.getReference(psiElement) : null); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/wrongPackageStatement/AdjustPackageNameFix.java b/java/java-analysis-impl/src/com/intellij/codeInspection/wrongPackageStatement/AdjustPackageNameFix.java index 712ad8944272..b7c89e06f484 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/wrongPackageStatement/AdjustPackageNameFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/wrongPackageStatement/AdjustPackageNameFix.java @@ -2,15 +2,16 @@ package com.intellij.codeInspection.wrongPackageStatement; import com.intellij.codeInsight.daemon.QuickFixBundle; -import com.intellij.codeInsight.intention.preview.IntentionPreviewUtils; -import com.intellij.codeInspection.LocalQuickFix; +import com.intellij.codeInspection.ModCommands; import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.modcommand.ModCommand; +import com.intellij.modcommand.ModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.SingleFileSourcesTracker; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; -public class AdjustPackageNameFix implements LocalQuickFix { +public class AdjustPackageNameFix extends ModCommandQuickFix { private final String myName; public AdjustPackageNameFix(String targetPackage) { @@ -30,18 +31,21 @@ public class AdjustPackageNameFix implements LocalQuickFix { } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getPsiElement(); - if (element == null) return; + public final @NotNull ModCommand perform(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + PsiElement element = descriptor.getStartElement(); + PsiFile origFile = element.getContainingFile(); + PsiDirectory directory = origFile.getContainingDirectory(); + if (directory == null) return ModCommands.nop(); + return ModCommands.psiUpdate(element, (e, updater) -> applyFix(e, origFile, directory)); + } + + private static void applyFix(@NotNull PsiElement element, @NotNull PsiFile origFile, @NotNull PsiDirectory directory) { PsiFile file = element.getContainingFile(); - PsiFile originalFile = IntentionPreviewUtils.getOriginalFile(file); - PsiDirectory directory = originalFile != null ? originalFile.getContainingDirectory() : file.getContainingDirectory(); - if (directory == null) return; PsiPackage myTargetPackage = JavaDirectoryService.getInstance().getPackage(directory); if (myTargetPackage == null) return; String myTargetPackageName = myTargetPackage.getQualifiedName(); SingleFileSourcesTracker singleFileSourcesTracker = SingleFileSourcesTracker.getInstance(file.getProject()); - String singleFileSourcePackageName = singleFileSourcesTracker.getPackageNameForSingleFileSource(file.getVirtualFile()); + String singleFileSourcePackageName = singleFileSourcesTracker.getPackageNameForSingleFileSource(origFile.getVirtualFile()); if (singleFileSourcePackageName != null) myTargetPackageName = singleFileSourcePackageName; PsiPackageStatement statement = ((PsiJavaFile)file).getPackageStatement(); diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddParameterListFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddParameterListFix.java index 9503e734daba..4ca7ef63d45c 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddParameterListFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddParameterListFix.java @@ -2,39 +2,29 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.daemon.QuickFixBundle; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.*; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandAction; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiIdentifier; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiType; import com.intellij.psi.util.JavaPsiRecordUtil; import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public class AddParameterListFix extends LocalQuickFixAndIntentionActionOnPsiElement { +public class AddParameterListFix extends PsiUpdateModCommandAction { public AddParameterListFix(@NotNull PsiMethod method) { super(method); } @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - if (!(startElement instanceof PsiMethod method)) return; + protected void invoke(@NotNull ActionContext context, @NotNull PsiMethod method, @NotNull EditorUpdater updater) { PsiIdentifier identifier = method.getNameIdentifier(); if (identifier == null) return; - method.addAfter(JavaPsiFacade.getElementFactory(project).createParameterList(ArrayUtil.EMPTY_STRING_ARRAY, PsiType.EMPTY_ARRAY), - identifier); - } - - @Nls(capitalization = Nls.Capitalization.Sentence) - @NotNull - @Override - public String getText() { - return getFamilyName(); + method.addAfter(JavaPsiFacade.getElementFactory(context.project()) + .createParameterList(ArrayUtil.EMPTY_STRING_ARRAY, PsiType.EMPTY_ARRAY), identifier); } @Nls(capitalization = Nls.Capitalization.Sentence) @@ -45,12 +35,8 @@ public class AddParameterListFix extends LocalQuickFixAndIntentionActionOnPsiEle } @Override - public boolean isAvailable(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - return super.isAvailable(project, file, editor, startElement, endElement) && - startElement instanceof PsiMethod && JavaPsiRecordUtil.isCompactConstructor((PsiMethod)startElement); + protected @Nullable Presentation getPresentation(@NotNull ActionContext context, @NotNull PsiMethod method) { + if (!JavaPsiRecordUtil.isCompactConstructor(method)) return null; + return Presentation.of(getFamilyName()); } } diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddToPermitsListFix.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddToPermitsListFix.java index 252f12e291f9..f9593b0a2b3c 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddToPermitsListFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddToPermitsListFix.java @@ -1,99 +1,43 @@ // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInsight.intention.impl; -import com.intellij.codeInsight.daemon.impl.actions.IntentionActionWithFixAllOption; -import com.intellij.codeInsight.intention.preview.IntentionPreviewInfo; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandAction; import com.intellij.codeInspection.util.IntentionFamilyName; -import com.intellij.codeInspection.util.IntentionName; -import com.intellij.ide.highlighter.JavaFileType; import com.intellij.java.JavaBundle; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiReferenceList; import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.util.PsiTreeUtil; import com.siyeh.ig.psiutils.SealedUtils; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.Arrays; import java.util.Objects; -import static com.intellij.util.ObjectUtils.tryCast; - -public class AddToPermitsListFix extends LocalQuickFixAndIntentionActionOnPsiElement implements IntentionActionWithFixAllOption { - - private final String myParentQualifiedName; +public class AddToPermitsListFix extends PsiUpdateModCommandAction { private final String myParentName; private final String myClassName; + private final String myClassQualifiedName; public AddToPermitsListFix(@NotNull PsiClass subClass, @NotNull PsiClass superClass) { - super(subClass); - myParentQualifiedName = Objects.requireNonNull(superClass.getQualifiedName()); + super(superClass); myParentName = Objects.requireNonNull(superClass.getName()); + myClassQualifiedName = Objects.requireNonNull(subClass.getQualifiedName()); myClassName = Objects.requireNonNull(subClass.getName()); } @Override - public @Nullable PsiElement getElementToMakeWritable(@NotNull PsiFile currentFile) { - if (!(getStartElement() instanceof PsiClass aClass)) return null; - return getSealedParent(aClass); - } - - @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - PsiClass psiClass = tryCast(startElement, PsiClass.class); - if (psiClass == null) return; - String qualifiedName = psiClass.getQualifiedName(); - if (qualifiedName == null) return; - PsiClass parentClass = getSealedParent(psiClass); - if (parentClass == null) return; - SealedUtils.addClassToPermitsList(parentClass, qualifiedName); - PsiReferenceList list = parentClass.getPermitsList(); + protected void invoke(@NotNull ActionContext context, @NotNull PsiClass superClass, @NotNull EditorUpdater updater) { + SealedUtils.addClassToPermitsList(superClass, myClassQualifiedName); + PsiReferenceList list = superClass.getPermitsList(); if (list != null) { - JavaCodeStyleManager.getInstance(project).shortenClassReferences(list); + JavaCodeStyleManager.getInstance(context.project()).shortenClassReferences(list); } } @Override - public @NotNull IntentionPreviewInfo generatePreview(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { - if (!(getStartElement() instanceof PsiClass psiClass)) return IntentionPreviewInfo.EMPTY; - PsiClass parent = getSealedParent(psiClass); - if (parent == null) return IntentionPreviewInfo.EMPTY; - PsiFile sealedClassFile = parent.getContainingFile(); - if (sealedClassFile == psiClass.getContainingFile()) { - return super.generatePreview(project, editor, file); - } - String qualifiedName = psiClass.getQualifiedName(); - if (qualifiedName == null) return IntentionPreviewInfo.EMPTY; - PsiClass copy = PsiTreeUtil.findSameElementInCopy(parent, (PsiFile)sealedClassFile.copy()); - SealedUtils.addClassToPermitsList(copy, qualifiedName); - CodeStyleManager.getInstance(project).reformat(Objects.requireNonNull(copy.getPermitsList())); - return new IntentionPreviewInfo.CustomDiff(JavaFileType.INSTANCE, sealedClassFile.getName(), parent.getText(), copy.getText()); - } - - private @Nullable PsiClass getSealedParent(PsiClass psiClass) { - PsiClass parentClass = findParent(psiClass.getExtendsListTypes()); - if (parentClass == null) parentClass = findParent(psiClass.getImplementsListTypes()); - if (parentClass == null) return null; - return parentClass; - } - - private @Nullable PsiClass findParent(PsiClassType[] types) { - return Arrays.stream(types).map(t -> t.resolve()) - .filter(parent -> parent != null && myParentQualifiedName.equals(parent.getQualifiedName())) - .findFirst().orElse(null); - } - - @Override - public @IntentionName @NotNull String getText() { - return JavaBundle.message("add.to.permits.list", myClassName, myParentName); + protected @Nullable Presentation getPresentation(@NotNull ActionContext context, @NotNull PsiClass element) { + return Presentation.of(JavaBundle.message("add.to.permits.list", myClassName, myParentName)).withFixAllOption(this); } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CollapseAnnotationsFix.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CollapseAnnotationsFix.java index 01443b85c138..73f8dbc15245 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CollapseAnnotationsFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CollapseAnnotationsFix.java @@ -1,13 +1,12 @@ // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInsight.intention.impl; -import com.intellij.codeInsight.daemon.impl.actions.IntentionActionWithFixAllOption; +import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.codeInsight.intention.QuickFixFactory; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandAction; import com.intellij.java.JavaBundle; import com.intellij.java.analysis.JavaAnalysisBundle; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.util.PsiUtil; import com.intellij.util.ArrayUtil; @@ -22,25 +21,18 @@ import java.util.Collections; import java.util.List; import java.util.Objects; -public final class CollapseAnnotationsFix extends LocalQuickFixAndIntentionActionOnPsiElement implements IntentionActionWithFixAllOption { +public final class CollapseAnnotationsFix extends PsiUpdateModCommandAction { private CollapseAnnotationsFix(PsiAnnotation annotation) { super(annotation); - - } - - @NotNull - @Override - public String getText() { - return JavaBundle.message("intention.text.collapse.repeating.annotations"); } @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - if (!(startElement instanceof PsiAnnotation annotation)) return; + protected @NotNull Presentation getPresentation(@NotNull ActionContext context, @NotNull PsiAnnotation element) { + return Presentation.of(getFamilyName()).withFixAllOption(this); + } + + @Override + protected void invoke(@NotNull ActionContext context, @NotNull PsiAnnotation annotation, @NotNull EditorUpdater updater) { PsiNameValuePair attribute = ArrayUtil.getFirstElement(annotation.getParameterList().getAttributes()); if (attribute == null) return; PsiAnnotationMemberValue origValue = attribute.getValue(); @@ -64,7 +56,8 @@ public final class CollapseAnnotationsFix extends LocalQuickFixAndIntentionActio } } String newValue = StreamEx.of(values).map(PsiElement::getText).joining(", ", "{", "}"); - PsiAnnotation dummy = JavaPsiFacade.getElementFactory(project).createAnnotationFromText("@x(" + newValue + ")", origValue); + PsiAnnotation dummy = JavaPsiFacade.getElementFactory(context.project()) + .createAnnotationFromText("@x(" + newValue + ")", origValue); ct.replaceAndRestoreComments(origValue, Objects.requireNonNull(dummy.getParameterList().getAttributes()[0].getValue())); } @@ -72,7 +65,7 @@ public final class CollapseAnnotationsFix extends LocalQuickFixAndIntentionActio @NotNull @Override public String getFamilyName() { - return getText(); + return JavaBundle.message("intention.text.collapse.repeating.annotations"); } private static List findCollapsibleAnnotations(PsiAnnotation annotation, PsiNameValuePair attribute) { @@ -97,7 +90,7 @@ public final class CollapseAnnotationsFix extends LocalQuickFixAndIntentionActio } @Nullable - public static LocalQuickFixAndIntentionActionOnPsiElement from(PsiAnnotation annotation) { + public static IntentionAction from(PsiAnnotation annotation) { PsiAnnotationOwner owner = annotation.getOwner(); String name = annotation.getQualifiedName(); if (owner == null || name == null) return null; @@ -112,7 +105,7 @@ public final class CollapseAnnotationsFix extends LocalQuickFixAndIntentionActio if (annoMethod == null || !(annoMethod.getReturnType() instanceof PsiArrayType)) return null; List annotations = findCollapsibleAnnotations(annotation, attribute); if (annotations.size() < 2) return null; - return new CollapseAnnotationsFix(annotation); + return new CollapseAnnotationsFix(annotation).asIntention(); } @Nullable diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java index 133e99b2cf0e..abe0ffe960bc 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java @@ -1007,7 +1007,7 @@ public final class QuickFixFactoryImpl extends QuickFixFactory { @NotNull @Override public IntentionAction createAddParameterListFix(@NotNull PsiMethod method) { - return new AddParameterListFix(method); + return new AddParameterListFix(method).asIntention(); } @NotNull @@ -1034,7 +1034,7 @@ public final class QuickFixFactoryImpl extends QuickFixFactory { @Override public @NotNull IntentionAction createAddToPermitsListFix(@NotNull PsiClass subClass, @NotNull PsiClass superClass) { - return new AddToPermitsListFix(subClass, superClass); + return new AddToPermitsListFix(subClass, superClass).asIntention(); } @Override diff --git a/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeMethodReferenceInspection.java b/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeMethodReferenceInspection.java index 1d427b755bb2..ffc5cd25c73b 100644 --- a/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeMethodReferenceInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeMethodReferenceInspection.java @@ -100,35 +100,35 @@ public class AnonymousCanBeMethodReferenceInspection extends AbstractBaseJavaLoc }; } - private static class ReplaceWithMethodRefFix implements LocalQuickFix { - @NotNull - @Override - public String getFamilyName() { - return JavaBundle.message("quickfix.family.replace.with.method.reference"); - } + private static class ReplaceWithMethodRefFix extends PsiUpdateModCommandQuickFix { + @NotNull + @Override + public String getFamilyName() { + return JavaBundle.message("quickfix.family.replace.with.method.reference"); + } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - if (element instanceof PsiNewExpression) { - final PsiAnonymousClass anonymousClass = ((PsiNewExpression)element).getAnonymousClass(); - if (anonymousClass == null) return; - final PsiMethod[] methods = anonymousClass.getMethods(); - if (methods.length != 1) return; + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + if (element instanceof PsiNewExpression newExpression) { + final PsiAnonymousClass anonymousClass = newExpression.getAnonymousClass(); + if (anonymousClass == null) return; + final PsiMethod[] methods = anonymousClass.getMethods(); + if (methods.length != 1) return; - final PsiParameter[] parameters = methods[0].getParameterList().getParameters(); - final PsiType functionalInterfaceType = anonymousClass.getBaseClassType(); - MethodReferenceCandidate methodRefCandidate = - LambdaCanBeMethodReferenceInspection.extractMethodReferenceCandidateExpression(methods[0].getBody()); - if (methodRefCandidate == null) return; - final PsiExpression candidate = LambdaCanBeMethodReferenceInspection - .canBeMethodReferenceProblem(parameters, functionalInterfaceType, anonymousClass.getParent(), methodRefCandidate.myExpression); + final PsiParameter[] parameters = methods[0].getParameterList().getParameters(); + final PsiType functionalInterfaceType = anonymousClass.getBaseClassType(); + MethodReferenceCandidate methodRefCandidate = + LambdaCanBeMethodReferenceInspection.extractMethodReferenceCandidateExpression(methods[0].getBody()); + if (methodRefCandidate == null) return; + final PsiExpression candidate = LambdaCanBeMethodReferenceInspection + .canBeMethodReferenceProblem(parameters, functionalInterfaceType, anonymousClass.getParent(), methodRefCandidate.myExpression); - final String methodRefText = LambdaCanBeMethodReferenceInspection.createMethodReferenceText(candidate, functionalInterfaceType, parameters); + final String methodRefText = + LambdaCanBeMethodReferenceInspection.createMethodReferenceText(candidate, functionalInterfaceType, parameters); - replaceWithMethodReference(project, methodRefText, anonymousClass.getBaseClassType(), anonymousClass.getParent()); - } + replaceWithMethodReference(project, methodRefText, anonymousClass.getBaseClassType(), anonymousClass.getParent()); } + } } static void replaceWithMethodReference(@NotNull Project project, diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/BoxPrimitiveInTernaryFix.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/BoxPrimitiveInTernaryFix.java index 1ba43f4acc29..3b4012d62011 100644 --- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/BoxPrimitiveInTernaryFix.java +++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/BoxPrimitiveInTernaryFix.java @@ -1,9 +1,8 @@ // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInspection.dataFlow.fix; -import com.intellij.codeInsight.intention.FileModifier; -import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandQuickFix; import com.intellij.java.JavaBundle; import com.intellij.openapi.project.Project; import com.intellij.psi.*; @@ -17,19 +16,13 @@ import org.jetbrains.annotations.Nullable; import java.util.Objects; -public class BoxPrimitiveInTernaryFix implements LocalQuickFix { +public class BoxPrimitiveInTernaryFix extends PsiUpdateModCommandQuickFix { private final SmartPsiElementPointer myPointer; private BoxPrimitiveInTernaryFix(PsiExpression expression) { myPointer = SmartPointerManager.createPointer(expression); } - @Override - public @Nullable FileModifier getFileModifierForPreview(@NotNull PsiFile target) { - PsiExpression expression = myPointer.getElement(); - return expression == null ? null : new BoxPrimitiveInTernaryFix(PsiTreeUtil.findSameElementInCopy(expression, target)); - } - public static @Nullable BoxPrimitiveInTernaryFix makeFix(@Nullable PsiExpression npeExpression) { if (npeExpression == null) return null; PsiConditionalExpression parentConditional = getParentConditional(npeExpression); @@ -70,9 +63,10 @@ public class BoxPrimitiveInTernaryFix implements LocalQuickFix { } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { PsiExpression expression = myPointer.getElement(); if (expression == null) return; + expression = updater.getWritable(expression); PsiConditionalExpression conditional = getParentConditional(expression); if (conditional == null) return; PsiExpression thenExpression = conditional.getThenExpression(); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/impl/quickfix/AddToPermitsListTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/impl/quickfix/AddToPermitsListTest.java index 1bc9126154c0..acd46807c288 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/impl/quickfix/AddToPermitsListTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/impl/quickfix/AddToPermitsListTest.java @@ -2,6 +2,7 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.application.impl.NonBlockingReadActionImpl; import com.intellij.psi.PsiClass; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase; @@ -22,7 +23,9 @@ public class AddToPermitsListTest extends LightJavaCodeInsightFixtureTestCase { public void testNoPermitsListSameFileInheritors() { PsiClass aClass = myFixture.addClass("sealed class A {} record A1() extends A{} record A2() extends A{}"); myFixture.configureByText("B.java", "final class B extends A {}"); - checkPreviewAndInvoke(aClass, "Add 'B' to permits list of sealed class 'A'", "sealed class A permits A1, A2, B {}"); + checkPreviewAndInvoke(aClass, "Add 'B' to permits list of sealed class 'A'", + "sealed class A permits A1, A2, B {} record A1() extends A{} record A2() extends A{}", + "sealed class A permits A1, A2, B {}"); } public void testUnorderedPermitsList() { @@ -48,10 +51,15 @@ public class AddToPermitsListTest extends LightJavaCodeInsightFixtureTestCase { } private void checkPreviewAndInvoke(PsiClass aClass, String hint, String expectedText) { + checkPreviewAndInvoke(aClass, hint, expectedText, expectedText); + } + + private void checkPreviewAndInvoke(PsiClass aClass, String hint, String expectedPreview, String expectedClass) { IntentionAction intention = myFixture.findSingleIntention(hint); String previewText = myFixture.getIntentionPreviewText(intention); - assertEquals(expectedText, previewText); + assertEquals(expectedPreview, previewText); myFixture.launchAction(intention); - assertEquals(expectedText, aClass.getText()); + NonBlockingReadActionImpl.waitForAsyncTaskCompletion(); + assertEquals(expectedClass, aClass.getText()); } } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInspection/BlockMarkerCommentsTest.java b/java/java-tests/testSrc/com/intellij/java/codeInspection/BlockMarkerCommentsTest.java index 473d611a7377..9c1f98637233 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInspection/BlockMarkerCommentsTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInspection/BlockMarkerCommentsTest.java @@ -1,9 +1,10 @@ -// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.java.codeInspection; import com.intellij.JavaTestUtil; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.codeInspection.BlockMarkerCommentsInspection; +import com.intellij.openapi.application.impl.NonBlockingReadActionImpl; import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase; /** @@ -50,6 +51,7 @@ public class BlockMarkerCommentsTest extends LightJavaCodeInsightFixtureTestCase final IntentionAction intentionAction = myFixture.findSingleIntention("Remove block marker comment"); assertNotNull(intentionAction); myFixture.launchAction(intentionAction); + NonBlockingReadActionImpl.waitForAsyncTaskCompletion(); myFixture.checkResultByFile(testFileName + "_after.java", true); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInspection/NullableStuffInspectionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInspection/NullableStuffInspectionTest.java index 5b3abd1781fe..4c3d24ab7cc4 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInspection/NullableStuffInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInspection/NullableStuffInspectionTest.java @@ -5,6 +5,7 @@ package com.intellij.java.codeInspection; import com.intellij.JavaTestUtil; import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInspection.nullable.NullableStuffInspection; +import com.intellij.openapi.application.impl.NonBlockingReadActionImpl; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.GeneratedSourcesFilter; import com.intellij.openapi.util.Disposer; @@ -48,6 +49,7 @@ public class NullableStuffInspectionTest extends LightJavaCodeInsightFixtureTest private void doTestWithFix(String intentionAction) { doTest(); myFixture.launchAction(myFixture.findSingleIntention(intentionAction)); + NonBlockingReadActionImpl.waitForAsyncTaskCompletion(); myFixture.checkResultByFile(getTestName(false) + "_after.java"); } diff --git a/java/manifest/resources/messages/ManifestBundle.properties b/java/manifest/resources/messages/ManifestBundle.properties index 126191de8394..7160c01dd1c2 100644 --- a/java/manifest/resources/messages/ManifestBundle.properties +++ b/java/manifest/resources/messages/ManifestBundle.properties @@ -13,6 +13,7 @@ inspection.newline.message=Manifest file doesn't end with a final newline inspection.newline.fix=Add newline inspection.header.message=Header name is unknown or spelled incorrectly inspection.header.ui.label=Custom headers: +inspection.header.rename.fix.family.name=Fix header name inspection.header.rename.fix=Change to ''{0}'' inspection.header.remember.fix=Add ''{0}'' to custom headers filetype.manifest.description=Manifest diff --git a/java/manifest/src/org/jetbrains/lang/manifest/highlighting/MisspelledHeaderInspection.java b/java/manifest/src/org/jetbrains/lang/manifest/highlighting/MisspelledHeaderInspection.java index a7f9db55ceae..14e5c2f8b26d 100644 --- a/java/manifest/src/org/jetbrains/lang/manifest/highlighting/MisspelledHeaderInspection.java +++ b/java/manifest/src/org/jetbrains/lang/manifest/highlighting/MisspelledHeaderInspection.java @@ -82,7 +82,7 @@ public final class MisspelledHeaderInspection extends LocalInspectionTool { List fixes = new ArrayList<>(); for (Suggestion match : matches) { - fixes.add(new HeaderRenameQuickFix(header, match.getWord())); + fixes.add(new HeaderRenameQuickFix(header, match.getWord()).asQuickFix()); if (fixes.size() == MAX_SUGGESTIONS) break; } if (bestMatch == null || bestMatch.getMetrics() > TYPO_DISTANCE) { @@ -111,7 +111,7 @@ public final class MisspelledHeaderInspection extends LocalInspectionTool { return pane(OptPane.stringList("CUSTOM_HEADERS", ManifestBundle.message("inspection.header.ui.label"))); } - private static final class HeaderRenameQuickFix extends AbstractManifestQuickFix { + private static final class HeaderRenameQuickFix extends PsiUpdateModCommandAction
{ private final String myNewName; private HeaderRenameQuickFix(Header header, String newName) { @@ -121,13 +121,18 @@ public final class MisspelledHeaderInspection extends LocalInspectionTool { @NotNull @Override - public String getText() { - return ManifestBundle.message("inspection.header.rename.fix", myNewName); + public String getFamilyName() { + return ManifestBundle.message("inspection.header.rename.fix.family.name"); } @Override - public void invoke(@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { - ((Header)startElement).setName(myNewName); + protected @NotNull Presentation getPresentation(@NotNull ActionContext context, @NotNull Header element) { + return Presentation.of(ManifestBundle.message("inspection.header.rename.fix", myNewName)); + } + + @Override + protected void invoke(@NotNull ActionContext context, @NotNull Header header, @NotNull EditorUpdater updater) { + header.setName(myNewName); } } diff --git a/java/manifest/test/org/jetbrains/lang/manifest/MisspelledHeaderInspectionTest.java b/java/manifest/test/org/jetbrains/lang/manifest/MisspelledHeaderInspectionTest.java index 7c9c1ab87523..bb3aa05a9a9e 100644 --- a/java/manifest/test/org/jetbrains/lang/manifest/MisspelledHeaderInspectionTest.java +++ b/java/manifest/test/org/jetbrains/lang/manifest/MisspelledHeaderInspectionTest.java @@ -1,21 +1,8 @@ -/* - * Copyright 2000-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package org.jetbrains.lang.manifest; import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.application.impl.NonBlockingReadActionImpl; import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase; import org.jetbrains.lang.manifest.highlighting.MisspelledHeaderInspection; @@ -48,7 +35,8 @@ public class MisspelledHeaderInspectionTest extends LightJavaCodeInsightFixtureT myFixture.configureByText(ManifestFileType.INSTANCE, "ManifestVersion: 1.0\n"); List intentions = myFixture.filterAvailableIntentions("Change to"); assertEquals(1, intentions.size()); - myFixture.launchAction(intentions.get(0)); + myFixture.checkPreviewAndLaunchAction(intentions.get(0)); + NonBlockingReadActionImpl.waitForAsyncTaskCompletion(); myFixture.checkResult("Manifest-Version: 1.0\n"); } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/ReflectionForUnavailableAnnotationInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/ReflectionForUnavailableAnnotationInspection.java index 140abcbc7c9c..e6ed4bf83104 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/ReflectionForUnavailableAnnotationInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/ReflectionForUnavailableAnnotationInspection.java @@ -50,10 +50,8 @@ public class ReflectionForUnavailableAnnotationInspection extends BaseInspection else if (infos.length == 2) { PsiAnnotation retentionAnnotation = (PsiAnnotation)infos[1]; String text = getText((PsiClass)infos[0]); - return new ChangeAnnotationParameterQuickFix(retentionAnnotation, PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME, runtimeRef) { - @Override - public @NotNull String getText() { return text; } - }; + return new ChangeAnnotationParameterQuickFix(retentionAnnotation, PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME, runtimeRef, text) + .asQuickFix(); } assert false; return null; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/fixes/ChangeAnnotationParameterQuickFix.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/fixes/ChangeAnnotationParameterQuickFix.java index 3dc2624b6209..30803bbb76de 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/fixes/ChangeAnnotationParameterQuickFix.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/fixes/ChangeAnnotationParameterQuickFix.java @@ -1,12 +1,14 @@ -// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.siyeh.ig.fixes; import com.intellij.codeInsight.AnnotationUtil; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.codeInspection.EditorUpdater; +import com.intellij.codeInspection.PsiUpdateModCommandAction; import com.intellij.codeInspection.util.IntentionName; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.*; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiElementFactory; +import com.intellij.psi.PsiNameValuePair; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.psiutils.CommentTracker; import org.jetbrains.annotations.NotNull; @@ -15,42 +17,37 @@ import org.jetbrains.annotations.Nullable; /** * @author Plushnikov Michail */ -public class ChangeAnnotationParameterQuickFix extends LocalQuickFixAndIntentionActionOnPsiElement { +public class ChangeAnnotationParameterQuickFix extends PsiUpdateModCommandAction { private final String myName; private final String myNewValue; + @IntentionName private final String myMessage; - public ChangeAnnotationParameterQuickFix(@NotNull PsiAnnotation annotation, @NotNull String name, @Nullable String newValue) { + public ChangeAnnotationParameterQuickFix(@NotNull PsiAnnotation annotation, @NotNull String name, @Nullable String newValue, + @IntentionName @NotNull String message) { super(annotation); myName = name; myNewValue = newValue; + myMessage = message; } - @Override - @NotNull - @IntentionName - public String getText() { - if (myNewValue == null) { - return InspectionGadgetsBundle.message("remove.annotation.parameter.0.fix.name", myName); - } - return InspectionGadgetsBundle.message("set.annotation.parameter.0.1.fix.name", myName, myNewValue); + public ChangeAnnotationParameterQuickFix(@NotNull PsiAnnotation annotation, @NotNull String name, @Nullable String newValue) { + this(annotation, name, newValue, + newValue == null + ? InspectionGadgetsBundle.message("remove.annotation.parameter.0.fix.name", name) + : InspectionGadgetsBundle.message("set.annotation.parameter.0.1.fix.name", name, newValue)); } @Override @NotNull public String getFamilyName() { - return getText(); + return myMessage; } @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - final PsiAnnotation annotation = (PsiAnnotation)startElement; + protected void invoke(@NotNull ActionContext context, @NotNull PsiAnnotation annotation, @NotNull EditorUpdater updater) { final PsiNameValuePair attribute = AnnotationUtil.findDeclaredAttribute(annotation, myName); if (myNewValue != null) { - final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); + final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(context.project()); final PsiAnnotation dummyAnnotation = elementFactory.createAnnotationFromText("@A" + "(" + myName + "=" + myNewValue + ")", null); annotation.setDeclaredAttributeValue(myName, dummyAnnotation.getParameterList().getAttributes()[0].getValue()); } diff --git a/plugins/InspectionGadgets/src/com/intellij/codeInspection/redundantCast/CastCanBeRemovedNarrowingVariableTypeInspection.java b/plugins/InspectionGadgets/src/com/intellij/codeInspection/redundantCast/CastCanBeRemovedNarrowingVariableTypeInspection.java index c4e5d15a1ec9..08d62f0ecce0 100644 --- a/plugins/InspectionGadgets/src/com/intellij/codeInspection/redundantCast/CastCanBeRemovedNarrowingVariableTypeInspection.java +++ b/plugins/InspectionGadgets/src/com/intellij/codeInspection/redundantCast/CastCanBeRemovedNarrowingVariableTypeInspection.java @@ -1,12 +1,13 @@ -// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.codeInspection.redundantCast; import com.intellij.codeInsight.daemon.impl.analysis.JavaGenericsUtil; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; -import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.codeInspection.EditorUpdater; import com.intellij.codeInspection.ProblemsHolder; +import com.intellij.codeInspection.PsiUpdateModCommandQuickFix; import com.intellij.java.JavaBundle; -import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.editor.colors.EditorColors; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; @@ -15,10 +16,8 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.RedundantCastUtil; import com.intellij.psi.util.TypeConversionUtil; -import com.siyeh.ig.psiutils.HighlightUtils; import com.siyeh.ig.psiutils.VariableAccessUtils; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import static com.intellij.util.ObjectUtils.tryCast; @@ -70,7 +69,7 @@ public class CastCanBeRemovedNarrowingVariableTypeInspection extends AbstractBas } String message = JavaBundle .message("inspection.cast.can.be.removed.narrowing.variable.type.message", variable.getName(), castType.getPresentableText()); - holder.registerProblem(castTypeElement, message, new CastCanBeRemovedNarrowingVariableTypeFix(castTypeElement, variable, castType, isOnTheFly)); + holder.registerProblem(castTypeElement, message, new CastCanBeRemovedNarrowingVariableTypeFix(variable, castType, isOnTheFly)); } }; } @@ -130,20 +129,19 @@ public class CastCanBeRemovedNarrowingVariableTypeInspection extends AbstractBas return true; } - private static class CastCanBeRemovedNarrowingVariableTypeFix extends LocalQuickFixAndIntentionActionOnPsiElement { + private static class CastCanBeRemovedNarrowingVariableTypeFix extends PsiUpdateModCommandQuickFix { private final String myVariableName; private final String myType; private final boolean myOnTheFly; - CastCanBeRemovedNarrowingVariableTypeFix(PsiTypeElement castTypeElement, PsiVariable variable, PsiType type, boolean onTheFly) { - super(castTypeElement); + CastCanBeRemovedNarrowingVariableTypeFix(@NotNull PsiVariable variable, @NotNull PsiType type, boolean onTheFly) { myVariableName = variable.getName(); myType = type.getPresentableText(); myOnTheFly = onTheFly; } @Override - public @NotNull String getText() { + public @NotNull String getName() { return JavaBundle.message("inspection.cast.can.be.removed.narrowing.variable.type.fix.name", myVariableName, myType); } @@ -154,12 +152,8 @@ public class CastCanBeRemovedNarrowingVariableTypeInspection extends AbstractBas } @Override - public void invoke(@NotNull Project project, - @NotNull PsiFile file, - @Nullable Editor editor, - @NotNull PsiElement startElement, - @NotNull PsiElement endElement) { - PsiTypeCastExpression cast = PsiTreeUtil.getParentOfType(startElement, PsiTypeCastExpression.class); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + PsiTypeCastExpression cast = PsiTreeUtil.getParentOfType(element, PsiTypeCastExpression.class); if (cast == null) return; PsiReferenceExpression ref = tryCast(PsiUtil.skipParenthesizedExprDown(cast.getOperand()), PsiReferenceExpression.class); if (ref == null) return; @@ -180,8 +174,8 @@ public class CastCanBeRemovedNarrowingVariableTypeInspection extends AbstractBas } } } - if (myOnTheFly && editor != null) { - HighlightUtils.highlightElement(newTypeElement, editor); + if (myOnTheFly) { + updater.highlight(newTypeElement, EditorColors.SEARCH_RESULT_ATTRIBUTES); } } } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/cloneable/CloneableImplementsCloneInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/cloneable/CloneableImplementsCloneInspection.java index fa3f0cf2ee3e..0a6fdf868621 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/cloneable/CloneableImplementsCloneInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/cloneable/CloneableImplementsCloneInspection.java @@ -16,12 +16,11 @@ package com.siyeh.ig.cloneable; import com.intellij.codeInsight.generation.GenerateMembersUtil; +import com.intellij.codeInspection.EditorUpdater; import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.codeInspection.ProblemHighlightType; +import com.intellij.codeInspection.PsiUpdateModCommandQuickFix; import com.intellij.codeInspection.options.OptPane; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.fileEditor.FileEditorManager; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleSettings; @@ -31,7 +30,6 @@ import com.siyeh.HardcodedMethodConstants; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.fixes.RemoveCloneableFix; import com.siyeh.ig.psiutils.CloneUtils; import com.siyeh.ig.psiutils.MethodUtils; @@ -105,7 +103,7 @@ public class CloneableImplementsCloneInspection extends BaseInspection { return fixes.toArray(LocalQuickFix.EMPTY_ARRAY); } - private static class CreateCloneMethodFix extends InspectionGadgetsFix { + private static class CreateCloneMethodFix extends PsiUpdateModCommandQuickFix { private final boolean myGenerateTryCatch; @@ -120,8 +118,7 @@ public class CloneableImplementsCloneInspection extends BaseInspection { } @Override - protected void doFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { final PsiElement parent = element.getParent(); if (!(parent instanceof PsiClass aClass)) { return; @@ -162,12 +159,7 @@ public class CloneableImplementsCloneInspection extends BaseInspection { methodText.append("}"); final PsiMethod method = JavaPsiFacade.getElementFactory(project).createMethodFromText(methodText.toString(), element); final PsiElement newElement = parent.add(method); - if (isOnTheFly() && newElement.isPhysical()) { - final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); - if (editor != null) { - GenerateMembersUtil.positionCaret(editor, newElement, true); - } - } + GenerateMembersUtil.positionCaret(updater, newElement, true); } } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/errorhandling/CatchMayIgnoreExceptionInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/errorhandling/CatchMayIgnoreExceptionInspection.java index 99c60b892439..284f859011da 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/errorhandling/CatchMayIgnoreExceptionInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/errorhandling/CatchMayIgnoreExceptionInspection.java @@ -1,12 +1,9 @@ -// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.siyeh.ig.errorhandling; import com.intellij.codeInsight.Nullability; import com.intellij.codeInsight.intention.LowPriorityAction; -import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; -import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemDescriptor; -import com.intellij.codeInspection.ProblemsHolder; +import com.intellij.codeInspection.*; import com.intellij.codeInspection.dataFlow.interpreter.RunnerResult; import com.intellij.codeInspection.dataFlow.interpreter.StandardDataFlowInterpreter; import com.intellij.codeInspection.dataFlow.java.ControlFlowAnalyzer; @@ -158,7 +155,7 @@ public class CatchMayIgnoreExceptionInspection extends AbstractBaseJavaLocalInsp * @param block a catch block body * @return class name of important VM exception (like NullPointerException) if given catch block may ignore it */ - private @Nullable String mayIgnoreVMException(PsiParameter parameter, PsiCodeBlock block) { + private static @Nullable String mayIgnoreVMException(PsiParameter parameter, PsiCodeBlock block) { PsiType type = parameter.getType(); if (!type.equalsToText(CommonClassNames.JAVA_LANG_THROWABLE) && !type.equalsToText(CommonClassNames.JAVA_LANG_EXCEPTION) && @@ -268,7 +265,7 @@ public class CatchMayIgnoreExceptionInspection extends AbstractBaseJavaLocalInsp return new VariableNameGenerator(block, VariableKind.LOCAL_VARIABLE).byName(IGNORED_PARAMETER_NAME).generate(true); } - private static class AddCatchBodyFix implements LocalQuickFix, LowPriorityAction { + private static class AddCatchBodyFix extends PsiUpdateModCommandQuickFix implements LowPriorityAction { @Nls(capitalization = Nls.Capitalization.Sentence) @Override @NotNull @@ -277,8 +274,8 @@ public class CatchMayIgnoreExceptionInspection extends AbstractBaseJavaLocalInsp } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - PsiCatchSection catchSection = ObjectUtils.tryCast(descriptor.getPsiElement().getParent(), PsiCatchSection.class); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + PsiCatchSection catchSection = ObjectUtils.tryCast(element.getParent(), PsiCatchSection.class); if (catchSection == null) return; PsiParameter parameter = catchSection.getParameter(); if (parameter == null) return; @@ -307,7 +304,7 @@ public class CatchMayIgnoreExceptionInspection extends AbstractBaseJavaLocalInsp } } - private static final class RenameCatchParameterFix implements LocalQuickFix { + private static final class RenameCatchParameterFix extends PsiUpdateModCommandQuickFix { private final String myName; private RenameCatchParameterFix(String name) { @@ -328,8 +325,7 @@ public class CatchMayIgnoreExceptionInspection extends AbstractBaseJavaLocalInsp } @Override - public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { final PsiElement parent = element.getParent(); if (!(parent instanceof PsiCatchSection catchSection)) return; final PsiParameter parameter = catchSection.getParameter(); diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/security/CloneableClassInSecureContextInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/security/CloneableClassInSecureContextInspection.java index 2cd847e65d91..fcd5d25a0b1e 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/security/CloneableClassInSecureContextInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/security/CloneableClassInSecureContextInspection.java @@ -16,10 +16,9 @@ package com.siyeh.ig.security; import com.intellij.codeInsight.generation.GenerateMembersUtil; +import com.intellij.codeInspection.EditorUpdater; import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemDescriptor; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.fileEditor.FileEditorManager; +import com.intellij.codeInspection.PsiUpdateModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleSettings; @@ -29,7 +28,6 @@ import com.intellij.util.containers.ContainerUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.fixes.RemoveCloneableFix; import com.siyeh.ig.psiutils.CloneUtils; import com.siyeh.ig.psiutils.ControlFlowUtils; @@ -76,7 +74,7 @@ public class CloneableClassInSecureContextInspection extends BaseInspection { return new CreateExceptionCloneMethodFix(); } - private static class CreateExceptionCloneMethodFix extends InspectionGadgetsFix { + private static class CreateExceptionCloneMethodFix extends PsiUpdateModCommandQuickFix { @NotNull @Override @@ -85,9 +83,8 @@ public class CloneableClassInSecureContextInspection extends BaseInspection { } @Override - protected void doFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement().getParent(); - if (!(element instanceof PsiClass aClass)) { + protected void applyFix(@NotNull Project project, @NotNull PsiElement element, @NotNull EditorUpdater updater) { + if (!(element.getParent() instanceof PsiClass aClass)) { return; } @NonNls final StringBuilder methodText = new StringBuilder(); @@ -146,12 +143,7 @@ public class CloneableClassInSecureContextInspection extends BaseInspection { for (PsiMethodCallExpression cloneCall : collectCallsToClone(aClass)) { cloneCall.replace(superCloneCall); } - if (isOnTheFly() && method.isPhysical()) { - final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); - if (editor != null) { - GenerateMembersUtil.positionCaret(editor, method, true); - } - } + GenerateMembersUtil.positionCaret(updater, method, true); } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/quickfix/PsiQuickFixFactory.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/quickfix/PsiQuickFixFactory.java index f7af2f9053db..1f8101c0598e 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/quickfix/PsiQuickFixFactory.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/quickfix/PsiQuickFixFactory.java @@ -30,6 +30,6 @@ public final class PsiQuickFixFactory { } public static LocalQuickFix createChangeAnnotationParameterFix(@NotNull PsiAnnotation psiAnnotation, @NotNull String name, @Nullable String newValue) { - return new ChangeAnnotationParameterQuickFix(psiAnnotation, name, newValue); + return new ChangeAnnotationParameterQuickFix(psiAnnotation, name, newValue).asQuickFix(); } }