diff --git a/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInspection/AbstractBaseJavaLocalInspectionTool.java b/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInspection/AbstractBaseJavaLocalInspectionTool.java index 0fe34042c9..d6b01df661 100644 --- a/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInspection/AbstractBaseJavaLocalInspectionTool.java +++ b/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInspection/AbstractBaseJavaLocalInspectionTool.java @@ -37,151 +37,155 @@ import jakarta.annotation.Nullable; public abstract class AbstractBaseJavaLocalInspectionTool extends LocalInspectionTool implements OldStyleInspection { - /** - * Override this to report problems at method level. - * - * @param method to check. - * @param manager InspectionManager to ask for ProblemDescriptors from. - * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. - * @param state - * @return null if no problems found or not applicable at method level. - */ - @Nullable - public ProblemDescriptor[] checkMethod(@Nonnull PsiMethod method, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { - return null; - } - - /** - * Override this to report problems at class level. - * - * @param aClass to check. - * @param manager InspectionManager to ask for ProblemDescriptors from. - * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. - * @param state - * @return null if no problems found or not applicable at class level. - */ - @Nullable - public ProblemDescriptor[] checkClass(@Nonnull PsiClass aClass, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { - return null; - } - - /** - * Override this to report problems at field level. - * - * @param field to check. - * @param manager InspectionManager to ask for ProblemDescriptors from. - * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. - * @param state - * @return null if no problems found or not applicable at field level. - */ - @Nullable - public ProblemDescriptor[] checkField(@Nonnull PsiField field, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { - return null; - } - - @Override - @Nullable - public final ProblemDescriptor[] checkFile(@Nonnull PsiFile file, @Nonnull InspectionManager manager, boolean isOnTheFly) { - return null; - } - - /** - * Override this to report problems at file level. - * - * @param file to check. - * @param manager InspectionManager to ask for ProblemDescriptors from. - * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. - * @return null if no problems found or not applicable at file level. - */ - @Nullable - public ProblemDescriptor[] checkFile(@Nonnull PsiFile file, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { - return null; - } - - @Nonnull - @Override - @SuppressWarnings("unchecked") - public InspectionToolState createStateProvider() { - return (InspectionToolState)super.createStateProvider(); - } - - @Nonnull - @Override - public final PsiElementVisitor buildVisitor(@Nonnull ProblemsHolder holder, boolean isOnTheFly) { - return super.buildVisitor(holder, isOnTheFly); - } - - @Nonnull - @Override - @SuppressWarnings("unchecked") - public final PsiElementVisitor buildVisitor(@Nonnull ProblemsHolder holder, - boolean isOnTheFly, - @Nonnull LocalInspectionToolSession session, - @Nonnull Object state) { - return buildVisitorImpl(holder, isOnTheFly, session, (State)state); - } - - @Nonnull - public PsiElementVisitor buildVisitorImpl(@Nonnull final ProblemsHolder holder, - final boolean isOnTheFly, - LocalInspectionToolSession session, - State state) { - return new JavaElementVisitor() { - @Override - public void visitMethod(PsiMethod method) { - addDescriptors(checkMethod(method, holder.getManager(), isOnTheFly, state)); - } - - @Override - public void visitClass(PsiClass aClass) { - addDescriptors(checkClass(aClass, holder.getManager(), isOnTheFly, state)); - } - - @Override - public void visitField(PsiField field) { - addDescriptors(checkField(field, holder.getManager(), isOnTheFly, state)); - } - - @Override - public void visitFile(PsiFile file) { - addDescriptors(checkFile(file, holder.getManager(), isOnTheFly, state)); - } - - private void addDescriptors(final ProblemDescriptor[] descriptors) { - if (descriptors != null) { - for (ProblemDescriptor descriptor : descriptors) { - holder.registerProblem(descriptor); - } - } - } - }; - } - - @Override - public PsiNamedElement getProblemElement(final PsiElement psiElement) { - return PsiTreeUtil.getNonStrictParentOfType(psiElement, PsiFile.class, PsiClass.class, PsiMethod.class, PsiField.class); - } - - @Override - public boolean isEnabledByDefault() { - return false; - } - - @Nullable - @Override - public Language getLanguage() { - return JavaLanguage.INSTANCE; - } - - @Nonnull - @Override - public LocalizeValue getGroupDisplayName() { - return InspectionLocalize.inspectionGeneralToolsGroupName(); - } - - @Nonnull - @Override - public HighlightDisplayLevel getDefaultLevel() { - return HighlightDisplayLevel.WARNING; - } + /** + * Override this to report problems at method level. + * + * @param method to check. + * @param manager InspectionManager to ask for ProblemDescriptors from. + * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. + * @param state + * @return null if no problems found or not applicable at method level. + */ + @Nullable + public ProblemDescriptor[] checkMethod(@Nonnull PsiMethod method, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { + return null; + } + + /** + * Override this to report problems at class level. + * + * @param aClass to check. + * @param manager InspectionManager to ask for ProblemDescriptors from. + * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. + * @param state + * @return null if no problems found or not applicable at class level. + */ + @Nullable + public ProblemDescriptor[] checkClass(@Nonnull PsiClass aClass, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { + return null; + } + + /** + * Override this to report problems at field level. + * + * @param field to check. + * @param manager InspectionManager to ask for ProblemDescriptors from. + * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. + * @param state + * @return null if no problems found or not applicable at field level. + */ + @Nullable + public ProblemDescriptor[] checkField(@Nonnull PsiField field, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { + return null; + } + + @Override + @Nullable + public final ProblemDescriptor[] checkFile(@Nonnull PsiFile file, @Nonnull InspectionManager manager, boolean isOnTheFly) { + return null; + } + + /** + * Override this to report problems at file level. + * + * @param file to check. + * @param manager InspectionManager to ask for ProblemDescriptors from. + * @param isOnTheFly true if called during on the fly editor highlighting. Called from Inspect Code action otherwise. + * @return null if no problems found or not applicable at file level. + */ + @Nullable + public ProblemDescriptor[] checkFile(@Nonnull PsiFile file, @Nonnull InspectionManager manager, boolean isOnTheFly, State state) { + return null; + } + + @Nonnull + @Override + @SuppressWarnings("unchecked") + public InspectionToolState createStateProvider() { + return (InspectionToolState) super.createStateProvider(); + } + + @Nonnull + @Override + public final PsiElementVisitor buildVisitor(@Nonnull ProblemsHolder holder, boolean isOnTheFly) { + return super.buildVisitor(holder, isOnTheFly); + } + + @Nonnull + @Override + @SuppressWarnings("unchecked") + public final PsiElementVisitor buildVisitor( + @Nonnull ProblemsHolder holder, + boolean isOnTheFly, + @Nonnull LocalInspectionToolSession session, + @Nonnull Object state + ) { + return buildVisitorImpl(holder, isOnTheFly, session, (State) state); + } + + @Nonnull + public PsiElementVisitor buildVisitorImpl( + @Nonnull final ProblemsHolder holder, + final boolean isOnTheFly, + LocalInspectionToolSession session, + State state + ) { + return new JavaElementVisitor() { + @Override + public void visitMethod(PsiMethod method) { + addDescriptors(checkMethod(method, holder.getManager(), isOnTheFly, state)); + } + + @Override + public void visitClass(PsiClass aClass) { + addDescriptors(checkClass(aClass, holder.getManager(), isOnTheFly, state)); + } + + @Override + public void visitField(PsiField field) { + addDescriptors(checkField(field, holder.getManager(), isOnTheFly, state)); + } + + @Override + public void visitFile(PsiFile file) { + addDescriptors(checkFile(file, holder.getManager(), isOnTheFly, state)); + } + + private void addDescriptors(final ProblemDescriptor[] descriptors) { + if (descriptors != null) { + for (ProblemDescriptor descriptor : descriptors) { + holder.registerProblem(descriptor); + } + } + } + }; + } + + @Override + public PsiNamedElement getProblemElement(final PsiElement psiElement) { + return PsiTreeUtil.getNonStrictParentOfType(psiElement, PsiFile.class, PsiClass.class, PsiMethod.class, PsiField.class); + } + + @Override + public boolean isEnabledByDefault() { + return false; + } + + @Nullable + @Override + public Language getLanguage() { + return JavaLanguage.INSTANCE; + } + + @Nonnull + @Override + public LocalizeValue getGroupDisplayName() { + return InspectionLocalize.inspectionGeneralToolsGroupName(); + } + + @Nonnull + @Override + public HighlightDisplayLevel getDefaultLevel() { + return HighlightDisplayLevel.WARNING; + } } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/BaseJavaLocalInspectionTool.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/BaseJavaLocalInspectionTool.java index ade8ec3c6e..4b58f5c42c 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/BaseJavaLocalInspectionTool.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/BaseJavaLocalInspectionTool.java @@ -36,17 +36,17 @@ * @see GlobalInspectionTool */ public abstract class BaseJavaLocalInspectionTool extends AbstractBaseJavaLocalInspectionTool implements CustomSuppressableInspectionTool { - @Override - public SuppressIntentionAction[] getSuppressActions(final PsiElement element) { - return SuppressManager.getInstance().createSuppressActions(HighlightDisplayKey.find(getShortName())); - } + @Override + public SuppressIntentionAction[] getSuppressActions(final PsiElement element) { + return SuppressManager.getInstance().createSuppressActions(HighlightDisplayKey.find(getShortName())); + } - @Override - public boolean isSuppressedFor(@Nonnull PsiElement element) { - return isSuppressedFor(element, this); - } + @Override + public boolean isSuppressedFor(@Nonnull PsiElement element) { + return isSuppressedFor(element, this); + } - public static boolean isSuppressedFor(@Nonnull PsiElement element, @Nonnull LocalInspectionTool tool) { - return BaseJavaBatchLocalInspectionTool.isSuppressedFor(element, tool); - } + public static boolean isSuppressedFor(@Nonnull PsiElement element, @Nonnull LocalInspectionTool tool) { + return BaseJavaBatchLocalInspectionTool.isSuppressedFor(element, tool); + } } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/ex/BaseLocalInspectionTool.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/ex/BaseLocalInspectionTool.java index 6e8032fd08..7144967cf1 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/ex/BaseLocalInspectionTool.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/ex/BaseLocalInspectionTool.java @@ -20,18 +20,18 @@ import jakarta.annotation.Nonnull; /** - * User: anna - * Date: Dec 27, 2004 + * @author anna + * @since 2004-12-27 */ public abstract class BaseLocalInspectionTool extends BaseJavaLocalInspectionTool { - @Override - public boolean isEnabledByDefault() { - return true; - } + @Override + public boolean isEnabledByDefault() { + return true; + } - @Nonnull - @Override - public HighlightDisplayLevel getDefaultLevel() { - return HighlightDisplayLevel.WARNING; - } + @Nonnull + @Override + public HighlightDisplayLevel getDefaultLevel() { + return HighlightDisplayLevel.WARNING; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/RemoveSuppressWarningAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/RemoveSuppressWarningAction.java index d837e7b4f3..97b76cd97e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/RemoveSuppressWarningAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/RemoveSuppressWarningAction.java @@ -19,7 +19,7 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.javadoc.PsiDocTag; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; @@ -29,168 +29,182 @@ import consulo.language.psi.PsiRecursiveElementWalkingVisitor; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.util.collection.ArrayUtil; import consulo.util.lang.Comparing; import consulo.util.lang.StringUtil; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.HashSet; import java.util.List; import java.util.Set; public class RemoveSuppressWarningAction implements LocalQuickFix { - private static final Logger LOG = Logger.getInstance(RemoveSuppressWarningAction.class); + private static final Logger LOG = Logger.getInstance(RemoveSuppressWarningAction.class); - private final String myID; - private final String myProblemLine; + private final String myID; + private final String myProblemLine; - public RemoveSuppressWarningAction(final String ID, final String problemLine) { - myID = ID; - myProblemLine = problemLine; - } - - public RemoveSuppressWarningAction(String id) { - final int idx = id.indexOf(";"); - if (idx > -1) { - myID = id.substring(0, idx); - myProblemLine = id.substring(idx); - } - else { - myID = id; - myProblemLine = null; + public RemoveSuppressWarningAction(final String ID, final String problemLine) { + myID = ID; + myProblemLine = problemLine; } - } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("remove.suppression.action.family"); - } + public RemoveSuppressWarningAction(String id) { + final int idx = id.indexOf(";"); + if (idx > -1) { + myID = id.substring(0, idx); + myProblemLine = id.substring(idx); + } + else { + myID = id; + myProblemLine = null; + } + } - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getPsiElement(); - try { - if (element instanceof PsiIdentifier) { - if (!FileModificationService.getInstance().prepareFileForWrite(element.getContainingFile())) return; - final PsiIdentifier identifier = (PsiIdentifier)element; - final PsiDocCommentOwner commentOwner = PsiTreeUtil.getParentOfType(identifier, PsiDocCommentOwner.class); - if (commentOwner != null) { - final PsiElement psiElement = BatchSuppressManager.getInstance().getElementMemberSuppressedIn(commentOwner, myID); - if (psiElement instanceof PsiAnnotation) { - removeFromAnnotation((PsiAnnotation)psiElement); - } else if (psiElement instanceof PsiDocComment) { - removeFromJavaDoc((PsiDocComment)psiElement); - } else { //try to remove from all comments - final Set comments = new HashSet(); - commentOwner.accept(new PsiRecursiveElementWalkingVisitor() { - @Override public void visitComment(final PsiComment comment) { - super.visitComment(comment); - if (comment.getText().contains(myID)) { - comments.add(comment); + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiElement element = descriptor.getPsiElement(); + try { + if (element instanceof PsiIdentifier) { + if (!FileModificationService.getInstance().prepareFileForWrite(element.getContainingFile())) { + return; + } + final PsiIdentifier identifier = (PsiIdentifier) element; + final PsiDocCommentOwner commentOwner = PsiTreeUtil.getParentOfType(identifier, PsiDocCommentOwner.class); + if (commentOwner != null) { + final PsiElement psiElement = BatchSuppressManager.getInstance().getElementMemberSuppressedIn(commentOwner, myID); + if (psiElement instanceof PsiAnnotation) { + removeFromAnnotation((PsiAnnotation) psiElement); + } + else if (psiElement instanceof PsiDocComment) { + removeFromJavaDoc((PsiDocComment) psiElement); + } + else { //try to remove from all comments + final Set comments = new HashSet(); + commentOwner.accept(new PsiRecursiveElementWalkingVisitor() { + @Override + public void visitComment(final PsiComment comment) { + super.visitComment(comment); + if (comment.getText().contains(myID)) { + comments.add(comment); + } + } + }); + for (PsiComment comment : comments) { + try { + removeFromComment(comment, comments.size() > 1); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + } + } } - } - }); - for (PsiComment comment : comments) { - try { - removeFromComment(comment, comments.size() > 1); - } - catch (IncorrectOperationException e) { - LOG.error(e); - } } - } } - } - } - catch (IncorrectOperationException e) { - LOG.error(e); + catch (IncorrectOperationException e) { + LOG.error(e); + } } - } - @Override - @Nonnull - public String getName() { - return JavaQuickFixBundle.message("remove.suppression.action.name", myID); - } - - private void removeFromComment(final PsiComment comment, final boolean checkLine) throws IncorrectOperationException { - if (checkLine) { - final PsiStatement statement = PsiTreeUtil.getNextSiblingOfType(comment, PsiStatement.class); - if (statement != null && !Comparing.strEqual(statement.getText(), myProblemLine)) return; - } - String newText = removeFromElementText(comment); - if (newText != null) { - if (newText.length() == 0) { - comment.delete(); - } - else { - PsiComment newComment = JavaPsiFacade.getInstance(comment.getProject()).getElementFactory() - .createCommentFromText("// " + SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME+" "+newText, comment); - comment.replace(newComment); - } + @Nonnull + @Override + public LocalizeValue getName() { + return JavaQuickFixLocalize.removeSuppressionActionName(myID); } - } - private void removeFromJavaDoc(PsiDocComment docComment) throws IncorrectOperationException { - PsiDocTag tag = docComment.findTagByName(SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME); - if (tag == null) return; - String newText = removeFromElementText(tag.getDataElements()); - if (newText != null && newText.length() == 0) { - tag.delete(); + private void removeFromComment(final PsiComment comment, final boolean checkLine) throws IncorrectOperationException { + if (checkLine) { + final PsiStatement statement = PsiTreeUtil.getNextSiblingOfType(comment, PsiStatement.class); + if (statement != null && !Comparing.strEqual(statement.getText(), myProblemLine)) { + return; + } + } + String newText = removeFromElementText(comment); + if (newText != null) { + if (newText.length() == 0) { + comment.delete(); + } + else { + PsiComment newComment = JavaPsiFacade.getInstance(comment.getProject()).getElementFactory() + .createCommentFromText("// " + SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME + " " + newText, comment); + comment.replace(newComment); + } + } } - else if (newText != null) { - newText = "@" + SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME + " " + newText; - PsiDocTag newTag = JavaPsiFacade.getInstance(tag.getProject()).getElementFactory().createDocTagFromText(newText); - tag.replace(newTag); + + private void removeFromJavaDoc(PsiDocComment docComment) throws IncorrectOperationException { + PsiDocTag tag = docComment.findTagByName(SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME); + if (tag == null) { + return; + } + String newText = removeFromElementText(tag.getDataElements()); + if (newText != null && newText.length() == 0) { + tag.delete(); + } + else if (newText != null) { + newText = "@" + SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME + " " + newText; + PsiDocTag newTag = JavaPsiFacade.getInstance(tag.getProject()).getElementFactory().createDocTagFromText(newText); + tag.replace(newTag); + } } - } - @Nullable - private String removeFromElementText(final PsiElement... elements) { - String text = ""; - for (PsiElement element : elements) { - text += StringUtil.trimStart(element.getText(), "//").trim(); + @Nullable + private String removeFromElementText(final PsiElement... elements) { + String text = ""; + for (PsiElement element : elements) { + text += StringUtil.trimStart(element.getText(), "//").trim(); + } + text = StringUtil.trimStart(text, "@").trim(); + text = StringUtil.trimStart(text, SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME).trim(); + List ids = StringUtil.split(text, ","); + int i = ArrayUtil.find(ids.toArray(), myID); + if (i == -1) { + return null; + } + ids.remove(i); + return StringUtil.join(ids, ","); } - text = StringUtil.trimStart(text, "@").trim(); - text = StringUtil.trimStart(text, SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME).trim(); - List ids = StringUtil.split(text, ","); - int i = ArrayUtil.find(ids.toArray(), myID); - if (i==-1) return null; - ids.remove(i); - return StringUtil.join(ids, ","); - } - private void removeFromAnnotation(final PsiAnnotation annotation) throws IncorrectOperationException { - PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes(); - for (PsiNameValuePair attribute : attributes) { - PsiAnnotationMemberValue value = attribute.getValue(); - if (value instanceof PsiArrayInitializerMemberValue) { - PsiAnnotationMemberValue[] initializers = ((PsiArrayInitializerMemberValue)value).getInitializers(); - for (PsiAnnotationMemberValue initializer : initializers) { - if (removeFromValue(annotation, initializer, initializers.length==1)) return; + private void removeFromAnnotation(final PsiAnnotation annotation) throws IncorrectOperationException { + PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes(); + for (PsiNameValuePair attribute : attributes) { + PsiAnnotationMemberValue value = attribute.getValue(); + if (value instanceof PsiArrayInitializerMemberValue) { + PsiAnnotationMemberValue[] initializers = ((PsiArrayInitializerMemberValue) value).getInitializers(); + for (PsiAnnotationMemberValue initializer : initializers) { + if (removeFromValue(annotation, initializer, initializers.length == 1)) { + return; + } + } + } + if (removeFromValue(annotation, value, attributes.length == 1)) { + return; + } } - } - if (removeFromValue(annotation, value, attributes.length==1)) return; } - } - private boolean removeFromValue(final PsiAnnotationMemberValue parent, final PsiAnnotationMemberValue value, final boolean removeParent) throws IncorrectOperationException { - String text = value.getText(); - text = StringUtil.trimStart(text, "\""); - text = StringUtil.trimEnd(text, "\""); - if (myID.equals(text)) { - if (removeParent) { - parent.delete(); - } - else { - value.delete(); - } - return true; + private boolean removeFromValue( + final PsiAnnotationMemberValue parent, + final PsiAnnotationMemberValue value, + final boolean removeParent + ) throws IncorrectOperationException { + String text = value.getText(); + text = StringUtil.trimStart(text, "\""); + text = StringUtil.trimEnd(text, "\""); + if (myID.equals(text)) { + if (removeParent) { + parent.delete(); + } + else { + value.delete(); + } + return true; + } + return false; } - return false; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/analysis/ReplacePrimitiveWithBoxedTypeAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/analysis/ReplacePrimitiveWithBoxedTypeAction.java index b54bae0da9..20cdfbbdb2 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/analysis/ReplacePrimitiveWithBoxedTypeAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/analysis/ReplacePrimitiveWithBoxedTypeAction.java @@ -15,89 +15,84 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.analysis; -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; - -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.java.language.psi.*; import consulo.codeEditor.Editor; -import consulo.project.Project; -import com.intellij.java.language.psi.JavaPsiFacade; -import com.intellij.java.language.psi.PsiClassType; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiPrimitiveType; -import com.intellij.java.language.psi.PsiType; -import com.intellij.java.language.psi.PsiTypeElement; -import com.intellij.java.language.psi.PsiWildcardType; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; +import consulo.project.Project; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; /** -* User: anna -*/ + * @author anna + */ class ReplacePrimitiveWithBoxedTypeAction extends LocalQuickFixAndIntentionActionOnPsiElement { - private final String myPrimitiveName; - private final String myBoxedTypeName; - private static final Logger LOG = Logger.getInstance(ReplacePrimitiveWithBoxedTypeAction.class); - - protected ReplacePrimitiveWithBoxedTypeAction(@Nullable PsiTypeElement element, String typeName, String boxedTypeName) { - super(element); - myPrimitiveName = typeName; - myBoxedTypeName = boxedTypeName; - } + private final String myPrimitiveName; + private final String myBoxedTypeName; + private static final Logger LOG = Logger.getInstance(ReplacePrimitiveWithBoxedTypeAction.class); - @Nonnull - @Override - public String getText() { - return "Convert '" + myPrimitiveName + "' to '" + myBoxedTypeName + "'"; - } + protected ReplacePrimitiveWithBoxedTypeAction(@Nullable PsiTypeElement element, String typeName, String boxedTypeName) { + super(element); + myPrimitiveName = typeName; + myBoxedTypeName = boxedTypeName; + } - @Nonnull - @Override - public String getFamilyName() { - return getText(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO("Convert '" + myPrimitiveName + "' to '" + myBoxedTypeName + "'"); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - if (startElement instanceof PsiTypeElement) { - PsiType type = ((PsiTypeElement)startElement).getType(); - if (type instanceof PsiWildcardType) { - type = ((PsiWildcardType)type).getBound(); - } - if (type instanceof PsiPrimitiveType) { - return ((PsiPrimitiveType)type).getBoxedType(startElement) != null; - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + if (startElement instanceof PsiTypeElement) { + PsiType type = ((PsiTypeElement) startElement).getType(); + if (type instanceof PsiWildcardType) { + type = ((PsiWildcardType) type).getBound(); + } + if (type instanceof PsiPrimitiveType) { + return ((PsiPrimitiveType) type).getBoxedType(startElement) != null; + } + } + return false; } - return false; - } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiType type = ((PsiTypeElement)startElement).getType(); - PsiType boxedType; - if (type instanceof PsiPrimitiveType) { - boxedType = ((PsiPrimitiveType)type).getBoxedType(startElement); - } else { - LOG.assertTrue(type instanceof PsiWildcardType); - final PsiWildcardType wildcardType = (PsiWildcardType)type; - final PsiClassType boxedBound = ((PsiPrimitiveType)wildcardType.getBound()).getBoxedType(startElement); - LOG.assertTrue(boxedBound != null); - boxedType = wildcardType.isExtends() ? PsiWildcardType.createExtends(startElement.getManager(), boxedBound) - : PsiWildcardType.createSuper(startElement.getManager(), boxedBound); + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiType type = ((PsiTypeElement) startElement).getType(); + PsiType boxedType; + if (type instanceof PsiPrimitiveType) { + boxedType = ((PsiPrimitiveType) type).getBoxedType(startElement); + } + else { + LOG.assertTrue(type instanceof PsiWildcardType); + final PsiWildcardType wildcardType = (PsiWildcardType) type; + final PsiClassType boxedBound = ((PsiPrimitiveType) wildcardType.getBound()).getBoxedType(startElement); + LOG.assertTrue(boxedBound != null); + boxedType = wildcardType.isExtends() + ? PsiWildcardType.createExtends(startElement.getManager(), boxedBound) + : PsiWildcardType.createSuper(startElement.getManager(), boxedBound); + } + LOG.assertTrue(boxedType != null); + startElement.replace(JavaPsiFacade.getElementFactory(project).createTypeElement(boxedType)); } - LOG.assertTrue(boxedType != null); - startElement.replace(JavaPsiFacade.getElementFactory(project).createTypeElement(boxedType)); - } - @Override - public boolean startInWriteAction() { - return true; - } + @Override + public boolean startInWriteAction() { + return true; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AccessStaticViaInstanceFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AccessStaticViaInstanceFix.java index 6e0bb90b5b..da0fcce9ac 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AccessStaticViaInstanceFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AccessStaticViaInstanceFix.java @@ -23,9 +23,7 @@ import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; import consulo.codeEditor.EditorColors; -import consulo.colorScheme.EditorColorsManager; -import consulo.colorScheme.TextAttributes; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.highlight.HighlightManager; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; @@ -34,6 +32,7 @@ import consulo.language.psi.PsiUtilCore; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import jakarta.annotation.Nonnull; @@ -43,151 +42,166 @@ import java.util.List; public class AccessStaticViaInstanceFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(AccessStaticViaInstanceFix.class); - private final boolean myOnTheFly; - private final String myText; + private static final Logger LOG = Logger.getInstance(AccessStaticViaInstanceFix.class); + private final boolean myOnTheFly; + @Nonnull + private final LocalizeValue myText; - public AccessStaticViaInstanceFix(@Nonnull PsiReferenceExpression expression, @Nonnull JavaResolveResult result, boolean onTheFly) { - super(expression); - myOnTheFly = onTheFly; - PsiMember member = (PsiMember)result.getElement(); - myText = calcText(member, result.getSubstitutor()); - } - - @Nonnull - @Override - public String getText() { - return myText; - } + public AccessStaticViaInstanceFix(@Nonnull PsiReferenceExpression expression, @Nonnull JavaResolveResult result, boolean onTheFly) { + super(expression); + myOnTheFly = onTheFly; + PsiMember member = (PsiMember) result.getElement(); + myText = calcText(member, result.getSubstitutor()); + } - private static String calcText(PsiMember member, PsiSubstitutor substitutor) { - PsiClass aClass = member.getContainingClass(); - if (aClass == null) return ""; - return JavaQuickFixBundle.message("access.static.via.class.reference.text", - HighlightMessageUtil.getSymbolName(member, substitutor), - HighlightUtil.formatClass(aClass), - HighlightUtil.formatClass(aClass, false)); - } + @Nonnull + @Override + public LocalizeValue getText() { + return myText; + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("access.static.via.class.reference.family"); - } + @Nonnull + private static LocalizeValue calcText(PsiMember member, PsiSubstitutor substitutor) { + PsiClass aClass = member.getContainingClass(); + if (aClass == null) { + return LocalizeValue.empty(); + } + return JavaQuickFixLocalize.accessStaticViaClassReferenceText( + HighlightMessageUtil.getSymbolName(member, substitutor), + HighlightUtil.formatClass(aClass), + HighlightUtil.formatClass(aClass, false) + ); + } - @Override - @RequiredReadAction - public void invoke( - @Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement - ) { - final PsiReferenceExpression myExpression = (PsiReferenceExpression)startElement; + @Override + @RequiredReadAction + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiReferenceExpression myExpression = (PsiReferenceExpression) startElement; - if (!myExpression.isValid()) return; - if (!FileModificationService.getInstance().prepareFileForWrite(myExpression.getContainingFile())) return; - PsiElement element = myExpression.resolve(); - if (!(element instanceof PsiMember)) return; - PsiMember myMember = (PsiMember)element; - if (!myMember.isValid()) return; + if (!myExpression.isValid()) { + return; + } + if (!FileModificationService.getInstance().prepareFileForWrite(myExpression.getContainingFile())) { + return; + } + PsiElement element = myExpression.resolve(); + if (!(element instanceof PsiMember)) { + return; + } + PsiMember myMember = (PsiMember) element; + if (!myMember.isValid()) { + return; + } - PsiClass containingClass = myMember.getContainingClass(); - if (containingClass == null) return; - try { - final PsiExpression qualifierExpression = myExpression.getQualifierExpression(); - PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - if (qualifierExpression != null) { - if (!checkSideEffects(project, containingClass, qualifierExpression, factory, myExpression,editor)) return; - PsiElement newQualifier = qualifierExpression.replace(factory.createReferenceExpression(containingClass)); - PsiElement qualifiedWithClassName = myExpression.copy(); - newQualifier.delete(); - if (myExpression.resolve() != myMember) { - myExpression.replace(qualifiedWithClassName); - } - } - } - catch (IncorrectOperationException e) { - LOG.error(e); + PsiClass containingClass = myMember.getContainingClass(); + if (containingClass == null) { + return; + } + try { + final PsiExpression qualifierExpression = myExpression.getQualifierExpression(); + PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + if (qualifierExpression != null) { + if (!checkSideEffects(project, containingClass, qualifierExpression, factory, myExpression, editor)) { + return; + } + PsiElement newQualifier = qualifierExpression.replace(factory.createReferenceExpression(containingClass)); + PsiElement qualifiedWithClassName = myExpression.copy(); + newQualifier.delete(); + if (myExpression.resolve() != myMember) { + myExpression.replace(qualifiedWithClassName); + } + } + } + catch (IncorrectOperationException e) { + LOG.error(e); + } } - } - @RequiredReadAction - private boolean checkSideEffects( - final Project project, - PsiClass containingClass, - final PsiExpression qualifierExpression, - PsiElementFactory factory, - final PsiElement myExpression, - Editor editor - ) { - final List sideEffects = new ArrayList<>(); - boolean hasSideEffects = RemoveUnusedVariableUtil.checkSideEffects(qualifierExpression, null, sideEffects); - if (hasSideEffects && !myOnTheFly) return false; - if (!hasSideEffects || project.getApplication().isUnitTestMode()) { - return true; - } - if (editor == null) { - return false; - } - HighlightManager.getInstance(project).addOccurrenceHighlights(editor, PsiUtilCore.toPsiElementArray(sideEffects), EditorColors.SEARCH_RESULT_ATTRIBUTES, true, null); - try { - hasSideEffects = PsiUtil.isStatement(factory.createStatementFromText(qualifierExpression.getText(), qualifierExpression)); - } - catch (IncorrectOperationException e) { - hasSideEffects = false; - } - final PsiReferenceExpression qualifiedWithClassName = (PsiReferenceExpression)myExpression.copy(); - qualifiedWithClassName.setQualifierExpression(factory.createReferenceExpression(containingClass)); - final boolean canCopeWithSideEffects = hasSideEffects; - final SideEffectWarningDialog dialog = - new SideEffectWarningDialog( - project, - false, - null, - sideEffects.get(0).getText(), - PsiExpressionTrimRenderer.render(qualifierExpression), - canCopeWithSideEffects - ) { - @Override - @RequiredReadAction - protected String sideEffectsDescription() { - if (canCopeWithSideEffects) { - return "" + - " There are possible side effects found in expression '" + - qualifierExpression.getText() + - "'
" + - " You can:
  • Remove class reference along with whole expressions involved, or
    • " + - "
  • Transform qualified expression into the statement on its own.
    " + - " That is,
    " + - "
    " + - myExpression.getText() + - "

    becomes:
    " + - "
    " + - qualifierExpression.getText() + - ";
    " + - qualifiedWithClassName.getText() + - "
    • " + - " "; - } - return " There are possible side effects found in expression '" + qualifierExpression.getText() + "'
    " + - "You can:
    • Remove class reference along with whole expressions involved, or
      • "; - } - }; - dialog.show(); - int res = dialog.getExitCode(); - if (res == RemoveUnusedVariableUtil.CANCEL) return false; - try { - if (res == RemoveUnusedVariableUtil.MAKE_STATEMENT) { - final PsiStatement statementFromText = factory.createStatementFromText(qualifierExpression.getText() + ";", null); - final PsiStatement statement = PsiTreeUtil.getParentOfType(myExpression, PsiStatement.class); - statement.getParent().addBefore(statementFromText, statement); - } - } - catch (IncorrectOperationException e) { - LOG.error(e); + @RequiredReadAction + private boolean checkSideEffects( + final Project project, + PsiClass containingClass, + final PsiExpression qualifierExpression, + PsiElementFactory factory, + final PsiElement myExpression, + Editor editor + ) { + final List sideEffects = new ArrayList<>(); + boolean hasSideEffects = RemoveUnusedVariableUtil.checkSideEffects(qualifierExpression, null, sideEffects); + if (hasSideEffects && !myOnTheFly) { + return false; + } + if (!hasSideEffects || project.getApplication().isUnitTestMode()) { + return true; + } + if (editor == null) { + return false; + } + HighlightManager.getInstance(project) + .addOccurrenceHighlights(editor, PsiUtilCore.toPsiElementArray(sideEffects), EditorColors.SEARCH_RESULT_ATTRIBUTES, true, null); + try { + hasSideEffects = PsiUtil.isStatement(factory.createStatementFromText(qualifierExpression.getText(), qualifierExpression)); + } + catch (IncorrectOperationException e) { + hasSideEffects = false; + } + final PsiReferenceExpression qualifiedWithClassName = (PsiReferenceExpression) myExpression.copy(); + qualifiedWithClassName.setQualifierExpression(factory.createReferenceExpression(containingClass)); + final boolean canCopeWithSideEffects = hasSideEffects; + final SideEffectWarningDialog dialog = new SideEffectWarningDialog( + project, + false, + null, + sideEffects.get(0).getText(), + PsiExpressionTrimRenderer.render(qualifierExpression), + canCopeWithSideEffects + ) { + @Override + @RequiredReadAction + protected String sideEffectsDescription() { + if (canCopeWithSideEffects) { + return "" + + " There are possible side effects found in expression '" + + qualifierExpression.getText() + + "'
      " + + " You can:
      • Remove class reference along with whole expressions involved, or
        • " + + "
      • Transform qualified expression into the statement on its own.
        " + + " That is,
        " + + "
        " + + myExpression.getText() + + "

        becomes:
        " + + "
        " + + qualifierExpression.getText() + + ";
        " + + qualifiedWithClassName.getText() + + "
        • " + + " "; + } + return " There are possible side effects found in expression '" + qualifierExpression.getText() + "'
        " + + "You can:
        • Remove class reference along with whole expressions involved, or
          • "; + } + }; + dialog.show(); + int res = dialog.getExitCode(); + if (res == RemoveUnusedVariableUtil.CANCEL) { + return false; + } + try { + if (res == RemoveUnusedVariableUtil.MAKE_STATEMENT) { + final PsiStatement statementFromText = factory.createStatementFromText(qualifierExpression.getText() + ";", null); + final PsiStatement statement = PsiTreeUtil.getParentOfType(myExpression, PsiStatement.class); + statement.getParent().addBefore(statementFromText, statement); + } + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + return true; } - return true; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddAnnotationAttributeNameFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddAnnotationAttributeNameFix.java index 5ad375f02f..a0d9896bc8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddAnnotationAttributeNameFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddAnnotationAttributeNameFix.java @@ -21,12 +21,11 @@ import consulo.language.editor.intention.IntentionAction; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ContainerUtil; -import jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; - import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; import java.util.*; import java.util.stream.Collectors; @@ -35,118 +34,125 @@ * @author Pavel.Dolgov */ public class AddAnnotationAttributeNameFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private final String myName; - - public AddAnnotationAttributeNameFix(PsiNameValuePair pair, String name) { - super(pair); - myName = name; - } - - @Nls - @Nonnull - @Override - public String getText() { - return "Add '" + myName + "='"; - } - - @Nls - @Nonnull - @Override - public String getFamilyName() { - return "Add annotation attribute name"; - } - - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - doFix((PsiNameValuePair) startElement, myName); - } - - @Override - public boolean isAvailable(@Nonnull Project project, @Nonnull PsiFile file, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) { - return super.isAvailable(project, file, startElement, endElement) && startElement instanceof PsiNameValuePair; - } - - @Nonnull - public static List createFixes(@Nonnull PsiNameValuePair pair) { - final PsiAnnotationMemberValue value = pair.getValue(); - if (value == null || pair.getName() != null) { - return Collections.emptyList(); + private final String myName; + + public AddAnnotationAttributeNameFix(PsiNameValuePair pair, String name) { + super(pair); + myName = name; + } + + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO("Add '" + myName + "='"); } - final Collection methodNames = getAvailableAnnotationMethodNames(pair); - return ContainerUtil.map2List(methodNames, name -> new AddAnnotationAttributeNameFix(pair, name)); - } - - public static void doFix(@Nonnull PsiNameValuePair annotationParameter, @Nonnull String name) { - final String text = buildReplacementText(annotationParameter, name); - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(annotationParameter.getProject()); - final PsiAnnotation newAnnotation = factory.createAnnotationFromText("@A(" + text + " )", annotationParameter); - annotationParameter.replace(newAnnotation.getParameterList().getAttributes()[0]); - } - - private static String buildReplacementText(@Nonnull PsiNameValuePair annotationParameter, @Nonnull String name) { - final PsiAnnotationMemberValue value = annotationParameter.getValue(); - return value != null ? name + "=" + value.getText() : name + "="; - } - - public static boolean isCompatibleReturnType(@Nonnull PsiMethod psiMethod, @Nullable PsiType valueType) { - final PsiType expectedType = psiMethod.getReturnType(); - if (expectedType == null || valueType == null || expectedType.isAssignableFrom(valueType)) { - return true; + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + doFix((PsiNameValuePair) startElement, myName); } - if (expectedType instanceof PsiArrayType) { - final PsiType componentType = ((PsiArrayType) expectedType).getComponentType(); - return componentType.isAssignableFrom(valueType); + + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + return super.isAvailable(project, file, startElement, endElement) && startElement instanceof PsiNameValuePair; } - return false; - } - - @Nonnull - private static Collection getAvailableAnnotationMethodNames(@Nonnull PsiNameValuePair pair) { - final PsiAnnotationMemberValue value = pair.getValue(); - if (value != null && pair.getName() == null) { - final PsiElement parent = pair.getParent(); - if ((parent instanceof PsiAnnotationParameterList)) { - final PsiAnnotationParameterList parameterList = (PsiAnnotationParameterList) parent; - final PsiClass annotationClass = getAnnotationClass(parameterList); - - if (annotationClass != null) { - final Set usedNames = getUsedAttributeNames(parameterList); - - final Collection availableMethods = Arrays.stream(annotationClass.getMethods()).filter(PsiAnnotationMethod.class::isInstance).filter(psiMethod -> !usedNames.contains - (psiMethod.getName())).collect(Collectors.toList()); - - if (!availableMethods.isEmpty()) { - final PsiType valueType = CreateAnnotationMethodFromUsageFix.getAnnotationValueType(value); - return availableMethods.stream().filter(psiMethod -> isCompatibleReturnType(psiMethod, valueType)).map(PsiMethod::getName).collect(Collectors.toSet()); - } + + @Nonnull + public static List createFixes(@Nonnull PsiNameValuePair pair) { + final PsiAnnotationMemberValue value = pair.getValue(); + if (value == null || pair.getName() != null) { + return Collections.emptyList(); } - } + + final Collection methodNames = getAvailableAnnotationMethodNames(pair); + return ContainerUtil.map2List(methodNames, name -> new AddAnnotationAttributeNameFix(pair, name)); } - return Collections.emptyList(); - } - - @Nonnull - public static Set getUsedAttributeNames(@Nonnull PsiAnnotationParameterList parameterList) { - return Arrays.stream(parameterList.getAttributes()).map(PsiNameValuePair::getName).filter(Objects::nonNull).collect(Collectors.toSet()); - } - - @Nullable - private static PsiClass getAnnotationClass(@Nonnull PsiAnnotationParameterList parameterList) { - final PsiElement parent = parameterList.getParent(); - if (parent instanceof PsiAnnotation) { - final PsiJavaCodeReferenceElement reference = ((PsiAnnotation) parent).getNameReferenceElement(); - if (reference != null) { - final PsiElement resolved = reference.resolve(); - if (resolved instanceof PsiClass && ((PsiClass) resolved).isAnnotationType()) { - return (PsiClass) resolved; + + public static void doFix(@Nonnull PsiNameValuePair annotationParameter, @Nonnull String name) { + final String text = buildReplacementText(annotationParameter, name); + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(annotationParameter.getProject()); + final PsiAnnotation newAnnotation = factory.createAnnotationFromText("@A(" + text + " )", annotationParameter); + annotationParameter.replace(newAnnotation.getParameterList().getAttributes()[0]); + } + + private static String buildReplacementText(@Nonnull PsiNameValuePair annotationParameter, @Nonnull String name) { + final PsiAnnotationMemberValue value = annotationParameter.getValue(); + return value != null ? name + "=" + value.getText() : name + "="; + } + + public static boolean isCompatibleReturnType(@Nonnull PsiMethod psiMethod, @Nullable PsiType valueType) { + final PsiType expectedType = psiMethod.getReturnType(); + if (expectedType == null || valueType == null || expectedType.isAssignableFrom(valueType)) { + return true; + } + if (expectedType instanceof PsiArrayType) { + final PsiType componentType = ((PsiArrayType) expectedType).getComponentType(); + return componentType.isAssignableFrom(valueType); + } + return false; + } + + @Nonnull + private static Collection getAvailableAnnotationMethodNames(@Nonnull PsiNameValuePair pair) { + final PsiAnnotationMemberValue value = pair.getValue(); + if (value != null && pair.getName() == null) { + final PsiElement parent = pair.getParent(); + if ((parent instanceof PsiAnnotationParameterList)) { + final PsiAnnotationParameterList parameterList = (PsiAnnotationParameterList) parent; + final PsiClass annotationClass = getAnnotationClass(parameterList); + + if (annotationClass != null) { + final Set usedNames = getUsedAttributeNames(parameterList); + + final Collection availableMethods = Arrays.stream(annotationClass.getMethods()) + .filter(PsiAnnotationMethod.class::isInstance) + .filter(psiMethod -> !usedNames.contains(psiMethod.getName())) + .collect(Collectors.toList()); + + if (!availableMethods.isEmpty()) { + final PsiType valueType = CreateAnnotationMethodFromUsageFix.getAnnotationValueType(value); + return availableMethods.stream() + .filter(psiMethod -> isCompatibleReturnType(psiMethod, valueType)) + .map(PsiMethod::getName) + .collect(Collectors.toSet()); + } + } + } + } + return Collections.emptyList(); + } + + @Nonnull + public static Set getUsedAttributeNames(@Nonnull PsiAnnotationParameterList parameterList) { + return Arrays.stream(parameterList.getAttributes()) + .map(PsiNameValuePair::getName) + .filter(Objects::nonNull) + .collect(Collectors.toSet()); + } + + @Nullable + private static PsiClass getAnnotationClass(@Nonnull PsiAnnotationParameterList parameterList) { + final PsiElement parent = parameterList.getParent(); + if (parent instanceof PsiAnnotation) { + final PsiJavaCodeReferenceElement reference = ((PsiAnnotation) parent).getNameReferenceElement(); + if (reference != null) { + final PsiElement resolved = reference.resolve(); + if (resolved instanceof PsiClass && ((PsiClass) resolved).isAnnotationType()) { + return (PsiClass) resolved; + } + } } - } + return null; } - return null; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddDefaultConstructorFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddDefaultConstructorFix.java index 6e98d5fcce..99db18f8ba 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddDefaultConstructorFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddDefaultConstructorFix.java @@ -15,34 +15,27 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import jakarta.annotation.Nonnull; - -import consulo.java.analysis.impl.JavaQuickFixBundle; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiModifier; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.util.VisibilityUtil; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; +import jakarta.annotation.Nonnull; public class AddDefaultConstructorFix extends AddMethodFix { - public AddDefaultConstructorFix(PsiClass aClass) { - this(aClass, PsiUtil.getMaximumModifierForMember(aClass, false)); - } - - public AddDefaultConstructorFix(PsiClass aClass, @Nonnull @PsiModifier.ModifierConstant final String modifier) { - super(generateConstructor(aClass.getName(), modifier), aClass); - setText(JavaQuickFixBundle.message("add.default.constructor.text", VisibilityUtil.toPresentableText(modifier), aClass.getName())); - } + public AddDefaultConstructorFix(PsiClass aClass) { + this(aClass, PsiUtil.getMaximumModifierForMember(aClass, false)); + } - private static String generateConstructor(final String className, @PsiModifier.ModifierConstant final String modifier) { - if (modifier.equals(PsiModifier.PACKAGE_LOCAL)) { - return className + "() {}"; + public AddDefaultConstructorFix(PsiClass aClass, @Nonnull @PsiModifier.ModifierConstant final String modifier) { + super(generateConstructor(aClass.getName(), modifier), aClass); + setText(JavaQuickFixLocalize.addDefaultConstructorText(VisibilityUtil.toPresentableText(modifier), aClass.getName())); } - return modifier + " " + className + "() {}"; - } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("add.default.constructor.family"); - } + private static String generateConstructor(final String className, @PsiModifier.ModifierConstant final String modifier) { + if (modifier.equals(PsiModifier.PACKAGE_LOCAL)) { + return className + "() {}"; + } + return modifier + " " + className + "() {}"; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddExternalLibraryToDependenciesQuickFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddExternalLibraryToDependenciesQuickFix.java index 018f90fa5a..8d316b0696 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddExternalLibraryToDependenciesQuickFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddExternalLibraryToDependenciesQuickFix.java @@ -15,85 +15,71 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; +import com.intellij.java.impl.openapi.roots.JavaProjectModelModificationService; +import com.intellij.java.language.projectRoots.roots.ExternalLibraryDescriptor; import consulo.application.WriteAction; -import consulo.logging.Logger; -import consulo.codeEditor.Editor; -import consulo.module.Module; import consulo.application.dumb.IndexNotReadyException; -import consulo.project.Project; -import consulo.module.content.layer.orderEntry.DependencyScope; -import com.intellij.java.language.projectRoots.roots.ExternalLibraryDescriptor; -import com.intellij.java.impl.openapi.roots.JavaProjectModelModificationService; +import consulo.codeEditor.Editor; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiReference; import consulo.language.util.IncorrectOperationException; -import jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; - +import consulo.localize.LocalizeValue; +import consulo.logging.Logger; +import consulo.module.Module; +import consulo.module.content.layer.orderEntry.DependencyScope; +import consulo.project.Project; import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; /** * @author nik */ -class AddExternalLibraryToDependenciesQuickFix extends AddOrderEntryFix -{ - private static final Logger LOG = Logger.getInstance(AddExternalLibraryToDependenciesQuickFix.class); - private final Module myCurrentModule; - private final ExternalLibraryDescriptor myLibraryDescriptor; - private final String myQualifiedClassName; - - public AddExternalLibraryToDependenciesQuickFix(@Nonnull Module currentModule, - @Nonnull ExternalLibraryDescriptor libraryDescriptor, - @Nonnull PsiReference reference, - @Nullable String qualifiedClassName) - { - super(reference); - myCurrentModule = currentModule; - myLibraryDescriptor = libraryDescriptor; - myQualifiedClassName = qualifiedClassName; - } +class AddExternalLibraryToDependenciesQuickFix extends AddOrderEntryFix { + private static final Logger LOG = Logger.getInstance(AddExternalLibraryToDependenciesQuickFix.class); + private final Module myCurrentModule; + private final ExternalLibraryDescriptor myLibraryDescriptor; + private final String myQualifiedClassName; - @Nls - @Nonnull - @Override - public String getText() - { - return "Add '" + myLibraryDescriptor.getPresentableName() + "' to classpath"; - } + public AddExternalLibraryToDependenciesQuickFix( + @Nonnull Module currentModule, + @Nonnull ExternalLibraryDescriptor libraryDescriptor, + @Nonnull PsiReference reference, + @Nullable String qualifiedClassName + ) { + super(reference); + myCurrentModule = currentModule; + myLibraryDescriptor = libraryDescriptor; + myQualifiedClassName = qualifiedClassName; + } - @Nls - @Nonnull - @Override - public String getFamilyName() - { - return getText(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO("Add '" + myLibraryDescriptor.getPresentableName() + "' to classpath"); + } - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) - { - return !project.isDisposed() && !myCurrentModule.isDisposed(); - } + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return !project.isDisposed() && !myCurrentModule.isDisposed(); + } - @Override - public void invoke(@Nonnull Project project, final Editor editor, PsiFile file) throws IncorrectOperationException - { - DependencyScope scope = suggestScopeByLocation(myCurrentModule, myReference.getElement()); - JavaProjectModelModificationService.getInstance(project).addDependency(myCurrentModule, myLibraryDescriptor, scope).doWhenDone(aVoid -> WriteAction.run(() -> { - try - { - importClass(myCurrentModule, editor, myReference, myQualifiedClassName); - } - catch(IndexNotReadyException e) - { - LOG.info(e); - } - })); - } + @Override + public void invoke(@Nonnull Project project, final Editor editor, PsiFile file) throws IncorrectOperationException { + DependencyScope scope = suggestScopeByLocation(myCurrentModule, myReference.getElement()); + JavaProjectModelModificationService.getInstance(project) + .addDependency(myCurrentModule, myLibraryDescriptor, scope) + .doWhenDone(aVoid -> WriteAction.run(() -> { + try { + importClass(myCurrentModule, editor, myReference, myQualifiedClassName); + } + catch (IndexNotReadyException e) { + LOG.info(e); + } + })); + } - @Override - public boolean startInWriteAction() - { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddLibraryToDependenciesFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddLibraryToDependenciesFix.java index d2d940acf2..85d2a3a118 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddLibraryToDependenciesFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddLibraryToDependenciesFix.java @@ -19,9 +19,10 @@ import consulo.codeEditor.Editor; import consulo.content.library.Library; import consulo.ide.impl.idea.openapi.roots.libraries.LibraryUtil; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiReference; +import consulo.localize.LocalizeValue; import consulo.module.Module; import consulo.module.content.layer.orderEntry.DependencyScope; import consulo.project.Project; @@ -32,40 +33,39 @@ * @author nik */ class AddLibraryToDependenciesFix extends AddOrderEntryFix { - private final Library myLibrary; - private final Module myCurrentModule; - private final String myQualifiedClassName; + private final Library myLibrary; + private final Module myCurrentModule; + private final String myQualifiedClassName; - public AddLibraryToDependenciesFix(@Nonnull Module currentModule, @Nonnull Library library, @Nonnull PsiReference reference, @Nullable String qualifiedClassName) { - super(reference); - myLibrary = library; - myCurrentModule = currentModule; - myQualifiedClassName = qualifiedClassName; - } - - @Override - @Nonnull - public String getText() { - return JavaQuickFixBundle.message("orderEntry.fix.add.library.to.classpath", LibraryUtil.getPresentableName(myLibrary)); - } + public AddLibraryToDependenciesFix( + @Nonnull Module currentModule, + @Nonnull Library library, + @Nonnull PsiReference reference, + @Nullable String qualifiedClassName + ) { + super(reference); + myLibrary = library; + myCurrentModule = currentModule; + myQualifiedClassName = qualifiedClassName; + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("orderEntry.fix.family.add.library.to.classpath"); - } + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.orderentryFixAddLibraryToClasspath(LibraryUtil.getPresentableName(myLibrary)); + } - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - return !project.isDisposed() && !myCurrentModule.isDisposed() && !((Library) myLibrary).isDisposed(); - } + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return !project.isDisposed() && !myCurrentModule.isDisposed() && !((Library) myLibrary).isDisposed(); + } - @Override - public void invoke(@Nonnull Project project, @Nullable Editor editor, PsiFile file) { - DependencyScope scope = suggestScopeByLocation(myCurrentModule, myReference.getElement()); - JavaProjectModelModificationService.getInstance(project).addDependency(myCurrentModule, myLibrary, scope); - if (myQualifiedClassName != null && editor != null) { - importClass(myCurrentModule, editor, myReference, myQualifiedClassName); + @Override + public void invoke(@Nonnull Project project, @Nullable Editor editor, PsiFile file) { + DependencyScope scope = suggestScopeByLocation(myCurrentModule, myReference.getElement()); + JavaProjectModelModificationService.getInstance(project).addDependency(myCurrentModule, myLibrary, scope); + if (myQualifiedClassName != null && editor != null) { + importClass(myCurrentModule, editor, myReference, myQualifiedClassName); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddMethodFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddMethodFix.java index 32bc3d28cd..fabf058982 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddMethodFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddMethodFix.java @@ -15,119 +15,120 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import java.util.ArrayList; -import java.util.List; - -import jakarta.annotation.Nonnull; - -import consulo.logging.Logger; -import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; -import consulo.language.editor.FileModificationService; import com.intellij.java.impl.codeInsight.generation.GenerateMembersUtil; -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; -import consulo.codeEditor.Editor; -import consulo.project.Project; import com.intellij.java.language.psi.JavaPsiFacade; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiCodeBlock; -import consulo.language.psi.PsiElement; -import consulo.language.psi.PsiFile; import com.intellij.java.language.psi.PsiMethod; -import consulo.language.codeStyle.CodeStyleManager; import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import com.intellij.java.language.psi.util.MethodSignatureUtil; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.codeEditor.Editor; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; +import consulo.language.codeStyle.CodeStyleManager; +import consulo.language.editor.FileModificationService; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; +import consulo.logging.Logger; +import consulo.project.Project; import consulo.util.collection.ContainerUtil; -import consulo.java.analysis.impl.JavaQuickFixBundle; - -public class AddMethodFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(AddMethodFix.class); +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; - private final PsiMethod myMethodPrototype; - private String myText; - private final List myExceptions = new ArrayList(); +import java.util.ArrayList; +import java.util.List; - public AddMethodFix(@Nonnull PsiMethod methodPrototype, @Nonnull PsiClass implClass) { - super(implClass); - myMethodPrototype = methodPrototype; - setText(JavaQuickFixBundle.message("add.method.text", methodPrototype.getName(), implClass.getName())); - } +public class AddMethodFix extends LocalQuickFixAndIntentionActionOnPsiElement { + private static final Logger LOG = Logger.getInstance(AddMethodFix.class); - public AddMethodFix(@NonNls @Nonnull String methodText, @Nonnull PsiClass implClass, @Nonnull String... exceptions) { - this(createMethod(methodText, implClass), implClass); - ContainerUtil.addAll(myExceptions, exceptions); - } + private final PsiMethod myMethodPrototype; + @Nonnull + private LocalizeValue myText; + private final List myExceptions = new ArrayList(); - private static PsiMethod createMethod(final String methodText, final PsiClass implClass) { - try { - return JavaPsiFacade.getInstance(implClass.getProject()).getElementFactory().createMethodFromText(methodText, implClass); - } - catch (IncorrectOperationException e) { - LOG.error(e); - return null; + public AddMethodFix(@Nonnull PsiMethod methodPrototype, @Nonnull PsiClass implClass) { + super(implClass); + myMethodPrototype = methodPrototype; + setText(JavaQuickFixLocalize.addMethodText(methodPrototype.getName(), implClass.getName())); } - } - - private static PsiMethod reformat(Project project, PsiMethod result) throws IncorrectOperationException { - CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project); - result = (PsiMethod) codeStyleManager.reformat(result); - JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); - result = (PsiMethod) javaCodeStyleManager.shortenClassReferences(result); - return result; - } + public AddMethodFix(@Nonnull String methodText, @Nonnull PsiClass implClass, @Nonnull String... exceptions) { + this(createMethod(methodText, implClass), implClass); + ContainerUtil.addAll(myExceptions, exceptions); + } - protected void setText(@Nonnull String text) { - myText = text; - } + private static PsiMethod createMethod(final String methodText, final PsiClass implClass) { + try { + return JavaPsiFacade.getInstance(implClass.getProject()).getElementFactory().createMethodFromText(methodText, implClass); + } + catch (IncorrectOperationException e) { + LOG.error(e); + return null; + } + } - @Nonnull - @Override - public String getText() { - return myText; - } + private static PsiMethod reformat(Project project, PsiMethod result) throws IncorrectOperationException { + CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project); + result = (PsiMethod) codeStyleManager.reformat(result); - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("add.method.family"); - } + JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); + result = (PsiMethod) javaCodeStyleManager.shortenClassReferences(result); + return result; + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; + protected void setText(@Nonnull LocalizeValue text) { + myText = text; + } - return myMethodPrototype != null - && myMethodPrototype.isValid() - && myClass.isValid() - && myClass.getManager().isInProject(myClass) - && myText != null - && MethodSignatureUtil.findMethodBySignature(myClass, myMethodPrototype, false) == null - ; - } + @Nonnull + @Override + public LocalizeValue getText() { + return myText; + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) return; - PsiCodeBlock body; - if (myClass.isInterface() && (body = myMethodPrototype.getBody()) != null) body.delete(); - for (String exception : myExceptions) { - PsiUtil.addException(myMethodPrototype, exception); + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + + return myMethodPrototype != null + && myMethodPrototype.isValid() + && myClass.isValid() + && myClass.getManager().isInProject(myClass) + && myText != null + && MethodSignatureUtil.findMethodBySignature(myClass, myMethodPrototype, false) == null; } - PsiMethod method = (PsiMethod)myClass.add(myMethodPrototype); - method = (PsiMethod)method.replace(reformat(project, method)); - if (editor != null && method.getContainingFile() == file) { - GenerateMembersUtil.positionCaret(editor, method, true); + + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) { + return; + } + PsiCodeBlock body; + if (myClass.isInterface() && (body = myMethodPrototype.getBody()) != null) { + body.delete(); + } + for (String exception : myExceptions) { + PsiUtil.addException(myMethodPrototype, exception); + } + PsiMethod method = (PsiMethod) myClass.add(myMethodPrototype); + method = (PsiMethod) method.replace(reformat(project, method)); + if (editor != null && method.getContainingFile() == file) { + GenerateMembersUtil.positionCaret(editor, method, true); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java index 40b56b34be..6695aaa551 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java @@ -23,11 +23,12 @@ import consulo.codeEditor.Editor; import consulo.codeEditor.EditorPopupHelper; import consulo.compiler.util.ModuleCompilerUtil; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiReference; import consulo.language.util.ModuleUtilCore; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.module.Module; import consulo.module.content.ModuleRootManager; @@ -36,6 +37,7 @@ import consulo.module.content.layer.orderEntry.DependencyScope; import consulo.module.ui.awt.ModuleListCellRenderer; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.JBList; import consulo.ui.ex.awt.Messages; import consulo.ui.ex.awt.UIUtil; @@ -45,7 +47,6 @@ import consulo.util.collection.ContainerUtil; import consulo.util.lang.Pair; import consulo.virtualFileSystem.VirtualFile; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -56,123 +57,132 @@ /** * @author anna - * @since 20.11.2012 + * @since 2012-11-20 */ class AddModuleDependencyFix extends AddOrderEntryFix { - private static final Logger LOG = Logger.getInstance(AddModuleDependencyFix.class); - - private final Module myCurrentModule; - private final VirtualFile myRefVFile; - private final List myClasses; - private final Set myModules; - - @RequiredReadAction - public AddModuleDependencyFix(Module currentModule, VirtualFile refVFile, List classes, PsiReference reference) { - super(reference); - myCurrentModule = currentModule; - myRefVFile = refVFile; - myClasses = classes; - myModules = new LinkedHashSet<>(); - - final PsiElement psiElement = reference.getElement(); - final Project project = psiElement.getProject(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex(); - final ModuleRootManager rootManager = ModuleRootManager.getInstance(currentModule); - for (PsiClass aClass : classes) { - if (!facade.getResolveHelper().isAccessible(aClass, psiElement, aClass)) { - continue; - } - PsiFile psiFile = aClass.getContainingFile(); - if (psiFile == null) { - continue; - } - VirtualFile virtualFile = psiFile.getVirtualFile(); - if (virtualFile == null) { - continue; - } - Module classModule = fileIndex.getModuleForFile(virtualFile); - if (classModule != null && classModule != currentModule && !rootManager.isDependsOn(classModule)) { - myModules.add(classModule); - } + private static final Logger LOG = Logger.getInstance(AddModuleDependencyFix.class); + + private final Module myCurrentModule; + private final VirtualFile myRefVFile; + private final List myClasses; + private final Set myModules; + + @RequiredReadAction + public AddModuleDependencyFix(Module currentModule, VirtualFile refVFile, List classes, PsiReference reference) { + super(reference); + myCurrentModule = currentModule; + myRefVFile = refVFile; + myClasses = classes; + myModules = new LinkedHashSet<>(); + + final PsiElement psiElement = reference.getElement(); + final Project project = psiElement.getProject(); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex(); + final ModuleRootManager rootManager = ModuleRootManager.getInstance(currentModule); + for (PsiClass aClass : classes) { + if (!facade.getResolveHelper().isAccessible(aClass, psiElement, aClass)) { + continue; + } + PsiFile psiFile = aClass.getContainingFile(); + if (psiFile == null) { + continue; + } + VirtualFile virtualFile = psiFile.getVirtualFile(); + if (virtualFile == null) { + continue; + } + Module classModule = fileIndex.getModuleForFile(virtualFile); + if (classModule != null && classModule != currentModule && !rootManager.isDependsOn(classModule)) { + myModules.add(classModule); + } + } } - } - - public AddModuleDependencyFix(Module currentModule, VirtualFile refVFile, Set modules, PsiReference reference) { - super(reference); - myCurrentModule = currentModule; - myRefVFile = refVFile; - myClasses = Collections.emptyList(); - myModules = modules; - } - @Override - @Nonnull - public String getText() { - if (myModules.size() == 1) { - final Module module = ContainerUtil.getFirstItem(myModules); - LOG.assertTrue(module != null); - return JavaQuickFixBundle.message("orderEntry.fix.add.dependency.on.module", module.getName()); - } else { - return JavaQuickFixBundle.message("orderEntry.fix.add.dependency.on.module.choose"); + public AddModuleDependencyFix(Module currentModule, VirtualFile refVFile, Set modules, PsiReference reference) { + super(reference); + myCurrentModule = currentModule; + myRefVFile = refVFile; + myClasses = Collections.emptyList(); + myModules = modules; } - } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("orderEntry.fix.family.add.module.dependency"); - } - - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - return !project.isDisposed() && !myCurrentModule.isDisposed() && !myModules.isEmpty() && myModules.stream().noneMatch(Module::isDisposed); - } + @Nonnull + @Override + public LocalizeValue getText() { + if (myModules.size() == 1) { + final Module module = ContainerUtil.getFirstItem(myModules); + LOG.assertTrue(module != null); + return JavaQuickFixLocalize.orderentryFixAddDependencyOnModule(module.getName()); + } + else { + return JavaQuickFixLocalize.orderentryFixAddDependencyOnModuleChoose(); + } + } - @Override - public void invoke(@Nonnull Project project, @Nullable Editor editor, PsiFile file) { - if (myModules.size() == 1) { - addDependencyOnModule(project, editor, ContainerUtil.getFirstItem(myModules)); - } else { - JBList list = new JBList<>(myModules); - list.setCellRenderer(new ModuleListCellRenderer()); - JBPopup popup = ((AWTPopupFactory) JBPopupFactory.getInstance()).createListPopupBuilder(list).setItemChoosenCallback(() -> addDependencyOnModule(project, editor, list.getSelectedValue())).setTitle(JavaQuickFixBundle.message("orderEntry.fix.choose.module.to.add.dependency.on")).setMovable(false) - .setResizable(false).setRequestFocus(true).createPopup(); - if (editor != null) { - EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); - } else { - popup.showCenteredInCurrentWindow(project); - } + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return !project.isDisposed() && !myCurrentModule.isDisposed() && !myModules.isEmpty() && myModules.stream() + .noneMatch(Module::isDisposed); } - } - private void addDependencyOnModule(Project project, Editor editor, @Nullable Module module) { - if (module == null) { - return; + @Override + public void invoke(@Nonnull Project project, @Nullable Editor editor, PsiFile file) { + if (myModules.size() == 1) { + addDependencyOnModule(project, editor, ContainerUtil.getFirstItem(myModules)); + } + else { + JBList list = new JBList<>(myModules); + list.setCellRenderer(new ModuleListCellRenderer()); + JBPopup popup = ((AWTPopupFactory) JBPopupFactory.getInstance()).createListPopupBuilder(list) + .setItemChoosenCallback(() -> addDependencyOnModule(project, editor, list.getSelectedValue())) + .setTitle(JavaQuickFixLocalize.orderentryFixChooseModuleToAddDependencyOn().get()) + .setMovable(false) + .setResizable(false) + .setRequestFocus(true) + .createPopup(); + if (editor != null) { + EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); + } + else { + popup.showCenteredInCurrentWindow(project); + } + } } - Pair circularModules = ModuleCompilerUtil.addingDependencyFormsCircularity(myCurrentModule, module); - if (circularModules == null || showCircularWarning(project, circularModules, module)) { - boolean test = ModuleRootManager.getInstance(myCurrentModule).getFileIndex().isInTestSourceContent(myRefVFile); - DependencyScope scope = test ? DependencyScope.TEST : DependencyScope.COMPILE; - JavaProjectModelModificationService.getInstance(project).addDependency(myCurrentModule, module, scope); - if (editor != null && !myClasses.isEmpty()) { - PsiClass[] targetClasses = myClasses.stream().filter(c -> ModuleUtilCore.findModuleForPsiElement(c) == module).toArray(PsiClass[]::new); - if (targetClasses.length > 0) { - new AddImportAction(project, myReference, editor, targetClasses).execute(); + private void addDependencyOnModule(Project project, Editor editor, @Nullable Module module) { + if (module == null) { + return; + } + Pair circularModules = ModuleCompilerUtil.addingDependencyFormsCircularity(myCurrentModule, module); + if (circularModules == null || showCircularWarning(project, circularModules, module)) { + boolean test = ModuleRootManager.getInstance(myCurrentModule).getFileIndex().isInTestSourceContent(myRefVFile); + DependencyScope scope = test ? DependencyScope.TEST : DependencyScope.COMPILE; + JavaProjectModelModificationService.getInstance(project).addDependency(myCurrentModule, module, scope); + + if (editor != null && !myClasses.isEmpty()) { + PsiClass[] targetClasses = + myClasses.stream().filter(c -> ModuleUtilCore.findModuleForPsiElement(c) == module).toArray(PsiClass[]::new); + if (targetClasses.length > 0) { + new AddImportAction(project, myReference, editor, targetClasses).execute(); + } + } } - } } - } - private static boolean showCircularWarning(Project project, Pair circle, Module classModule) { - String message = JavaQuickFixBundle.message("orderEntry.fix.circular.dependency.warning", classModule.getName(), circle.getFirst().getName(), circle.getSecond().getName()); - String title = JavaQuickFixBundle.message("orderEntry.fix.title.circular.dependency.warning"); - return Messages.showOkCancelDialog(project, message, title, UIUtil.getWarningIcon()) == Messages.OK; - } + @RequiredUIAccess + private static boolean showCircularWarning(Project project, Pair circle, Module classModule) { + LocalizeValue message = JavaQuickFixLocalize.orderentryFixCircularDependencyWarning( + classModule.getName(), + circle.getFirst().getName(), + circle.getSecond().getName() + ); + LocalizeValue title = JavaQuickFixLocalize.orderentryFixTitleCircularDependencyWarning(); + return Messages.showOkCancelDialog(project, message.get(), title.get(), UIUtil.getWarningIcon()) == Messages.OK; + } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddOrderEntryFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddOrderEntryFix.java index ebf49fd2a1..d699a97572 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddOrderEntryFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/AddOrderEntryFix.java @@ -17,13 +17,11 @@ import consulo.language.psi.PsiReference; -abstract class AddOrderEntryFix extends OrderEntryFix -{ - @SuppressWarnings("StatefulEp") - protected final PsiReference myReference; +abstract class AddOrderEntryFix extends OrderEntryFix { + @SuppressWarnings("StatefulEp") + protected final PsiReference myReference; - protected AddOrderEntryFix(PsiReference reference) - { - myReference = reference; - } + protected AddOrderEntryFix(PsiReference reference) { + myReference = reference; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ChangeParameterClassFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ChangeParameterClassFix.java index 41c9f25ab8..9e6951cfb7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ChangeParameterClassFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ChangeParameterClassFix.java @@ -32,14 +32,12 @@ import com.intellij.java.language.psi.infos.CandidateInfo; import consulo.application.ApplicationManager; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; import consulo.language.editor.FileModificationService; import consulo.language.editor.util.LanguageUndoUtil; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.project.Project; import consulo.util.collection.ContainerUtil; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -47,76 +45,79 @@ import java.util.function.Function; public class ChangeParameterClassFix extends ExtendsListFix { - public ChangeParameterClassFix(@Nonnull PsiClass aClassToExtend, @Nonnull PsiClassType parameterClass) { - super(aClassToExtend, parameterClass, true); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("change.parameter.class.family"); - } + public ChangeParameterClassFix(@Nonnull PsiClass aClassToExtend, @Nonnull PsiClassType parameterClass) { + super(aClassToExtend, parameterClass, true); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - return - super.isAvailable(project, file, startElement, endElement) - && myClassToExtendFrom != null - && myClassToExtendFrom.isValid() - && myClassToExtendFrom.getQualifiedName() != null - ; - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + return + super.isAvailable(project, file, startElement, endElement) + && myClassToExtendFrom != null + && myClassToExtendFrom.isValid() + && myClassToExtendFrom.getQualifiedName() != null + ; + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass) startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; - ApplicationManager.getApplication().runWriteAction( - new Runnable() { - @Override - public void run() { - invokeImpl(myClass); - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(file)) { + return; } - ); - final Editor editor1 = CodeInsightUtil.positionCursor(project, myClass.getContainingFile(), myClass); - if (editor1 == null) return; - final Collection toImplement = OverrideImplementExploreUtil.getMethodsToOverrideImplement(myClass, true); - if (!toImplement.isEmpty()) { - if (ApplicationManager.getApplication().isUnitTestMode()) { ApplicationManager.getApplication().runWriteAction( new Runnable() { - @Override - public void run() { - Collection members = - ContainerUtil.map2List(toImplement, new Function() { - @Override - public PsiMethodMember apply(final CandidateInfo s) { - return new PsiMethodMember(s); - } + @Override + public void run() { + invokeImpl(myClass); + } + } + ); + final Editor editor1 = CodeInsightUtil.positionCursor(project, myClass.getContainingFile(), myClass); + if (editor1 == null) { + return; + } + final Collection toImplement = OverrideImplementExploreUtil.getMethodsToOverrideImplement(myClass, true); + if (!toImplement.isEmpty()) { + if (ApplicationManager.getApplication().isUnitTestMode()) { + ApplicationManager.getApplication().runWriteAction( + new Runnable() { + @Override + public void run() { + Collection members = + ContainerUtil.map2List(toImplement, new Function() { + @Override + public PsiMethodMember apply(final CandidateInfo s) { + return new PsiMethodMember(s); + } + }); + OverrideImplementUtil.overrideOrImplementMethodsInRightPlace(editor1, myClass, members, false); + } }); - OverrideImplementUtil.overrideOrImplementMethodsInRightPlace(editor1, myClass, members, false); - } - }); - } else { - //SCR 12599 - editor1.getCaretModel().moveToOffset(myClass.getTextRange().getStartOffset()); + } + else { + //SCR 12599 + editor1.getCaretModel().moveToOffset(myClass.getTextRange().getStartOffset()); - OverrideImplementUtil.chooseAndImplementMethods(project, editor1, myClass); - } + OverrideImplementUtil.chooseAndImplementMethods(project, editor1, myClass); + } + } + LanguageUndoUtil.markPsiFileForUndo(file); } - LanguageUndoUtil.markPsiFileForUndo(file); - } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/CreateMethodQuickFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/CreateMethodQuickFix.java index c0ba68e15f..ffd7b5f448 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/CreateMethodQuickFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/CreateMethodQuickFix.java @@ -21,87 +21,92 @@ import com.intellij.java.language.psi.util.PsiFormatUtil; import com.intellij.java.language.psi.util.PsiFormatUtilBase; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ContainerUtil; import consulo.util.lang.Pair; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.List; import java.util.function.Function; public class CreateMethodQuickFix extends LocalQuickFixAndIntentionActionOnPsiElement { - protected final String mySignature; - protected final String myBody; + protected final String mySignature; + protected final String myBody; - private CreateMethodQuickFix(final PsiClass targetClass, @NonNls final String signature, @NonNls final String body) { - super(targetClass); - mySignature = signature; - myBody = body; - } + private CreateMethodQuickFix(final PsiClass targetClass, String signature, String body) { + super(targetClass); + mySignature = signature; + myBody = body; + } - @Override - @Nonnull - public String getText() { - PsiClass myTargetClass = (PsiClass) getStartElement(); - String signature = myTargetClass == null ? "" : - PsiFormatUtil.formatMethod(createMethod(myTargetClass), PsiSubstitutor.EMPTY, + @Nonnull + @Override + public LocalizeValue getText() { + PsiClass myTargetClass = (PsiClass) getStartElement(); + String signature = myTargetClass == null ? "" + : PsiFormatUtil.formatMethod( + createMethod(myTargetClass), + PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_PARAMETERS | PsiFormatUtilBase.SHOW_RAW_TYPE, - PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_RAW_TYPE, 2); - return JavaQuickFixBundle.message("create.method.from.usage.text", signature); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("create.method.from.usage.family"); - } + PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_RAW_TYPE, + 2 + ); + return JavaQuickFixLocalize.createMethodFromUsageText(signature); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - PsiClass myTargetClass = (PsiClass) startElement; - if (!FileModificationService.getInstance().preparePsiElementForWrite(myTargetClass.getContainingFile())) return; + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + PsiClass myTargetClass = (PsiClass) startElement; + if (!FileModificationService.getInstance().preparePsiElementForWrite(myTargetClass.getContainingFile())) { + return; + } - PsiMethod method = createMethod(myTargetClass); - List> arguments = - ContainerUtil.map2List(method.getParameterList().getParameters(), (Function>) psiParameter -> Pair.create(null, psiParameter.getType())); + PsiMethod method = createMethod(myTargetClass); + List> arguments = ContainerUtil.map2List( + method.getParameterList().getParameters(), + (Function>) psiParameter -> Pair.create(null, psiParameter.getType()) + ); - method = (PsiMethod) JavaCodeStyleManager.getInstance(project).shortenClassReferences(myTargetClass.add(method)); - CreateMethodFromUsageFix.doCreate(myTargetClass, method, arguments, PsiSubstitutor.EMPTY, ExpectedTypeInfo.EMPTY_ARRAY, method); - } + method = (PsiMethod) JavaCodeStyleManager.getInstance(project).shortenClassReferences(myTargetClass.add(method)); + CreateMethodFromUsageFix.doCreate(myTargetClass, method, arguments, PsiSubstitutor.EMPTY, ExpectedTypeInfo.EMPTY_ARRAY, method); + } - private PsiMethod createMethod(@Nonnull PsiClass myTargetClass) { - Project project = myTargetClass.getProject(); - JVMElementFactory elementFactory = JVMElementFactories.getFactory(myTargetClass.getLanguage(), project); - if (elementFactory == null) { - elementFactory = JavaPsiFacade.getElementFactory(project); + private PsiMethod createMethod(@Nonnull PsiClass myTargetClass) { + Project project = myTargetClass.getProject(); + JVMElementFactory elementFactory = JVMElementFactories.getFactory(myTargetClass.getLanguage(), project); + if (elementFactory == null) { + elementFactory = JavaPsiFacade.getElementFactory(project); + } + String methodText = mySignature + (myTargetClass.isInterface() ? ";" : "{" + myBody + "}"); + return elementFactory.createMethodFromText(methodText, null); } - String methodText = mySignature + (myTargetClass.isInterface() ? ";" : "{" + myBody + "}"); - return elementFactory.createMethodFromText(methodText, null); - } - @Nullable - public static CreateMethodQuickFix createFix(@Nonnull PsiClass targetClass, @NonNls final String signature, @NonNls final String body) { - CreateMethodQuickFix fix = new CreateMethodQuickFix(targetClass, signature, body); - try { - fix.createMethod(targetClass); - return fix; - } catch (IncorrectOperationException e) { - return null; + @Nullable + public static CreateMethodQuickFix createFix(@Nonnull PsiClass targetClass, String signature, String body) { + CreateMethodQuickFix fix = new CreateMethodQuickFix(targetClass, signature, body); + try { + fix.createMethod(targetClass); + return fix; + } + catch (IncorrectOperationException e) { + return null; + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ExtendsListFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ExtendsListFix.java index 350d5ed706..f255089fdf 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ExtendsListFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ExtendsListFix.java @@ -17,163 +17,172 @@ import com.intellij.java.language.psi.*; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.util.LanguageUndoUtil; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -public class ExtendsListFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(ExtendsListFix.class); - - final PsiClass myClassToExtendFrom; - private final boolean myToAdd; - private final PsiClassType myTypeToExtendFrom; - private final String myName; +import java.util.function.BiFunction; - public ExtendsListFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType typeToExtendFrom, boolean toAdd) { - this(aClass, typeToExtendFrom.resolve(), typeToExtendFrom, toAdd); - } - - public ExtendsListFix(@Nonnull PsiClass aClass, @Nonnull PsiClass classToExtendFrom, boolean toAdd) { - this(aClass, classToExtendFrom, JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory().createType(classToExtendFrom), toAdd); - } +public class ExtendsListFix extends LocalQuickFixAndIntentionActionOnPsiElement { + private static final Logger LOG = Logger.getInstance(ExtendsListFix.class); - private ExtendsListFix(@Nonnull PsiClass aClass, - PsiClass classToExtendFrom, - @Nonnull PsiClassType typeToExtendFrom, - boolean toAdd) { - super(aClass); - myClassToExtendFrom = classToExtendFrom; - myToAdd = toAdd; - myTypeToExtendFrom = typeToExtendFrom; + final PsiClass myClassToExtendFrom; + private final boolean myToAdd; + private final PsiClassType myTypeToExtendFrom; + @Nonnull + private final LocalizeValue myName; - @NonNls final String messageKey; - if (classToExtendFrom != null && aClass.isInterface() == classToExtendFrom.isInterface()) { - messageKey = toAdd ? "add.class.to.extends.list" : "remove.class.from.extends.list"; + public ExtendsListFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType typeToExtendFrom, boolean toAdd) { + this(aClass, typeToExtendFrom.resolve(), typeToExtendFrom, toAdd); } - else { - messageKey = toAdd ? "add.interface.to.implements.list" : "remove.interface.from.implements.list"; - } - - myName = JavaQuickFixBundle.message(messageKey, aClass.getName(), classToExtendFrom == null ? "" : classToExtendFrom instanceof PsiTypeParameter ? classToExtendFrom.getName() - : classToExtendFrom.getQualifiedName()); - } - - @Override - @Nonnull - public String getText() { - return myName; - } + public ExtendsListFix(@Nonnull PsiClass aClass, @Nonnull PsiClass classToExtendFrom, boolean toAdd) { + this( + aClass, + classToExtendFrom, + JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory().createType(classToExtendFrom), + toAdd + ); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("change.extends.list.family"); - } + private ExtendsListFix( + @Nonnull PsiClass aClass, + PsiClass classToExtendFrom, + @Nonnull PsiClassType typeToExtendFrom, + boolean toAdd + ) { + super(aClass); + myClassToExtendFrom = classToExtendFrom; + myToAdd = toAdd; + myTypeToExtendFrom = typeToExtendFrom; + + BiFunction messageKey; + if (classToExtendFrom != null && aClass.isInterface() == classToExtendFrom.isInterface()) { + messageKey = toAdd ? JavaQuickFixLocalize::addClassToExtendsList : JavaQuickFixLocalize::removeClassFromExtendsList; + } + else { + messageKey = + toAdd ? JavaQuickFixLocalize::addInterfaceToImplementsList : JavaQuickFixLocalize::removeInterfaceFromImplementsList; + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - return - myClass.isValid() - && myClass.getManager().isInProject(myClass) - && myClassToExtendFrom != null - && myClassToExtendFrom.isValid() - && !myClassToExtendFrom.hasModifierProperty(PsiModifier.FINAL) - && (myClassToExtendFrom.isInterface() - || !myClass.isInterface() - && myClass.getExtendsList() != null - && myClass.getExtendsList().getReferencedTypes().length == 0 == myToAdd) - ; + myName = messageKey.apply( + aClass.getName(), + classToExtendFrom == null ? "" + : classToExtendFrom instanceof PsiTypeParameter ? classToExtendFrom.getName() : classToExtendFrom.getQualifiedName() + ); + } - } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - invokeImpl(myClass); - LanguageUndoUtil.markPsiFileForUndo(file); - } + @Nonnull + @Override + public LocalizeValue getText() { + return myName; + } - protected void invokeImpl(PsiClass myClass) { - if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) return; - PsiReferenceList extendsList = !(myClass instanceof PsiTypeParameter) && - myClass.isInterface() != myClassToExtendFrom.isInterface() ? - myClass.getImplementsList() : myClass.getExtendsList(); - PsiReferenceList otherList = extendsList == myClass.getImplementsList() ? - myClass.getExtendsList() : myClass.getImplementsList(); - try { - if (extendsList != null) { - modifyList(extendsList, myToAdd, -1); - } - if (otherList != null) { - modifyList(otherList, false, -1); - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + return myClass.isValid() + && myClass.getManager().isInProject(myClass) + && myClassToExtendFrom != null + && myClassToExtendFrom.isValid() + && !myClassToExtendFrom.hasModifierProperty(PsiModifier.FINAL) + && (myClassToExtendFrom.isInterface() + || !myClass.isInterface() + && myClass.getExtendsList() != null + && myClass.getExtendsList().getReferencedTypes().length == 0 == myToAdd); } - catch (IncorrectOperationException e) { - LOG.error(e); + + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + invokeImpl(myClass); + LanguageUndoUtil.markPsiFileForUndo(file); } - } - /** - * @param position to add new class to or -1 if add to the end - */ - PsiReferenceList modifyList(@Nonnull PsiReferenceList extendsList, boolean add, int position) throws IncorrectOperationException { - PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements(); - boolean alreadyExtends = false; - for (PsiJavaCodeReferenceElement referenceElement : referenceElements) { - if (referenceElement.getManager().areElementsEquivalent(myClassToExtendFrom, referenceElement.resolve())) { - alreadyExtends = true; - if (!add) { - referenceElement.delete(); + protected void invokeImpl(PsiClass myClass) { + if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) { + return; + } + PsiReferenceList extendsList = !(myClass instanceof PsiTypeParameter) && myClass.isInterface() != myClassToExtendFrom.isInterface() + ? myClass.getImplementsList() + : myClass.getExtendsList(); + PsiReferenceList otherList = extendsList == myClass.getImplementsList() ? myClass.getExtendsList() : myClass.getImplementsList(); + try { + if (extendsList != null) { + modifyList(extendsList, myToAdd, -1); + } + if (otherList != null) { + modifyList(otherList, false, -1); + } + } + catch (IncorrectOperationException e) { + LOG.error(e); } - } } - PsiReferenceList list = extendsList; - if (add && !alreadyExtends) { - PsiElement anchor; - if (position == -1) { - anchor = referenceElements.length ==0 ? null : referenceElements[referenceElements.length-1]; - } - else if (position == 0) { - anchor = null; - } - else { - anchor = referenceElements[position - 1]; - } - PsiJavaCodeReferenceElement classReferenceElement = - JavaPsiFacade.getInstance(extendsList.getProject()).getElementFactory().createReferenceElementByType(myTypeToExtendFrom); - PsiElement element; - if (anchor == null) { - if (referenceElements.length == 0) { - element = extendsList.add(classReferenceElement); + + /** + * @param position to add new class to or -1 if add to the end + */ + PsiReferenceList modifyList(@Nonnull PsiReferenceList extendsList, boolean add, int position) throws IncorrectOperationException { + PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements(); + boolean alreadyExtends = false; + for (PsiJavaCodeReferenceElement referenceElement : referenceElements) { + if (referenceElement.getManager().areElementsEquivalent(myClassToExtendFrom, referenceElement.resolve())) { + alreadyExtends = true; + if (!add) { + referenceElement.delete(); + } + } } - else { - element = extendsList.addBefore(classReferenceElement, referenceElements[0]); + PsiReferenceList list = extendsList; + if (add && !alreadyExtends) { + PsiElement anchor; + if (position == -1) { + anchor = referenceElements.length == 0 ? null : referenceElements[referenceElements.length - 1]; + } + else if (position == 0) { + anchor = null; + } + else { + anchor = referenceElements[position - 1]; + } + PsiJavaCodeReferenceElement classReferenceElement = + JavaPsiFacade.getInstance(extendsList.getProject()).getElementFactory().createReferenceElementByType(myTypeToExtendFrom); + PsiElement element; + if (anchor == null) { + if (referenceElements.length == 0) { + element = extendsList.add(classReferenceElement); + } + else { + element = extendsList.addBefore(classReferenceElement, referenceElements[0]); + } + } + else { + element = extendsList.addAfter(classReferenceElement, anchor); + } + list = (PsiReferenceList) element.getParent(); } - } - else { - element = extendsList.addAfter(classReferenceElement, anchor); - } - list = (PsiReferenceList) element.getParent(); + return list; } - return list; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/GenerifyFileFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/GenerifyFileFix.java index 190c54ceab..ad947e4183 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/GenerifyFileFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/GenerifyFileFix.java @@ -19,7 +19,7 @@ import consulo.application.Result; import consulo.codeEditor.Editor; import consulo.fileEditor.FileEditorManager; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.WriteCommandAction; import consulo.language.editor.inspection.LocalQuickFix; @@ -28,66 +28,64 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiManager; +import consulo.localize.LocalizeValue; import consulo.project.Project; - import jakarta.annotation.Nonnull; public class GenerifyFileFix implements SyntheticIntentionAction, LocalQuickFix { - private String myFileName; - - @Override - @Nonnull - public String getText() { - return JavaQuickFixBundle.message("generify.text", myFileName); - } + private String myFileName; - @Nonnull - @Override - public String getName() { - return getText(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.generifyText(myFileName); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("generify.family"); - } + @Nonnull + @Override + public LocalizeValue getName() { + return getText(); + } - @Override - public void applyFix(@Nonnull final Project project, @Nonnull final ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - if (element == null) return; - final PsiFile file = element.getContainingFile(); - if (isAvailable(project, null, file)) { - myFileName = file.getName(); - new WriteCommandAction(project) { - @Override - protected void run(Result result) throws Throwable { - invoke(project, FileEditorManager.getInstance(project).getSelectedTextEditor(), file); + @Override + public void applyFix(@Nonnull final Project project, @Nonnull final ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + if (element == null) { + return; + } + final PsiFile file = element.getContainingFile(); + if (isAvailable(project, null, file)) { + myFileName = file.getName(); + new WriteCommandAction(project) { + @Override + protected void run(Result result) throws Throwable { + invoke(project, FileEditorManager.getInstance(project).getSelectedTextEditor(), file); + } + }.execute(); } - }.execute(); } - } - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - if (file != null && file.isValid()) { - myFileName = file.getName(); - return PsiManager.getInstance(project).isInProject(file); - } - else { - return false; + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + if (file != null && file.isValid()) { + myFileName = file.getName(); + return PsiManager.getInstance(project).isInProject(file); + } + else { + return false; + } } - } - @Override - public void invoke(@Nonnull Project project, Editor editor, PsiFile file) { - if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; - new TypeCookAction().getHandler().invoke(project, editor, file, null); - } + @Override + public void invoke(@Nonnull Project project, Editor editor, PsiFile file) { + if (!FileModificationService.getInstance().prepareFileForWrite(file)) { + return; + } + new TypeCookAction().getHandler().invoke(project, editor, file, null); + } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ImplementMethodsFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ImplementMethodsFix.java index f8aba0f7a7..4350b7f3ab 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ImplementMethodsFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ImplementMethodsFix.java @@ -25,13 +25,14 @@ import consulo.codeEditor.Editor; import consulo.externalService.statistic.FeatureUsageTracker; import consulo.ide.impl.idea.ide.util.MemberChooser; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.WriteCommandAction; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.util.ProductivityFeatureNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; @@ -41,79 +42,91 @@ import java.util.List; public class ImplementMethodsFix extends LocalQuickFixAndIntentionActionOnPsiElement { - public ImplementMethodsFix(PsiElement aClass) { - super(aClass); - } - - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message("implement.methods.fix"); - } + public ImplementMethodsFix(PsiElement aClass) { + super(aClass); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("implement.methods.fix"); - } + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.implementMethodsFix(); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - PsiElement myPsiElement = startElement; - return myPsiElement.isValid() && myPsiElement.getManager().isInProject(myPsiElement); - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + PsiElement myPsiElement = startElement; + return myPsiElement.isValid() && myPsiElement.getManager().isInProject(myPsiElement); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable final Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiElement myPsiElement = startElement; + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable final Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiElement myPsiElement = startElement; - if (editor == null || !FileModificationService.getInstance().prepareFileForWrite(myPsiElement.getContainingFile())) return; - if (myPsiElement instanceof PsiEnumConstant) { - final boolean hasClassInitializer = ((PsiEnumConstant)myPsiElement).getInitializingClass() != null; - final MemberChooser chooser = chooseMethodsToImplement(editor, startElement, - ((PsiEnumConstant)myPsiElement).getContainingClass(), hasClassInitializer); - if (chooser == null) return; + if (editor == null || !FileModificationService.getInstance().prepareFileForWrite(myPsiElement.getContainingFile())) { + return; + } + if (myPsiElement instanceof PsiEnumConstant) { + final boolean hasClassInitializer = ((PsiEnumConstant) myPsiElement).getInitializingClass() != null; + final MemberChooser chooser = chooseMethodsToImplement(editor, startElement, + ((PsiEnumConstant) myPsiElement).getContainingClass(), hasClassInitializer + ); + if (chooser == null) { + return; + } - final List selectedElements = chooser.getSelectedElements(); - if (selectedElements == null || selectedElements.isEmpty()) return; + final List selectedElements = chooser.getSelectedElements(); + if (selectedElements == null || selectedElements.isEmpty()) { + return; + } - new WriteCommandAction(project, file) { - @Override - protected void run(final Result result) throws Throwable { - final PsiClass psiClass = ((PsiEnumConstant)myPsiElement).getOrCreateInitializingClass(); - OverrideImplementUtil.overrideOrImplementMethodsInRightPlace(editor, psiClass, selectedElements, chooser.isCopyJavadoc(), - chooser.isInsertOverrideAnnotation()); + new WriteCommandAction(project, file) { + @Override + protected void run(final Result result) throws Throwable { + final PsiClass psiClass = ((PsiEnumConstant) myPsiElement).getOrCreateInitializingClass(); + OverrideImplementUtil.overrideOrImplementMethodsInRightPlace( + editor, + psiClass, + selectedElements, + chooser.isCopyJavadoc(), + chooser.isInsertOverrideAnnotation() + ); + } + }.execute(); + } + else { + OverrideImplementUtil.chooseAndImplementMethods(project, editor, (PsiClass) myPsiElement); } - }.execute(); - } - else { - OverrideImplementUtil.chooseAndImplementMethods(project, editor, (PsiClass)myPsiElement); } - } - - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } - @Nullable - protected static MemberChooser chooseMethodsToImplement(Editor editor, - PsiElement startElement, - PsiClass aClass, - boolean implemented) { - FeatureUsageTracker.getInstance().triggerFeatureUsed(ProductivityFeatureNames.CODEASSISTS_OVERRIDE_IMPLEMENT); + @Nullable + protected static MemberChooser chooseMethodsToImplement( + Editor editor, + PsiElement startElement, + PsiClass aClass, + boolean implemented + ) { + FeatureUsageTracker.getInstance().triggerFeatureUsed(ProductivityFeatureNames.CODEASSISTS_OVERRIDE_IMPLEMENT); - final Collection overrideImplement = OverrideImplementExploreUtil.getMapToOverrideImplement(aClass, true, implemented).values(); - return OverrideImplementUtil - .showOverrideImplementChooser(editor, startElement, true, overrideImplement, ContainerUtil.newArrayList()); - } + final Collection overrideImplement = + OverrideImplementExploreUtil.getMapToOverrideImplement(aClass, true, implemented).values(); + return OverrideImplementUtil + .showOverrideImplementChooser(editor, startElement, true, overrideImplement, ContainerUtil.newArrayList()); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MakeClassInterfaceFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MakeClassInterfaceFix.java index fc67b68bf6..98135fe964 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MakeClassInterfaceFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MakeClassInterfaceFix.java @@ -17,7 +17,7 @@ import com.intellij.java.language.psi.*; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.ast.IElementType; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; @@ -25,86 +25,91 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; public class MakeClassInterfaceFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(MakeClassInterfaceFix.class); - - private final boolean myMakeInterface; - private final String myName; + private static final Logger LOG = Logger.getInstance(MakeClassInterfaceFix.class); - public MakeClassInterfaceFix(PsiClass aClass, final boolean makeInterface) { - super(aClass); - myMakeInterface = makeInterface; - myName = aClass.getName(); - } + private final boolean myMakeInterface; + private final String myName; - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message(myMakeInterface? "make.class.an.interface.text":"make.interface.an.class.text", myName); - } + public MakeClassInterfaceFix(PsiClass aClass, final boolean makeInterface) { + super(aClass); + myMakeInterface = makeInterface; + myName = aClass.getName(); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("make.class.an.interface.family"); - } + @Nonnull + @Override + public LocalizeValue getText() { + return myMakeInterface + ? JavaQuickFixLocalize.makeClassAnInterfaceText(myName) + : JavaQuickFixLocalize.makeInterfaceAnClassText(myName); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; - return myClass.isValid() && myClass.getManager().isInProject(myClass); - } + return myClass.isValid() && myClass.getManager().isInProject(myClass); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - if (!FileModificationService.getInstance().preparePsiElementForWrite(myClass)) return; - try { - final PsiReferenceList extendsList = myMakeInterface? myClass.getExtendsList() : myClass.getImplementsList(); - final PsiReferenceList implementsList = myMakeInterface? myClass.getImplementsList() : myClass.getExtendsList(); - if (extendsList != null) { - for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { - referenceElement.delete(); + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + if (!FileModificationService.getInstance().preparePsiElementForWrite(myClass)) { + return; + } + try { + final PsiReferenceList extendsList = myMakeInterface ? myClass.getExtendsList() : myClass.getImplementsList(); + final PsiReferenceList implementsList = myMakeInterface ? myClass.getImplementsList() : myClass.getExtendsList(); + if (extendsList != null) { + for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { + referenceElement.delete(); + } + if (implementsList != null) { + for (PsiJavaCodeReferenceElement referenceElement : implementsList.getReferenceElements()) { + extendsList.addAfter(referenceElement, null); + referenceElement.delete(); + } + } + } + convertPsiClass(myClass, myMakeInterface); + LanguageUndoUtil.markPsiFileForUndo(file); } - if (implementsList != null) { - for (PsiJavaCodeReferenceElement referenceElement : implementsList.getReferenceElements()) { - extendsList.addAfter(referenceElement, null); - referenceElement.delete(); - } + catch (IncorrectOperationException e) { + LOG.error(e); } - } - convertPsiClass(myClass, myMakeInterface); - LanguageUndoUtil.markPsiFileForUndo(file); - } catch (IncorrectOperationException e) { - LOG.error(e); } - } - private static void convertPsiClass(PsiClass aClass, final boolean makeInterface) throws IncorrectOperationException { - final IElementType lookFor = makeInterface? JavaTokenType.CLASS_KEYWORD : JavaTokenType.INTERFACE_KEYWORD; - final PsiKeyword replaceWith = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory().createKeyword(makeInterface? PsiKeyword.INTERFACE : PsiKeyword.CLASS); - for (PsiElement psiElement : aClass.getChildren()) { - if (psiElement instanceof PsiKeyword) { - final PsiKeyword psiKeyword = (PsiKeyword)psiElement; - if (psiKeyword.getTokenType() == lookFor) { - psiKeyword.replace(replaceWith); - break; + private static void convertPsiClass(PsiClass aClass, final boolean makeInterface) throws IncorrectOperationException { + final IElementType lookFor = makeInterface ? JavaTokenType.CLASS_KEYWORD : JavaTokenType.INTERFACE_KEYWORD; + final PsiKeyword replaceWith = JavaPsiFacade.getInstance(aClass.getProject()) + .getElementFactory() + .createKeyword(makeInterface ? PsiKeyword.INTERFACE : PsiKeyword.CLASS); + for (PsiElement psiElement : aClass.getChildren()) { + if (psiElement instanceof PsiKeyword) { + final PsiKeyword psiKeyword = (PsiKeyword) psiElement; + if (psiKeyword.getTokenType() == lookFor) { + psiKeyword.replace(replaceWith); + break; + } + } } - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodParameterFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodParameterFix.java index 4eb2a8fed0..519c3fb8eb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodParameterFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodParameterFix.java @@ -23,7 +23,7 @@ import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.refactoring.rename.SuggestedNameInfo; @@ -31,114 +31,116 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.util.lang.Comparing; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.ArrayList; import java.util.List; public class MethodParameterFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.quickfix.MethodReturnFix"); + private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.quickfix.MethodReturnFix"); - private final PsiType myParameterType; - private final int myIndex; - private final boolean myFixWholeHierarchy; - private final String myName; + private final PsiType myParameterType; + private final int myIndex; + private final boolean myFixWholeHierarchy; + private final String myName; - public MethodParameterFix(PsiMethod method, PsiType type, int index, boolean fixWholeHierarchy) { - super(method); - myParameterType = type; - myIndex = index; - myFixWholeHierarchy = fixWholeHierarchy; - myName = method.getName(); - } - - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message("fix.parameter.type.text", - myName, - myParameterType.getCanonicalText() ); - } + public MethodParameterFix(PsiMethod method, PsiType type, int index, boolean fixWholeHierarchy) { + super(method); + myParameterType = type; + myIndex = index; + myFixWholeHierarchy = fixWholeHierarchy; + myName = method.getName(); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("fix.parameter.type.family"); - } + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.fixParameterTypeText(myName, myParameterType.getCanonicalText()); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiMethod myMethod = (PsiMethod)startElement; - return myMethod.isValid() - && myMethod.getManager().isInProject(myMethod) - && myParameterType != null - && !TypeConversionUtil.isNullType(myParameterType) - && myMethod.getReturnType() != null - && !Comparing.equal(myParameterType, myMethod.getReturnType()); - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiMethod myMethod = (PsiMethod) startElement; + return myMethod.isValid() + && myMethod.getManager().isInProject(myMethod) + && myParameterType != null + && !TypeConversionUtil.isNullType(myParameterType) + && myMethod.getReturnType() != null + && !Comparing.equal(myParameterType, myMethod.getReturnType()); + } - @Override - public void invoke(@Nonnull final Project project, - @Nonnull final PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiMethod myMethod = (PsiMethod)startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile())) return; - try { - PsiMethod method = myMethod; - if (myFixWholeHierarchy) { - method = myMethod.findDeepestSuperMethod(); - if (method == null) method = myMethod; - } + @Override + public void invoke( + @Nonnull final Project project, + @Nonnull final PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiMethod myMethod = (PsiMethod) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile())) { + return; + } + try { + PsiMethod method = myMethod; + if (myFixWholeHierarchy) { + method = myMethod.findDeepestSuperMethod(); + if (method == null) { + method = myMethod; + } + } - final PsiMethod finalMethod = method; - ChangeSignatureProcessor processor = new ChangeSignatureProcessor(project, - finalMethod, - false, null, - finalMethod.getName(), - finalMethod.getReturnType(), - getNewParametersInfo(finalMethod)); + final PsiMethod finalMethod = method; + ChangeSignatureProcessor processor = new ChangeSignatureProcessor(project, + finalMethod, + false, null, + finalMethod.getName(), + finalMethod.getReturnType(), + getNewParametersInfo(finalMethod) + ); - processor.run(); + processor.run(); - LanguageUndoUtil.markPsiFileForUndo(file); + LanguageUndoUtil.markPsiFileForUndo(file); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } } - catch (IncorrectOperationException e) { - LOG.error(e); - } - } - private ParameterInfoImpl[] getNewParametersInfo(PsiMethod method) throws IncorrectOperationException { - List result = new ArrayList(); - PsiParameter[] parameters = method.getParameterList().getParameters(); - PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory(); - JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(method.getProject()); - SuggestedNameInfo nameInfo = codeStyleManager.suggestVariableName(VariableKind.PARAMETER, null, null, myParameterType); - PsiParameter newParameter = factory.createParameter(nameInfo.names[0], myParameterType); - if (method.getContainingClass().isInterface()) { - PsiUtil.setModifierProperty(newParameter, PsiModifier.FINAL, false); - } + private ParameterInfoImpl[] getNewParametersInfo(PsiMethod method) throws IncorrectOperationException { + List result = new ArrayList(); + PsiParameter[] parameters = method.getParameterList().getParameters(); + PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory(); + JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(method.getProject()); + SuggestedNameInfo nameInfo = codeStyleManager.suggestVariableName(VariableKind.PARAMETER, null, null, myParameterType); + PsiParameter newParameter = factory.createParameter(nameInfo.names[0], myParameterType); + if (method.getContainingClass().isInterface()) { + PsiUtil.setModifierProperty(newParameter, PsiModifier.FINAL, false); + } - for (int i = 0; i < parameters.length; i++) { - PsiParameter parameter = parameters[i]; - if (i == myIndex) { - newParameter.setName(parameter.getName()); - parameter = newParameter; - } - result.add(new ParameterInfoImpl(i, parameter.getName(), parameter.getType())); - } - if (parameters.length == myIndex) { - result.add(new ParameterInfoImpl(-1, newParameter.getName(), newParameter.getType())); + for (int i = 0; i < parameters.length; i++) { + PsiParameter parameter = parameters[i]; + if (i == myIndex) { + newParameter.setName(parameter.getName()); + parameter = newParameter; + } + result.add(new ParameterInfoImpl(i, parameter.getName(), parameter.getType())); + } + if (parameters.length == myIndex) { + result.add(new ParameterInfoImpl(-1, newParameter.getName(), newParameter.getType())); + } + return result.toArray(new ParameterInfoImpl[result.size()]); } - return result.toArray(new ParameterInfoImpl[result.size()]); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodReturnTypeFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodReturnTypeFix.java index cae0129a44..200eaddacc 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodReturnTypeFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MethodReturnTypeFix.java @@ -21,7 +21,7 @@ import consulo.codeEditor.ScrollType; import consulo.document.util.TextRange; import consulo.fileEditor.FileEditorManager; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.intention.HighPriorityAction; @@ -30,356 +30,401 @@ import consulo.language.psi.PsiFile; import consulo.language.psi.scope.LocalSearchScope; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.navigation.OpenFileDescriptor; import consulo.navigation.OpenFileDescriptorFactory; import consulo.project.Project; import consulo.usage.UsageInfo; import consulo.util.lang.Comparing; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class MethodReturnTypeFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction { - private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.quickfix.MethodReturnBooleanFix"); - - private final SmartTypePointer myReturnTypePointer; - private final boolean myFixWholeHierarchy; - private final String myName; - private final String myCanonicalText; - - public MethodReturnTypeFix(@Nonnull PsiMethod method, @Nonnull PsiType returnType, boolean fixWholeHierarchy) { - super(method); - myReturnTypePointer = SmartTypePointerManager.getInstance(method.getProject()).createSmartTypePointer(returnType); - myFixWholeHierarchy = fixWholeHierarchy; - myName = method.getName(); - myCanonicalText = returnType.getCanonicalText(); - } - - - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message("fix.return.type.text", myName, myCanonicalText); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("fix.return.type.family"); - } - - @Override - public boolean isAvailable(@Nonnull Project project, @Nonnull PsiFile file, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) { - final PsiMethod myMethod = (PsiMethod) startElement; - - final PsiType myReturnType = myReturnTypePointer.getType(); - if (myMethod.getManager().isInProject(myMethod) && myReturnType != null && myReturnType.isValid() && !TypeConversionUtil.isNullType(myReturnType)) { - final PsiType returnType = myMethod.getReturnType(); - if (returnType != null && returnType.isValid() && !Comparing.equal(myReturnType, returnType)) { - return PsiTypesUtil.allTypeParametersResolved(myMethod, myReturnType); - } + private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.quickfix.MethodReturnBooleanFix"); + + private final SmartTypePointer myReturnTypePointer; + private final boolean myFixWholeHierarchy; + private final String myName; + private final String myCanonicalText; + + public MethodReturnTypeFix(@Nonnull PsiMethod method, @Nonnull PsiType returnType, boolean fixWholeHierarchy) { + super(method); + myReturnTypePointer = SmartTypePointerManager.getInstance(method.getProject()).createSmartTypePointer(returnType); + myFixWholeHierarchy = fixWholeHierarchy; + myName = method.getName(); + myCanonicalText = returnType.getCanonicalText(); } - return false; - } - - @Override - public void invoke(@Nonnull Project project, @Nonnull PsiFile file, Editor editor, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) { - final PsiMethod myMethod = (PsiMethod) startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile())) { - return; - } - final PsiType myReturnType = myReturnTypePointer.getType(); - if (myReturnType == null) { - return; + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.fixReturnTypeText(myName, myCanonicalText); } - if (myFixWholeHierarchy) { - final PsiMethod superMethod = myMethod.findDeepestSuperMethod(); - final PsiType superReturnType = superMethod == null ? null : superMethod.getReturnType(); - if (superReturnType != null && !Comparing.equal(myReturnType, superReturnType) && !changeClassTypeArgument(myMethod, project, superReturnType, superMethod.getContainingClass(), editor, - myReturnType)) { - return; - } + + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiMethod myMethod = (PsiMethod) startElement; + + final PsiType myReturnType = myReturnTypePointer.getType(); + if (myMethod.getManager().isInProject(myMethod) && myReturnType != null && myReturnType.isValid() && !TypeConversionUtil.isNullType( + myReturnType)) { + final PsiType returnType = myMethod.getReturnType(); + if (returnType != null && returnType.isValid() && !Comparing.equal(myReturnType, returnType)) { + return PsiTypesUtil.allTypeParametersResolved(myMethod, myReturnType); + } + } + return false; } - final List affectedMethods = changeReturnType(myMethod, myReturnType); + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiMethod myMethod = (PsiMethod) startElement; + + if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile())) { + return; + } + final PsiType myReturnType = myReturnTypePointer.getType(); + if (myReturnType == null) { + return; + } + if (myFixWholeHierarchy) { + final PsiMethod superMethod = myMethod.findDeepestSuperMethod(); + final PsiType superReturnType = superMethod == null ? null : superMethod.getReturnType(); + if (superReturnType != null && !Comparing.equal(myReturnType, superReturnType) && !changeClassTypeArgument( + myMethod, + project, + superReturnType, + superMethod.getContainingClass(), + editor, + myReturnType + )) { + return; + } + } - PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - PsiReturnStatement statementToSelect = null; - if (!PsiType.VOID.equals(myReturnType)) { - final ReturnStatementAdder adder = new ReturnStatementAdder(factory, myReturnType); + final List affectedMethods = changeReturnType(myMethod, myReturnType); - for (PsiMethod affectedMethod : affectedMethods) { - PsiReturnStatement statement = adder.addReturnForMethod(file, affectedMethod); - if (statement != null && affectedMethod == myMethod) { - statementToSelect = statement; + PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + PsiReturnStatement statementToSelect = null; + if (!PsiType.VOID.equals(myReturnType)) { + final ReturnStatementAdder adder = new ReturnStatementAdder(factory, myReturnType); + + for (PsiMethod affectedMethod : affectedMethods) { + PsiReturnStatement statement = adder.addReturnForMethod(file, affectedMethod); + if (statement != null && affectedMethod == myMethod) { + statementToSelect = statement; + } + } } - } - } - if (statementToSelect != null) { - Editor editorForMethod = getEditorForMethod(myMethod, project, editor, file); - if (editorForMethod != null) { - selectReturnValueInEditor(statementToSelect, editorForMethod); - } + if (statementToSelect != null) { + Editor editorForMethod = getEditorForMethod(myMethod, project, editor, file); + if (editorForMethod != null) { + selectReturnValueInEditor(statementToSelect, editorForMethod); + } + } } - } - // to clearly separate data - private static class ReturnStatementAdder { - @Nonnull - private final PsiElementFactory factory; - @Nonnull - private final PsiType myTargetType; + // to clearly separate data + private static class ReturnStatementAdder { + @Nonnull + private final PsiElementFactory factory; + @Nonnull + private final PsiType myTargetType; - private ReturnStatementAdder(@Nonnull final PsiElementFactory factory, @Nonnull final PsiType targetType) { - this.factory = factory; - myTargetType = targetType; - } + private ReturnStatementAdder(@Nonnull final PsiElementFactory factory, @Nonnull final PsiType targetType) { + this.factory = factory; + myTargetType = targetType; + } - private PsiReturnStatement addReturnForMethod(final PsiFile file, final PsiMethod method) { - final PsiModifierList modifiers = method.getModifierList(); - if (modifiers.hasModifierProperty(PsiModifier.ABSTRACT) || method.getBody() == null) { - return null; - } + private PsiReturnStatement addReturnForMethod(final PsiFile file, final PsiMethod method) { + final PsiModifierList modifiers = method.getModifierList(); + if (modifiers.hasModifierProperty(PsiModifier.ABSTRACT) || method.getBody() == null) { + return null; + } + + try { + final ConvertReturnStatementsVisitor visitor = new ConvertReturnStatementsVisitor(factory, method, myTargetType); + + ControlFlow controlFlow; + try { + controlFlow = HighlightControlFlowUtil.getControlFlowNoConstantEvaluate(method.getBody()); + } + catch (AnalysisCanceledException e) { + return null; //must be an error + } + PsiReturnStatement returnStatement; + if (ControlFlowUtil.processReturns(controlFlow, visitor)) { + // extra return statement not needed + // get latest modified return statement and select... + returnStatement = visitor.getLatestReturn(); + } + else { + returnStatement = visitor.createReturnInLastStatement(); + } + if (method.getContainingFile() != file) { + LanguageUndoUtil.markPsiFileForUndo(file); + } + return returnStatement; + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + + return null; + } + } - try { - final ConvertReturnStatementsVisitor visitor = new ConvertReturnStatementsVisitor(factory, method, myTargetType); + private static Editor getEditorForMethod(PsiMethod myMethod, @Nonnull final Project project, final Editor editor, final PsiFile file) { - ControlFlow controlFlow; - try { - controlFlow = HighlightControlFlowUtil.getControlFlowNoConstantEvaluate(method.getBody()); - } catch (AnalysisCanceledException e) { - return null; //must be an error - } - PsiReturnStatement returnStatement; - if (ControlFlowUtil.processReturns(controlFlow, visitor)) { - // extra return statement not needed - // get latest modified return statement and select... - returnStatement = visitor.getLatestReturn(); - } else { - returnStatement = visitor.createReturnInLastStatement(); + PsiFile containingFile = myMethod.getContainingFile(); + if (containingFile != file) { + OpenFileDescriptor descriptor = OpenFileDescriptorFactory.getInstance(project).builder(containingFile.getVirtualFile()).build(); + return FileEditorManager.getInstance(project).openTextEditor(descriptor, true); } - if (method.getContainingFile() != file) { - LanguageUndoUtil.markPsiFileForUndo(file); + return editor; + } + + @Nonnull + private PsiMethod[] getChangeRoots(final PsiMethod method, @Nonnull PsiType returnType) { + if (!myFixWholeHierarchy) { + return new PsiMethod[]{method}; } - return returnStatement; - } catch (IncorrectOperationException e) { - LOG.error(e); - } - return null; + final PsiMethod[] methods = method.findDeepestSuperMethods(); + + if (methods.length > 0) { + for (PsiMethod psiMethod : methods) { + if (returnType.equals(psiMethod.getReturnType())) { + return new PsiMethod[]{method}; + } + } + return methods; + } + // no - only base + return new PsiMethod[]{method}; } - } - private static Editor getEditorForMethod(PsiMethod myMethod, @Nonnull final Project project, final Editor editor, final PsiFile file) { + @Nonnull + private List changeReturnType(final PsiMethod method, @Nonnull final PsiType returnType) { + final PsiMethod[] methods = getChangeRoots(method, returnType); + + final MethodSignatureChangeVisitor methodSignatureChangeVisitor = new MethodSignatureChangeVisitor(); + for (PsiMethod targetMethod : methods) { + methodSignatureChangeVisitor.addBase(targetMethod); + ChangeSignatureProcessor processor = new UsagesAwareChangeSignatureProcessor( + method.getProject(), + targetMethod, + false, + null, + myName, + returnType, + RemoveUnusedParameterFix + .getNewParametersInfo(targetMethod, null), + methodSignatureChangeVisitor + ); + processor.run(); + } - PsiFile containingFile = myMethod.getContainingFile(); - if (containingFile != file) { - OpenFileDescriptor descriptor = OpenFileDescriptorFactory.getInstance(project).builder(containingFile.getVirtualFile()).build(); - return FileEditorManager.getInstance(project).openTextEditor(descriptor, true); + return methodSignatureChangeVisitor.getAffectedMethods(); } - return editor; - } - @Nonnull - private PsiMethod[] getChangeRoots(final PsiMethod method, @Nonnull PsiType returnType) { - if (!myFixWholeHierarchy) { - return new PsiMethod[]{method}; - } + private static class MethodSignatureChangeVisitor implements UsageVisitor { + private final List myAffectedMethods; - final PsiMethod[] methods = method.findDeepestSuperMethods(); + private MethodSignatureChangeVisitor() { + myAffectedMethods = new ArrayList<>(); + } - if (methods.length > 0) { - for (PsiMethod psiMethod : methods) { - if (returnType.equals(psiMethod.getReturnType())) { - return new PsiMethod[]{method}; + public void addBase(final PsiMethod baseMethod) { + myAffectedMethods.add(baseMethod); } - } - return methods; - } - // no - only base - return new PsiMethod[]{method}; - } - - @Nonnull - private List changeReturnType(final PsiMethod method, @Nonnull final PsiType returnType) { - final PsiMethod[] methods = getChangeRoots(method, returnType); - - final MethodSignatureChangeVisitor methodSignatureChangeVisitor = new MethodSignatureChangeVisitor(); - for (PsiMethod targetMethod : methods) { - methodSignatureChangeVisitor.addBase(targetMethod); - ChangeSignatureProcessor processor = new UsagesAwareChangeSignatureProcessor(method.getProject(), targetMethod, false, null, myName, returnType, RemoveUnusedParameterFix - .getNewParametersInfo(targetMethod, null), methodSignatureChangeVisitor); - processor.run(); - } - return methodSignatureChangeVisitor.getAffectedMethods(); - } + @Override + public void visit(final UsageInfo usage) { + if (usage instanceof OverriderUsageInfo) { + myAffectedMethods.add(((OverriderUsageInfo) usage).getOverridingMethod()); + } + } - private static class MethodSignatureChangeVisitor implements UsageVisitor { - private final List myAffectedMethods; + public List getAffectedMethods() { + return myAffectedMethods; + } - private MethodSignatureChangeVisitor() { - myAffectedMethods = new ArrayList<>(); + @Override + public void preprocessCovariantOverriders(final List covariantOverriderInfos) { + for (Iterator usageInfoIterator = covariantOverriderInfos.iterator(); usageInfoIterator.hasNext(); ) { + final UsageInfo info = usageInfoIterator.next(); + if (info instanceof OverriderUsageInfo) { + final OverriderUsageInfo overrideUsage = (OverriderUsageInfo) info; + if (myAffectedMethods.contains(overrideUsage.getOverridingMethod())) { + usageInfoIterator.remove(); + } + } + } + } } - public void addBase(final PsiMethod baseMethod) { - myAffectedMethods.add(baseMethod); - } + private interface UsageVisitor { + void visit(final UsageInfo usage); - @Override - public void visit(final UsageInfo usage) { - if (usage instanceof OverriderUsageInfo) { - myAffectedMethods.add(((OverriderUsageInfo) usage).getOverridingMethod()); - } + void preprocessCovariantOverriders(final List covariantOverriderInfos); } - public List getAffectedMethods() { - return myAffectedMethods; - } + private static class UsagesAwareChangeSignatureProcessor extends ChangeSignatureProcessor { + private final UsageVisitor myUsageVisitor; + + private UsagesAwareChangeSignatureProcessor( + final Project project, + final PsiMethod method, + final boolean generateDelegate, + @PsiModifier.ModifierConstant final String newVisibility, + final String newName, + final PsiType newType, + @Nonnull final ParameterInfoImpl[] parameterInfo, + final UsageVisitor usageVisitor + ) { + super(project, method, generateDelegate, newVisibility, newName, newType, parameterInfo); + myUsageVisitor = usageVisitor; + } - @Override - public void preprocessCovariantOverriders(final List covariantOverriderInfos) { - for (Iterator usageInfoIterator = covariantOverriderInfos.iterator(); usageInfoIterator.hasNext(); ) { - final UsageInfo info = usageInfoIterator.next(); - if (info instanceof OverriderUsageInfo) { - final OverriderUsageInfo overrideUsage = (OverriderUsageInfo) info; - if (myAffectedMethods.contains(overrideUsage.getOverridingMethod())) { - usageInfoIterator.remove(); - } + @Override + protected void preprocessCovariantOverriders(final List covariantOverriderInfos) { + myUsageVisitor.preprocessCovariantOverriders(covariantOverriderInfos); } - } - } - } - - private interface UsageVisitor { - void visit(final UsageInfo usage); - - void preprocessCovariantOverriders(final List covariantOverriderInfos); - } - - private static class UsagesAwareChangeSignatureProcessor extends ChangeSignatureProcessor { - private final UsageVisitor myUsageVisitor; - - private UsagesAwareChangeSignatureProcessor(final Project project, - final PsiMethod method, - final boolean generateDelegate, - @PsiModifier.ModifierConstant final String newVisibility, - final String newName, - final PsiType newType, - @Nonnull final ParameterInfoImpl[] parameterInfo, - final UsageVisitor usageVisitor) { - super(project, method, generateDelegate, newVisibility, newName, newType, parameterInfo); - myUsageVisitor = usageVisitor; - } - @Override - protected void preprocessCovariantOverriders(final List covariantOverriderInfos) { - myUsageVisitor.preprocessCovariantOverriders(covariantOverriderInfos); + @Override + protected void performRefactoring(@Nonnull final UsageInfo[] usages) { + super.performRefactoring(usages); + + for (UsageInfo usage : usages) { + myUsageVisitor.visit(usage); + } + } } - @Override - protected void performRefactoring(@Nonnull final UsageInfo[] usages) { - super.performRefactoring(usages); + static void selectReturnValueInEditor(final PsiReturnStatement returnStatement, final Editor editor) { + final PsiExpression returnValue = returnStatement.getReturnValue(); + LOG.assertTrue(returnValue != null, returnStatement); + TextRange range = returnValue.getTextRange(); + int offset = range.getStartOffset(); - for (UsageInfo usage : usages) { - myUsageVisitor.visit(usage); - } - } - } - - static void selectReturnValueInEditor(final PsiReturnStatement returnStatement, final Editor editor) { - final PsiExpression returnValue = returnStatement.getReturnValue(); - LOG.assertTrue(returnValue != null, returnStatement); - TextRange range = returnValue.getTextRange(); - int offset = range.getStartOffset(); - - editor.getCaretModel().moveToOffset(offset); - editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); - editor.getSelectionModel().setSelection(range.getEndOffset(), range.getStartOffset()); - } - - private static boolean changeClassTypeArgument(PsiMethod myMethod, Project project, PsiType superReturnType, PsiClass superClass, Editor editor, PsiType returnType) { - if (superClass == null || !superClass.hasTypeParameters()) { - return true; - } - final PsiClass superReturnTypeClass = PsiUtil.resolveClassInType(superReturnType); - if (superReturnTypeClass == null || !(superReturnTypeClass instanceof PsiTypeParameter || superReturnTypeClass.hasTypeParameters())) { - return true; + editor.getCaretModel().moveToOffset(offset); + editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); + editor.getSelectionModel().setSelection(range.getEndOffset(), range.getStartOffset()); } - final PsiClass derivedClass = myMethod.getContainingClass(); - if (derivedClass == null) { - return true; - } + private static boolean changeClassTypeArgument( + PsiMethod myMethod, + Project project, + PsiType superReturnType, + PsiClass superClass, + Editor editor, + PsiType returnType + ) { + if (superClass == null || !superClass.hasTypeParameters()) { + return true; + } + final PsiClass superReturnTypeClass = PsiUtil.resolveClassInType(superReturnType); + if (superReturnTypeClass == null || !(superReturnTypeClass instanceof PsiTypeParameter || superReturnTypeClass.hasTypeParameters())) { + return true; + } - final PsiReferenceParameterList referenceParameterList = findTypeArgumentsList(superClass, derivedClass); - if (referenceParameterList == null) { - return true; - } + final PsiClass derivedClass = myMethod.getContainingClass(); + if (derivedClass == null) { + return true; + } - final PsiElement resolve = ((PsiJavaCodeReferenceElement) referenceParameterList.getParent()).resolve(); - if (!(resolve instanceof PsiClass)) { - return true; - } - final PsiClass baseClass = (PsiClass) resolve; + final PsiReferenceParameterList referenceParameterList = findTypeArgumentsList(superClass, derivedClass); + if (referenceParameterList == null) { + return true; + } + + final PsiElement resolve = ((PsiJavaCodeReferenceElement) referenceParameterList.getParent()).resolve(); + if (!(resolve instanceof PsiClass)) { + return true; + } + final PsiClass baseClass = (PsiClass) resolve; - if (returnType instanceof PsiPrimitiveType) { - returnType = ((PsiPrimitiveType) returnType).getBoxedType(derivedClass); + if (returnType instanceof PsiPrimitiveType) { + returnType = ((PsiPrimitiveType) returnType).getBoxedType(derivedClass); + } + + final PsiSubstitutor superClassSubstitutor = + TypeConversionUtil.getSuperClassSubstitutor(superClass, baseClass, PsiSubstitutor.EMPTY); + final PsiType superReturnTypeInBaseClassType = superClassSubstitutor.substitute(superReturnType); + final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(project).getResolveHelper(); + final PsiSubstitutor psiSubstitutor = resolveHelper.inferTypeArguments(PsiTypesUtil.filterUnusedTypeParameters( + superReturnTypeInBaseClassType, + baseClass.getTypeParameters() + ), new + PsiType[]{superReturnTypeInBaseClassType}, new PsiType[]{returnType}, PsiUtil.getLanguageLevel(superClass)); + + final TypeMigrationRules rules = new TypeMigrationRules(project); + final PsiSubstitutor compoundSubstitutor = + TypeConversionUtil.getSuperClassSubstitutor(superClass, derivedClass, PsiSubstitutor.EMPTY).putAll(psiSubstitutor); + rules.setBoundScope(new LocalSearchScope(derivedClass)); + TypeMigrationProcessor.runHighlightingTypeMigration( + project, + editor, + rules, + referenceParameterList, + JavaPsiFacade.getElementFactory(project).createType(baseClass, compoundSubstitutor) + ); + + return false; } - final PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, baseClass, PsiSubstitutor.EMPTY); - final PsiType superReturnTypeInBaseClassType = superClassSubstitutor.substitute(superReturnType); - final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(project).getResolveHelper(); - final PsiSubstitutor psiSubstitutor = resolveHelper.inferTypeArguments(PsiTypesUtil.filterUnusedTypeParameters(superReturnTypeInBaseClassType, baseClass.getTypeParameters()), new - PsiType[]{superReturnTypeInBaseClassType}, new PsiType[]{returnType}, PsiUtil.getLanguageLevel(superClass)); - - final TypeMigrationRules rules = new TypeMigrationRules(project); - final PsiSubstitutor compoundSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, derivedClass, PsiSubstitutor.EMPTY).putAll(psiSubstitutor); - rules.setBoundScope(new LocalSearchScope(derivedClass)); - TypeMigrationProcessor.runHighlightingTypeMigration(project, editor, rules, referenceParameterList, JavaPsiFacade.getElementFactory(project).createType(baseClass, compoundSubstitutor)); - - return false; - } - - @Nullable - private static PsiReferenceParameterList findTypeArgumentsList(final PsiClass superClass, final PsiClass derivedClass) { - PsiReferenceParameterList referenceParameterList = null; - if (derivedClass instanceof PsiAnonymousClass) { - referenceParameterList = ((PsiAnonymousClass) derivedClass).getBaseClassReference().getParameterList(); - } else { - final PsiReferenceList implementsList = derivedClass.getImplementsList(); - if (implementsList != null) { - referenceParameterList = extractReferenceParameterList(superClass, implementsList); - } - if (referenceParameterList == null) { - final PsiReferenceList extendsList = derivedClass.getExtendsList(); - if (extendsList != null) { - referenceParameterList = extractReferenceParameterList(superClass, extendsList); + @Nullable + private static PsiReferenceParameterList findTypeArgumentsList(final PsiClass superClass, final PsiClass derivedClass) { + PsiReferenceParameterList referenceParameterList = null; + if (derivedClass instanceof PsiAnonymousClass) { + referenceParameterList = ((PsiAnonymousClass) derivedClass).getBaseClassReference().getParameterList(); } - } + else { + final PsiReferenceList implementsList = derivedClass.getImplementsList(); + if (implementsList != null) { + referenceParameterList = extractReferenceParameterList(superClass, implementsList); + } + if (referenceParameterList == null) { + final PsiReferenceList extendsList = derivedClass.getExtendsList(); + if (extendsList != null) { + referenceParameterList = extractReferenceParameterList(superClass, extendsList); + } + } + } + return referenceParameterList; } - return referenceParameterList; - } - - @Nullable - private static PsiReferenceParameterList extractReferenceParameterList(final PsiClass superClass, final PsiReferenceList extendsList) { - for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { - final PsiElement element = referenceElement.resolve(); - if (element instanceof PsiClass && InheritanceUtil.isInheritorOrSelf((PsiClass) element, superClass, true)) { - return referenceElement.getParameterList(); - } + + @Nullable + private static PsiReferenceParameterList extractReferenceParameterList(final PsiClass superClass, final PsiReferenceList extendsList) { + for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { + final PsiElement element = referenceElement.resolve(); + if (element instanceof PsiClass && InheritanceUtil.isInheritorOrSelf((PsiClass) element, superClass, true)) { + return referenceElement.getParameterList(); + } + } + return null; } - return null; - } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java index 3c07e1bf41..6d9c775744 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java @@ -23,7 +23,6 @@ import com.intellij.java.language.util.VisibilityUtil; import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; @@ -55,7 +54,8 @@ public class ModifierFix extends LocalQuickFixAndIntentionActionOnPsiElement { private final String myModifier; private final boolean myShouldHave; private final boolean myShowContainingClass; - private final String myName; + @Nonnull + private final LocalizeValue myName; private final SmartPsiElementPointer myVariable; @RequiredReadAction @@ -92,12 +92,12 @@ public ModifierFix( @Nonnull @Override - public String getText() { + public LocalizeValue getText() { return myName; } @RequiredReadAction - private String format(PsiVariable variable, PsiModifierList modifierList) { + private LocalizeValue format(PsiVariable variable, PsiModifierList modifierList) { String name; PsiElement parent = variable == null ? modifierList == null ? null : modifierList.getParent() : variable; if (parent instanceof PsiClass psiClass) { @@ -126,14 +126,8 @@ else if (parent instanceof PsiClassInitializer classInitializer) { String modifierText = VisibilityUtil.toPresentableText(myModifier); return myShouldHave - ? JavaQuickFixLocalize.addModifierFix(name, modifierText).get() - : JavaQuickFixLocalize.removeModifierFix(name, modifierText).get(); - } - - @Nonnull - @Override - public String getFamilyName() { - return JavaQuickFixLocalize.fixModifiersFamily().get(); + ? JavaQuickFixLocalize.addModifierFix(name, modifierText) + : JavaQuickFixLocalize.removeModifierFix(name, modifierText); } @Override diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MoveBoundClassToFrontFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MoveBoundClassToFrontFix.java index 2f90f2ac1e..1f50236fb0 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MoveBoundClassToFrontFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/MoveBoundClassToFrontFix.java @@ -20,72 +20,75 @@ import com.intellij.java.language.psi.PsiClassType; import com.intellij.java.language.psi.PsiReferenceList; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.util.LanguageUndoUtil; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; public class MoveBoundClassToFrontFix extends ExtendsListFix { - private static final Logger LOG = Logger.getInstance(MoveBoundClassToFrontFix.class); - private final String myName; - - public MoveBoundClassToFrontFix(PsiClass aClass, PsiClassType classToExtendFrom) { - super(aClass, classToExtendFrom, true); - myName = JavaQuickFixBundle.message("move.bound.class.to.front.fix.text", - HighlightUtil.formatClass(myClassToExtendFrom), - HighlightUtil.formatClass(aClass)); - } - - @Override - @Nonnull - public String getText() { - return myName; - } + private static final Logger LOG = Logger.getInstance(MoveBoundClassToFrontFix.class); + @Nonnull + private final LocalizeValue myName; - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("move.class.in.extend.list.family"); - } + public MoveBoundClassToFrontFix(PsiClass aClass, PsiClassType classToExtendFrom) { + super(aClass, classToExtendFrom, true); + myName = JavaQuickFixLocalize.moveBoundClassToFrontFixText( + HighlightUtil.formatClass(myClassToExtendFrom), + HighlightUtil.formatClass(aClass) + ); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) return; - PsiReferenceList extendsList = myClass.getExtendsList(); - if (extendsList == null) return; - try { - modifyList(extendsList, false, -1); - modifyList(extendsList, true, 0); + @Nonnull + @Override + public LocalizeValue getText() { + return myName; } - catch (IncorrectOperationException e) { - LOG.error(e); + + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(myClass.getContainingFile())) { + return; + } + PsiReferenceList extendsList = myClass.getExtendsList(); + if (extendsList == null) { + return; + } + try { + modifyList(extendsList, false, -1); + modifyList(extendsList, true, 0); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + LanguageUndoUtil.markPsiFileForUndo(file); } - LanguageUndoUtil.markPsiFileForUndo(file); - } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiClass myClass = (PsiClass)startElement; - return - myClass.isValid() - && myClass.getManager().isInProject(myClass) - && myClassToExtendFrom != null - && myClassToExtendFrom.isValid() - ; - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiClass myClass = (PsiClass) startElement; + return + myClass.isValid() + && myClass.getManager().isInProject(myClass) + && myClassToExtendFrom != null + && myClassToExtendFrom.isValid(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/OrderEntryFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/OrderEntryFix.java index 64fa5bed95..05c27ce271 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/OrderEntryFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/OrderEntryFix.java @@ -38,6 +38,7 @@ import consulo.language.psi.*; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.module.Module; import consulo.module.content.ModuleFileIndex; import consulo.module.content.ModuleRootManager; @@ -68,17 +69,14 @@ * @author cdr */ public abstract class OrderEntryFix implements SyntheticIntentionAction, LocalQuickFix { - protected OrderEntryFix() { - } - @Override public boolean startInWriteAction() { return true; } - @Override @Nonnull - public String getName() { + @Override + public LocalizeValue getName() { return getText(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/PullAsAbstractUpFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/PullAsAbstractUpFix.java index 869ae716d1..144e9550af 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/PullAsAbstractUpFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/PullAsAbstractUpFix.java @@ -34,6 +34,7 @@ import consulo.language.psi.PsiFile; import consulo.language.psi.PsiManager; import consulo.language.psi.resolve.PsiElementProcessor; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.ui.ex.popup.JBPopup; @@ -43,139 +44,160 @@ import java.util.LinkedHashSet; public class PullAsAbstractUpFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(PullAsAbstractUpFix.class); - private final String myName; - - public PullAsAbstractUpFix(PsiMethod psiMethod, final String name) { - super(psiMethod); - myName = name; - } - - @Override - @Nonnull - public String getText() { - return myName; - } - - @Override - @Nonnull - public String getFamilyName() { - return "Pull up"; - } - - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - return startElement instanceof PsiMethod && startElement.isValid() && ((PsiMethod) startElement).getContainingClass() != null; - } - - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiMethod method = (PsiMethod) startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(method.getContainingFile())) return; - - final PsiClass containingClass = method.getContainingClass(); - LOG.assertTrue(containingClass != null); - - PsiManager manager = containingClass.getManager(); - if (containingClass instanceof PsiAnonymousClass) { - final PsiClassType baseClassType = ((PsiAnonymousClass) containingClass).getBaseClassType(); - final PsiClass baseClass = baseClassType.resolve(); - if (baseClass != null && manager.isInProject(baseClass)) { - pullUp(method, containingClass, baseClass); - } - } else { - final LinkedHashSet classesToPullUp = new LinkedHashSet(); - collectClassesToPullUp(manager, classesToPullUp, containingClass.getExtendsListTypes()); - collectClassesToPullUp(manager, classesToPullUp, containingClass.getImplementsListTypes()); - - if (classesToPullUp.size() == 0) { - //check visibility - new ExtractInterfaceHandler().invoke(project, new PsiElement[]{containingClass}, null); - } else if (classesToPullUp.size() == 1) { - pullUp(method, containingClass, classesToPullUp.iterator().next()); - } else if (editor != null) { - JBPopup popup = PopupNavigationUtil.getPsiElementPopup(classesToPullUp.toArray(new PsiClass[classesToPullUp.size()]), new PsiClassListCellRenderer(), - "Choose super class", - new PsiElementProcessor() { - @Override - public boolean execute(@Nonnull PsiClass aClass) { - pullUp(method, containingClass, aClass); - return false; - } - }, classesToPullUp.iterator().next()); - - EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); - } + private static final Logger LOG = Logger.getInstance(PullAsAbstractUpFix.class); + @Nonnull + private final LocalizeValue myName; + + public PullAsAbstractUpFix(PsiMethod psiMethod, @Nonnull LocalizeValue name) { + super(psiMethod); + myName = name; + } + + @Nonnull + @Override + public LocalizeValue getText() { + return myName; + } + + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + return startElement instanceof PsiMethod && startElement.isValid() && ((PsiMethod) startElement).getContainingClass() != null; } - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiMethod method = (PsiMethod) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(method.getContainingFile())) { + return; + } + + final PsiClass containingClass = method.getContainingClass(); + LOG.assertTrue(containingClass != null); + + PsiManager manager = containingClass.getManager(); + if (containingClass instanceof PsiAnonymousClass) { + final PsiClassType baseClassType = ((PsiAnonymousClass) containingClass).getBaseClassType(); + final PsiClass baseClass = baseClassType.resolve(); + if (baseClass != null && manager.isInProject(baseClass)) { + pullUp(method, containingClass, baseClass); + } + } + else { + final LinkedHashSet classesToPullUp = new LinkedHashSet(); + collectClassesToPullUp(manager, classesToPullUp, containingClass.getExtendsListTypes()); + collectClassesToPullUp(manager, classesToPullUp, containingClass.getImplementsListTypes()); + + if (classesToPullUp.size() == 0) { + //check visibility + new ExtractInterfaceHandler().invoke(project, new PsiElement[]{containingClass}, null); + } + else if (classesToPullUp.size() == 1) { + pullUp(method, containingClass, classesToPullUp.iterator().next()); + } + else if (editor != null) { + JBPopup popup = PopupNavigationUtil.getPsiElementPopup( + classesToPullUp.toArray(new PsiClass[classesToPullUp.size()]), + new PsiClassListCellRenderer(), + "Choose super class", + new PsiElementProcessor() { + @Override + public boolean execute(@Nonnull PsiClass aClass) { + pullUp(method, containingClass, aClass); + return false; + } + }, + classesToPullUp.iterator().next() + ); + + EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); + } + } + } - private static void collectClassesToPullUp(PsiManager manager, LinkedHashSet classesToPullUp, PsiClassType[] extendsListTypes) { - for (PsiClassType extendsListType : extendsListTypes) { - PsiClass resolve = extendsListType.resolve(); - if (resolve != null && manager.isInProject(resolve)) { - classesToPullUp.add(resolve); - } + private static void collectClassesToPullUp( + PsiManager manager, + LinkedHashSet classesToPullUp, + PsiClassType[] extendsListTypes + ) { + for (PsiClassType extendsListType : extendsListTypes) { + PsiClass resolve = extendsListType.resolve(); + if (resolve != null && manager.isInProject(resolve)) { + classesToPullUp.add(resolve); + } + } } - } - - private static void pullUp(PsiMethod method, PsiClass containingClass, PsiClass baseClass) { - if (!FileModificationService.getInstance().prepareFileForWrite(baseClass.getContainingFile())) return; - final MemberInfo memberInfo = new MemberInfo(method); - memberInfo.setChecked(true); - memberInfo.setToAbstract(true); - new PullUpProcessor(containingClass, baseClass, new MemberInfo[]{memberInfo}, new DocCommentPolicy(DocCommentPolicy.ASIS)).run(); - } - - @Override - public boolean startInWriteAction() { - return false; - } - - public static void registerQuickFix(@Nonnull PsiMethod methodWithOverrides, @Nonnull QuickFixActionRegistrar registrar) { - PsiClass containingClass = methodWithOverrides.getContainingClass(); - if (containingClass == null) return; - final PsiManager manager = containingClass.getManager(); - - boolean canBePulledUp = true; - String name = "Pull method \'" + methodWithOverrides.getName() + "\' up"; - if (containingClass instanceof PsiAnonymousClass) { - final PsiClassType baseClassType = ((PsiAnonymousClass) containingClass).getBaseClassType(); - final PsiClass baseClass = baseClassType.resolve(); - if (baseClass == null) return; - if (!manager.isInProject(baseClass)) return; - if (!baseClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - name = "Pull method \'" + methodWithOverrides.getName() + "\' up and make it abstract"; - } - } else { - final LinkedHashSet classesToPullUp = new LinkedHashSet(); - collectClassesToPullUp(manager, classesToPullUp, containingClass.getExtendsListTypes()); - collectClassesToPullUp(manager, classesToPullUp, containingClass.getImplementsListTypes()); - if (classesToPullUp.size() == 0) { - name = "Extract method \'" + methodWithOverrides.getName() + "\' to new interface"; - canBePulledUp = false; - } else if (classesToPullUp.size() == 1) { - final PsiClass baseClass = classesToPullUp.iterator().next(); - name = "Pull method \'" + methodWithOverrides.getName() + "\' to \'" + baseClass.getName() + "\'"; - if (!baseClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - name += " and make it abstract"; + + private static void pullUp(PsiMethod method, PsiClass containingClass, PsiClass baseClass) { + if (!FileModificationService.getInstance().prepareFileForWrite(baseClass.getContainingFile())) { + return; } - } - registrar.register(new RunRefactoringAction(new ExtractInterfaceHandler(), "Extract interface")); - registrar.register(new RunRefactoringAction(new ExtractSuperclassHandler(), "Extract superclass")); + final MemberInfo memberInfo = new MemberInfo(method); + memberInfo.setChecked(true); + memberInfo.setToAbstract(true); + new PullUpProcessor(containingClass, baseClass, new MemberInfo[]{memberInfo}, new DocCommentPolicy(DocCommentPolicy.ASIS)).run(); + } + + @Override + public boolean startInWriteAction() { + return false; } + public static void registerQuickFix(@Nonnull PsiMethod methodWithOverrides, @Nonnull QuickFixActionRegistrar registrar) { + PsiClass containingClass = methodWithOverrides.getContainingClass(); + if (containingClass == null) { + return; + } + final PsiManager manager = containingClass.getManager(); + + boolean canBePulledUp = true; + LocalizeValue name = LocalizeValue.localizeTODO("Pull method \'" + methodWithOverrides.getName() + "\' up"); + if (containingClass instanceof PsiAnonymousClass) { + final PsiClassType baseClassType = ((PsiAnonymousClass) containingClass).getBaseClassType(); + final PsiClass baseClass = baseClassType.resolve(); + if (baseClass == null) { + return; + } + if (!manager.isInProject(baseClass)) { + return; + } + if (!baseClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + name = LocalizeValue.localizeTODO("Pull method \'" + methodWithOverrides.getName() + "\' up and make it abstract"); + } + } + else { + final LinkedHashSet classesToPullUp = new LinkedHashSet(); + collectClassesToPullUp(manager, classesToPullUp, containingClass.getExtendsListTypes()); + collectClassesToPullUp(manager, classesToPullUp, containingClass.getImplementsListTypes()); + if (classesToPullUp.size() == 0) { + name = LocalizeValue.localizeTODO("Extract method \'" + methodWithOverrides.getName() + "\' to new interface"); + canBePulledUp = false; + } + else if (classesToPullUp.size() == 1) { + final PsiClass baseClass = classesToPullUp.iterator().next(); + name = LocalizeValue.localizeTODO( + "Pull method \'" + methodWithOverrides.getName() + "\' to \'" + baseClass.getName() + "\'" + + (baseClass.isAbstract() ? "" : " and make it abstract") + ); + } + registrar.register(new RunRefactoringAction(new ExtractInterfaceHandler(), "Extract interface")); + registrar.register(new RunRefactoringAction(new ExtractSuperclassHandler(), "Extract superclass")); + } - if (canBePulledUp) { - registrar.register(new RunRefactoringAction(new JavaPullUpHandler(), "Pull members up")); + + if (canBePulledUp) { + registrar.register(new RunRefactoringAction(new JavaPullUpHandler(), "Pull members up")); + } + registrar.register(new PullAsAbstractUpFix(methodWithOverrides, name)); } - registrar.register(new PullAsAbstractUpFix(methodWithOverrides, name)); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveTypeArgumentsFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveTypeArgumentsFix.java index d074327cfd..47331619ed 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveTypeArgumentsFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveTypeArgumentsFix.java @@ -15,66 +15,65 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import consulo.language.editor.intention.HighPriorityAction; -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; -import consulo.logging.Logger; -import consulo.codeEditor.Editor; -import consulo.project.Project; -import consulo.language.psi.PsiElement; -import consulo.language.psi.PsiFile; import com.intellij.java.language.psi.PsiJavaCodeReferenceElement; import com.intellij.java.language.psi.PsiReferenceParameterList; import com.intellij.java.language.psi.PsiTypeElement; import com.intellij.java.language.psi.PsiVariable; +import consulo.codeEditor.Editor; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import consulo.language.editor.intention.HighPriorityAction; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; +import consulo.logging.Logger; +import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; /** - * User: anna - * Date: 1/18/12 + * @author anna + * @since 2012-01-18 */ public class RemoveTypeArgumentsFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction { - private static final Logger LOGGER = Logger.getInstance(RemoveTypeArgumentsFix.class); + private static final Logger LOGGER = Logger.getInstance(RemoveTypeArgumentsFix.class); - public RemoveTypeArgumentsFix(@Nullable PsiElement element) { - super(element); - } - - @Nonnull - @Override - public String getText() { - return "Remove type arguments"; - } + public RemoveTypeArgumentsFix(@Nullable PsiElement element) { + super(element); + } - @Nonnull - @Override - public String getFamilyName() { - return getText(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO("Remove type arguments"); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - return startElement instanceof PsiVariable && startElement.isValid() && ((PsiVariable)startElement).getTypeElement() != null; - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + return startElement instanceof PsiVariable && startElement.isValid() && ((PsiVariable) startElement).getTypeElement() != null; + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiVariable psiVariable = (PsiVariable)startElement; - final PsiTypeElement typeElement = psiVariable.getTypeElement(); - LOGGER.assertTrue(typeElement != null); - final PsiJavaCodeReferenceElement referenceElement = typeElement.getInnermostComponentReferenceElement(); - if (referenceElement != null) { - final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); - if (parameterList != null) { - parameterList.delete(); - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiVariable psiVariable = (PsiVariable) startElement; + final PsiTypeElement typeElement = psiVariable.getTypeElement(); + LOGGER.assertTrue(typeElement != null); + final PsiJavaCodeReferenceElement referenceElement = typeElement.getInnermostComponentReferenceElement(); + if (referenceElement != null) { + final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); + if (parameterList != null) { + parameterList.delete(); + } + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedParameterFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedParameterFix.java index 9d703bd9c2..f7d10a1e6b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedParameterFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedParameterFix.java @@ -15,94 +15,93 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import java.util.ArrayList; -import java.util.List; - -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; - +import com.intellij.java.impl.refactoring.changeSignature.ChangeSignatureProcessor; +import com.intellij.java.impl.refactoring.changeSignature.ParameterInfoImpl; +import com.intellij.java.language.psi.PsiMethod; +import com.intellij.java.language.psi.PsiParameter; +import consulo.codeEditor.Editor; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; -import consulo.codeEditor.Editor; -import consulo.project.Project; -import consulo.util.lang.Comparing; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiParameter; -import com.intellij.java.impl.refactoring.changeSignature.ChangeSignatureProcessor; -import com.intellij.java.impl.refactoring.changeSignature.ParameterInfoImpl; -import consulo.java.analysis.impl.JavaQuickFixBundle; - -public class RemoveUnusedParameterFix extends LocalQuickFixAndIntentionActionOnPsiElement { +import consulo.localize.LocalizeValue; +import consulo.project.Project; +import consulo.util.lang.Comparing; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; - private final String myName; +import java.util.ArrayList; +import java.util.List; - public RemoveUnusedParameterFix(PsiParameter parameter) { - super(parameter); - myName = parameter.getName(); - } +public class RemoveUnusedParameterFix extends LocalQuickFixAndIntentionActionOnPsiElement { + private final String myName; - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message("remove.unused.parameter.text", myName); - } + public RemoveUnusedParameterFix(PsiParameter parameter) { + super(parameter); + myName = parameter.getName(); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("remove.unused.parameter.family"); - } + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.removeUnusedParameterText(myName); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiParameter myParameter = (PsiParameter)startElement; - return - myParameter.isValid() - && myParameter.getDeclarationScope() instanceof PsiMethod - && myParameter.getManager().isInProject(myParameter); - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiParameter myParameter = (PsiParameter) startElement; + return myParameter.isValid() + && myParameter.getDeclarationScope() instanceof PsiMethod + && myParameter.getManager().isInProject(myParameter); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiParameter myParameter = (PsiParameter)startElement; - if (!FileModificationService.getInstance().prepareFileForWrite(myParameter.getContainingFile())) return; - removeReferences(myParameter); - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiParameter myParameter = (PsiParameter) startElement; + if (!FileModificationService.getInstance().prepareFileForWrite(myParameter.getContainingFile())) { + return; + } + removeReferences(myParameter); + } - private static void removeReferences(PsiParameter parameter) { - PsiMethod method = (PsiMethod) parameter.getDeclarationScope(); - ChangeSignatureProcessor processor = new ChangeSignatureProcessor(parameter.getProject(), - method, - false, null, - method.getName(), - method.getReturnType(), - getNewParametersInfo(method, parameter)); - processor.run(); - } + private static void removeReferences(PsiParameter parameter) { + PsiMethod method = (PsiMethod) parameter.getDeclarationScope(); + ChangeSignatureProcessor processor = new ChangeSignatureProcessor(parameter.getProject(), + method, + false, null, + method.getName(), + method.getReturnType(), + getNewParametersInfo(method, parameter) + ); + processor.run(); + } - public static ParameterInfoImpl[] getNewParametersInfo(PsiMethod method, PsiParameter parameterToRemove) { - List result = new ArrayList(); - PsiParameter[] parameters = method.getParameterList().getParameters(); - for (int i = 0; i < parameters.length; i++) { - PsiParameter parameter = parameters[i]; - if (!Comparing.equal(parameter, parameterToRemove)) { - result.add(new ParameterInfoImpl(i, parameter.getName(), parameter.getType())); - } + public static ParameterInfoImpl[] getNewParametersInfo(PsiMethod method, PsiParameter parameterToRemove) { + List result = new ArrayList(); + PsiParameter[] parameters = method.getParameterList().getParameters(); + for (int i = 0; i < parameters.length; i++) { + PsiParameter parameter = parameters[i]; + if (!Comparing.equal(parameter, parameterToRemove)) { + result.add(new ParameterInfoImpl(i, parameter.getName(), parameter.getType())); + } + } + return result.toArray(new ParameterInfoImpl[result.size()]); } - return result.toArray(new ParameterInfoImpl[result.size()]); - } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceInaccessibleFieldWithGetterSetterFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceInaccessibleFieldWithGetterSetterFix.java index 75546d3dc4..fd329cfee8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceInaccessibleFieldWithGetterSetterFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceInaccessibleFieldWithGetterSetterFix.java @@ -23,62 +23,61 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; public class ReplaceInaccessibleFieldWithGetterSetterFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private final String myMethodName; - private final boolean myIsSetter; - - public ReplaceInaccessibleFieldWithGetterSetterFix(@Nonnull PsiElement element, @Nonnull PsiMethod getter, boolean isSetter) { - super(element); - myMethodName = getter.getName(); - myIsSetter = isSetter; - } + private final String myMethodName; + private final boolean myIsSetter; - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - PsiReferenceExpression place = (PsiReferenceExpression)startElement; - if (!FileModificationService.getInstance().preparePsiElementForWrite(place)) return; - String qualifier = null; - final PsiExpression qualifierExpression = place.getQualifierExpression(); - if (qualifierExpression != null) { - qualifier = qualifierExpression.getText(); - } - PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); - PsiMethodCallExpression callExpression; - final String call = (qualifier != null ? qualifier + "." : "") + myMethodName; - if (!myIsSetter) { - callExpression = (PsiMethodCallExpression)elementFactory.createExpressionFromText(call + "()", null); - callExpression = (PsiMethodCallExpression)CodeStyleManager.getInstance(project).reformat(callExpression); - place.replace(callExpression); - } else { - PsiElement parent = PsiTreeUtil.skipParentsOfType(place, PsiParenthesizedExpression.class); - if (parent instanceof PsiAssignmentExpression) { - final PsiExpression rExpression = ((PsiAssignmentExpression)parent).getRExpression(); - final String argList = rExpression != null ? rExpression.getText() : ""; - callExpression = (PsiMethodCallExpression)elementFactory.createExpressionFromText(call + "(" + argList + ")", null); - callExpression = (PsiMethodCallExpression)CodeStyleManager.getInstance(project).reformat(callExpression); - parent.replace(callExpression); - } + public ReplaceInaccessibleFieldWithGetterSetterFix(@Nonnull PsiElement element, @Nonnull PsiMethod getter, boolean isSetter) { + super(element); + myMethodName = getter.getName(); + myIsSetter = isSetter; } - } - @Nonnull - @Override - public String getText() { - return myIsSetter ? "Replace with setter" : "Replace with getter"; - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + PsiReferenceExpression place = (PsiReferenceExpression) startElement; + if (!FileModificationService.getInstance().preparePsiElementForWrite(place)) { + return; + } + String qualifier = null; + final PsiExpression qualifierExpression = place.getQualifierExpression(); + if (qualifierExpression != null) { + qualifier = qualifierExpression.getText(); + } + PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); + PsiMethodCallExpression callExpression; + final String call = (qualifier != null ? qualifier + "." : "") + myMethodName; + if (!myIsSetter) { + callExpression = (PsiMethodCallExpression) elementFactory.createExpressionFromText(call + "()", null); + callExpression = (PsiMethodCallExpression) CodeStyleManager.getInstance(project).reformat(callExpression); + place.replace(callExpression); + } + else { + PsiElement parent = PsiTreeUtil.skipParentsOfType(place, PsiParenthesizedExpression.class); + if (parent instanceof PsiAssignmentExpression) { + final PsiExpression rExpression = ((PsiAssignmentExpression) parent).getRExpression(); + final String argList = rExpression != null ? rExpression.getText() : ""; + callExpression = (PsiMethodCallExpression) elementFactory.createExpressionFromText(call + "(" + argList + ")", null); + callExpression = (PsiMethodCallExpression) CodeStyleManager.getInstance(project).reformat(callExpression); + parent.replace(callExpression); + } + } + } - @Nonnull - @Override - public String getFamilyName() { - return "Replace with getter/setter"; - } + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO(myIsSetter ? "Replace with setter" : "Replace with getter"); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplacePrimitiveWithBoxedTypeAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplacePrimitiveWithBoxedTypeAction.java index f52ea7ca40..2c9fd5b80c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplacePrimitiveWithBoxedTypeAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplacePrimitiveWithBoxedTypeAction.java @@ -15,89 +15,83 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import jakarta.annotation.Nonnull; - -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; -import consulo.logging.Logger; +import com.intellij.java.language.psi.*; import consulo.codeEditor.Editor; -import consulo.project.Project; -import com.intellij.java.language.psi.JavaPsiFacade; -import com.intellij.java.language.psi.PsiClassType; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiPrimitiveType; -import com.intellij.java.language.psi.PsiType; -import com.intellij.java.language.psi.PsiTypeElement; -import com.intellij.java.language.psi.PsiWildcardType; +import consulo.localize.LocalizeValue; +import consulo.logging.Logger; +import consulo.project.Project; +import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; /** * User: anna */ public class ReplacePrimitiveWithBoxedTypeAction extends LocalQuickFixAndIntentionActionOnPsiElement { - private final String myPrimitiveName; - private final String myBoxedTypeName; - private static final Logger LOG = Logger.getInstance(ReplacePrimitiveWithBoxedTypeAction.class); - - public ReplacePrimitiveWithBoxedTypeAction(@Nonnull PsiTypeElement element, @Nonnull String typeName, @Nonnull String boxedTypeName) { - super(element); - myPrimitiveName = typeName; - myBoxedTypeName = boxedTypeName; - } + private final String myPrimitiveName; + private final String myBoxedTypeName; + private static final Logger LOG = Logger.getInstance(ReplacePrimitiveWithBoxedTypeAction.class); - @Nonnull - @Override - public String getText() { - return "Convert '" + myPrimitiveName + "' to '" + myBoxedTypeName + "'"; - } + public ReplacePrimitiveWithBoxedTypeAction(@Nonnull PsiTypeElement element, @Nonnull String typeName, @Nonnull String boxedTypeName) { + super(element); + myPrimitiveName = typeName; + myBoxedTypeName = boxedTypeName; + } - @Nonnull - @Override - public String getFamilyName() { - return getText(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return LocalizeValue.localizeTODO("Convert '" + myPrimitiveName + "' to '" + myBoxedTypeName + "'"); + } - @Override - public boolean isAvailable(@Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - if (startElement instanceof PsiTypeElement) { - PsiType type = ((PsiTypeElement)startElement).getType(); - if (type instanceof PsiWildcardType) { - type = ((PsiWildcardType)type).getBound(); - } - if (type instanceof PsiPrimitiveType) { - return ((PsiPrimitiveType)type).getBoxedType(startElement) != null; - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + if (startElement instanceof PsiTypeElement) { + PsiType type = ((PsiTypeElement) startElement).getType(); + if (type instanceof PsiWildcardType) { + type = ((PsiWildcardType) type).getBound(); + } + if (type instanceof PsiPrimitiveType) { + return ((PsiPrimitiveType) type).getBoxedType(startElement) != null; + } + } + return false; } - return false; - } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiType type = ((PsiTypeElement)startElement).getType(); - PsiType boxedType; - if (type instanceof PsiPrimitiveType) { - boxedType = ((PsiPrimitiveType)type).getBoxedType(startElement); - } else { - LOG.assertTrue(type instanceof PsiWildcardType); - final PsiWildcardType wildcardType = (PsiWildcardType)type; - final PsiClassType boxedBound = ((PsiPrimitiveType)wildcardType.getBound()).getBoxedType(startElement); - LOG.assertTrue(boxedBound != null); - boxedType = wildcardType.isExtends() ? PsiWildcardType.createExtends(startElement.getManager(), boxedBound) - : PsiWildcardType.createSuper(startElement.getManager(), boxedBound); + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiType type = ((PsiTypeElement) startElement).getType(); + PsiType boxedType; + if (type instanceof PsiPrimitiveType) { + boxedType = ((PsiPrimitiveType) type).getBoxedType(startElement); + } + else { + LOG.assertTrue(type instanceof PsiWildcardType); + final PsiWildcardType wildcardType = (PsiWildcardType) type; + final PsiClassType boxedBound = ((PsiPrimitiveType) wildcardType.getBound()).getBoxedType(startElement); + LOG.assertTrue(boxedBound != null); + boxedType = wildcardType.isExtends() ? PsiWildcardType.createExtends(startElement.getManager(), boxedBound) + : PsiWildcardType.createSuper(startElement.getManager(), boxedBound); + } + LOG.assertTrue(boxedType != null); + startElement.replace(JavaPsiFacade.getElementFactory(project).createTypeElement(boxedType)); } - LOG.assertTrue(boxedType != null); - startElement.replace(JavaPsiFacade.getElementFactory(project).createTypeElement(boxedType)); - } - @Override - public boolean startInWriteAction() { - return true; - } + @Override + public boolean startInWriteAction() { + return true; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/SafeDeleteFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/SafeDeleteFix.java index b2d51a5c7d..4c04a01cfe 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/SafeDeleteFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/SafeDeleteFix.java @@ -15,51 +15,53 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; - -import consulo.language.editor.FileModificationService; import com.intellij.java.analysis.impl.codeInsight.daemon.impl.analysis.HighlightMessageUtil; -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.java.language.psi.PsiSubstitutor; +import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; -import consulo.project.Project; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; +import consulo.language.editor.FileModificationService; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import consulo.language.editor.refactoring.safeDelete.SafeDeleteHandler; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiSubstitutor; -import consulo.language.editor.refactoring.safeDelete.SafeDeleteHandler; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.localize.LocalizeValue; +import consulo.project.Project; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; public class SafeDeleteFix extends LocalQuickFixAndIntentionActionOnPsiElement { - public SafeDeleteFix(@Nonnull PsiElement element) { - super(element); - } - - @Override - @Nonnull - public String getText() { - PsiElement startElement = getStartElement(); - return JavaQuickFixBundle.message("safe.delete.text", startElement == null ? "" : HighlightMessageUtil.getSymbolName(startElement, PsiSubstitutor.EMPTY)); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("safe.delete.family"); - } + public SafeDeleteFix(@Nonnull PsiElement element) { + super(element); + } - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; - SafeDeleteHandler.invoke(project, new PsiElement[]{startElement}, false); - } + @Nonnull + @Override + @RequiredReadAction + public LocalizeValue getText() { + PsiElement startElement = getStartElement(); + return JavaQuickFixLocalize.safeDeleteText( + startElement == null ? "" + : HighlightMessageUtil.getSymbolName(startElement, PsiSubstitutor.EMPTY) + ); + } - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + if (!FileModificationService.getInstance().prepareFileForWrite(file)) { + return; + } + SafeDeleteHandler.invoke(project, new PsiElement[]{startElement}, false); + } + @Override + public boolean startInWriteAction() { + return false; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ShowModulePropertiesFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ShowModulePropertiesFix.java index 9ae94b542e..34326f17b7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ShowModulePropertiesFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ShowModulePropertiesFix.java @@ -18,6 +18,7 @@ import consulo.ide.setting.ShowSettingsUtil; import consulo.language.editor.inspection.IntentionAndQuickFixAction; import consulo.language.editor.intention.SyntheticIntentionAction; +import consulo.localize.LocalizeValue; import consulo.ui.ex.action.ActionManager; import consulo.ui.ex.action.AnAction; import consulo.ui.ex.action.IdeActions; @@ -32,43 +33,37 @@ import jakarta.annotation.Nullable; public class ShowModulePropertiesFix extends IntentionAndQuickFixAction implements SyntheticIntentionAction { - private final String myModuleName; + private final String myModuleName; - public ShowModulePropertiesFix(@Nonnull PsiElement context) { - this(ModuleUtilCore.findModuleForPsiElement(context)); - } + public ShowModulePropertiesFix(@Nonnull PsiElement context) { + this(ModuleUtilCore.findModuleForPsiElement(context)); + } - public ShowModulePropertiesFix(@Nullable Module module) { - myModuleName = module == null ? null : module.getName(); - } + public ShowModulePropertiesFix(@Nullable Module module) { + myModuleName = module == null ? null : module.getName(); + } - @Nonnull - @Override - public String getName() { - AnAction action = ActionManager.getInstance().getAction(IdeActions.MODULE_SETTINGS); - return action.getTemplatePresentation().getText(); - } + @Nonnull + @Override + public LocalizeValue getName() { + AnAction action = ActionManager.getInstance().getAction(IdeActions.MODULE_SETTINGS); + return action.getTemplatePresentation().getTextValue(); + } - @Override - @Nonnull - public String getFamilyName() { - return getText(); - } + @Override + public boolean isAvailable(@Nonnull final Project project, final Editor editor, final PsiFile file) { + return myModuleName != null; + } - @Override - public boolean isAvailable(@Nonnull final Project project, final Editor editor, final PsiFile file) { - return myModuleName != null; - } + @Override + public void applyFix(@Nonnull Project project, PsiFile file, @Nullable Editor editor) { + ShowSettingsUtil.getInstance().showProjectStructureDialog(project, projectStructureSelector -> { + projectStructureSelector.select(myModuleName, null, true); + }); + } - @Override - public void applyFix(@Nonnull Project project, PsiFile file, @Nullable Editor editor) { - ShowSettingsUtil.getInstance().showProjectStructureDialog(project, projectStructureSelector -> { - projectStructureSelector.select(myModuleName, null, true); - }); - } - - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/UnwrapSwitchLabelFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/UnwrapSwitchLabelFix.java index 0c129bfc8c..4eb2ac816c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/UnwrapSwitchLabelFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/UnwrapSwitchLabelFix.java @@ -11,89 +11,93 @@ import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.lang.ObjectUtil; -import org.jetbrains.annotations.Nls; - import jakarta.annotation.Nonnull; + import java.util.List; import java.util.Objects; public class UnwrapSwitchLabelFix implements LocalQuickFix { - @Nls(capitalization = Nls.Capitalization.Sentence) - @Nonnull - @Override - public String getFamilyName() { - return "Remove unreachable branches"; - } - - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiExpression label = ObjectUtil.tryCast(descriptor.getStartElement(), PsiExpression.class); - if (label == null) { - return; - } - PsiSwitchLabelStatementBase labelStatement = PsiImplUtil.getSwitchLabel(label); - if (labelStatement == null) { - return; + @Nonnull + @Override + public LocalizeValue getName() { + return LocalizeValue.localizeTODO("Remove unreachable branches"); } - PsiSwitchBlock block = labelStatement.getEnclosingSwitchBlock(); - if (block == null) { - return; - } - List labels = PsiTreeUtil.getChildrenOfTypeAsList(block.getBody(), PsiSwitchLabelStatementBase.class); - boolean shouldKeepDefault = block instanceof PsiSwitchExpression && - !(labelStatement instanceof PsiSwitchLabeledRuleStatement && - ((PsiSwitchLabeledRuleStatement) labelStatement).getBody() instanceof PsiExpressionStatement); - for (PsiSwitchLabelStatementBase otherLabel : labels) { - if (otherLabel == labelStatement || (shouldKeepDefault && otherLabel.isDefaultCase())) { - continue; - } - DeleteSwitchLabelFix.deleteLabel(otherLabel); - } - for (PsiExpression expression : Objects.requireNonNull(labelStatement.getCaseValues()).getExpressions()) { - if (expression != label) { - new CommentTracker().deleteAndRestoreComments(expression); - } - } - tryUnwrap(labelStatement, block); - } - public void tryUnwrap(PsiSwitchLabelStatementBase labelStatement, PsiSwitchBlock block) { - if (block instanceof PsiSwitchStatement) { - BreakConverter converter = BreakConverter.from(block); - if (converter == null) { - return; - } - converter.process(); - unwrapStatement(labelStatement, (PsiSwitchStatement) block); - } else { - UnwrapSwitchStatementFix.unwrapExpression((PsiSwitchExpression) block); + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiExpression label = ObjectUtil.tryCast(descriptor.getStartElement(), PsiExpression.class); + if (label == null) { + return; + } + PsiSwitchLabelStatementBase labelStatement = PsiImplUtil.getSwitchLabel(label); + if (labelStatement == null) { + return; + } + PsiSwitchBlock block = labelStatement.getEnclosingSwitchBlock(); + if (block == null) { + return; + } + List labels = PsiTreeUtil.getChildrenOfTypeAsList(block.getBody(), PsiSwitchLabelStatementBase.class); + boolean shouldKeepDefault = block instanceof PsiSwitchExpression && + !(labelStatement instanceof PsiSwitchLabeledRuleStatement && + ((PsiSwitchLabeledRuleStatement) labelStatement).getBody() instanceof PsiExpressionStatement); + for (PsiSwitchLabelStatementBase otherLabel : labels) { + if (otherLabel == labelStatement || (shouldKeepDefault && otherLabel.isDefaultCase())) { + continue; + } + DeleteSwitchLabelFix.deleteLabel(otherLabel); + } + for (PsiExpression expression : Objects.requireNonNull(labelStatement.getCaseValues()).getExpressions()) { + if (expression != label) { + new CommentTracker().deleteAndRestoreComments(expression); + } + } + tryUnwrap(labelStatement, block); } - } - private static void unwrapStatement(PsiSwitchLabelStatementBase labelStatement, PsiSwitchStatement statement) { - PsiCodeBlock block = statement.getBody(); - PsiStatement body = - labelStatement instanceof PsiSwitchLabeledRuleStatement ? ((PsiSwitchLabeledRuleStatement) labelStatement).getBody() : null; - if (body == null) { - new CommentTracker().deleteAndRestoreComments(labelStatement); - } else if (body instanceof PsiBlockStatement) { - block = ((PsiBlockStatement) body).getCodeBlock(); - } else { - new CommentTracker().replaceAndRestoreComments(labelStatement, body); + public void tryUnwrap(PsiSwitchLabelStatementBase labelStatement, PsiSwitchBlock block) { + if (block instanceof PsiSwitchStatement) { + BreakConverter converter = BreakConverter.from(block); + if (converter == null) { + return; + } + converter.process(); + unwrapStatement(labelStatement, (PsiSwitchStatement) block); + } + else { + UnwrapSwitchStatementFix.unwrapExpression((PsiSwitchExpression) block); + } } - PsiCodeBlock parent = ObjectUtil.tryCast(statement.getParent(), PsiCodeBlock.class); - CommentTracker ct = new CommentTracker(); - if (parent != null && !BlockUtils.containsConflictingDeclarations(Objects.requireNonNull(block), parent)) { - ct.grabComments(statement); - ct.markUnchanged(block); - ct.insertCommentsBefore(statement); - BlockUtils.inlineCodeBlock(statement, block); - } else if (block != null) { - ct.replaceAndRestoreComments(statement, ct.text(block)); - } else { - ct.deleteAndRestoreComments(statement); + + private static void unwrapStatement(PsiSwitchLabelStatementBase labelStatement, PsiSwitchStatement statement) { + PsiCodeBlock block = statement.getBody(); + PsiStatement body = + labelStatement instanceof PsiSwitchLabeledRuleStatement ? ((PsiSwitchLabeledRuleStatement) labelStatement).getBody() : null; + if (body == null) { + new CommentTracker().deleteAndRestoreComments(labelStatement); + } + else if (body instanceof PsiBlockStatement) { + block = ((PsiBlockStatement) body).getCodeBlock(); + } + else { + new CommentTracker().replaceAndRestoreComments(labelStatement, body); + } + PsiCodeBlock parent = ObjectUtil.tryCast(statement.getParent(), PsiCodeBlock.class); + CommentTracker ct = new CommentTracker(); + if (parent != null && !BlockUtils.containsConflictingDeclarations(Objects.requireNonNull(block), parent)) { + ct.grabComments(statement); + ct.markUnchanged(block); + ct.insertCommentsBefore(statement); + BlockUtils.inlineCodeBlock(statement, block); + } + else if (block != null) { + ct.replaceAndRestoreComments(statement, ct.text(block)); + } + else { + ct.deleteAndRestoreComments(statement); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/VariableTypeFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/VariableTypeFix.java index b8bb77c706..5ccc2a3cca 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/VariableTypeFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/VariableTypeFix.java @@ -24,7 +24,7 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.application.ApplicationManager; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.WriteCommandAction; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; @@ -33,6 +33,7 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.usage.UsageViewUtil; @@ -42,109 +43,129 @@ import java.util.ArrayList; public class VariableTypeFix extends LocalQuickFixAndIntentionActionOnPsiElement { - static final Logger LOG = Logger.getInstance(VariableTypeFix.class); + static final Logger LOG = Logger.getInstance(VariableTypeFix.class); - private final PsiType myReturnType; - protected final String myName; + private final PsiType myReturnType; + protected final String myName; - public VariableTypeFix(@Nonnull PsiVariable variable, PsiType toReturn) { - super(variable); - myReturnType = GenericsUtil.getVariableTypeByExpressionType(toReturn); - myName = variable.getName(); - } - - @Nonnull - @Override - public String getText() { - return JavaQuickFixBundle.message("fix.variable.type.text", UsageViewUtil.getType(getStartElement()), myName, getReturnType().getCanonicalText()); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("fix.variable.type.family"); - } - - @Override - public boolean startInWriteAction() { - return false; - } - - @Override - public boolean isAvailable(@Nonnull Project project, @Nonnull PsiFile file, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) { - final PsiVariable myVariable = (PsiVariable) startElement; - return myVariable.isValid() && myVariable.getTypeElement() != null && myVariable.getManager().isInProject(myVariable) && getReturnType() != null && getReturnType().isValid() && - !TypeConversionUtil.isNullType(getReturnType()) && !TypeConversionUtil.isVoidType(getReturnType()); - } + public VariableTypeFix(@Nonnull PsiVariable variable, PsiType toReturn) { + super(variable); + myReturnType = GenericsUtil.getVariableTypeByExpressionType(toReturn); + myName = variable.getName(); + } - @Override - public void invoke(@Nonnull final Project project, - @Nonnull final PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) { - final PsiVariable myVariable = (PsiVariable) startElement; - if (changeMethodSignatureIfNeeded(myVariable)) { - return; + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.fixVariableTypeText( + UsageViewUtil.getType(getStartElement()), + myName, + getReturnType().getCanonicalText() + ); } - if (!FileModificationService.getInstance().prepareFileForWrite(myVariable.getContainingFile())) { - return; + + @Override + public boolean startInWriteAction() { + return false; } - new WriteCommandAction.Simple(project, getText(), file) { - @Override - protected void run() throws Throwable { - try { - myVariable.normalizeDeclaration(); - final PsiTypeElement typeElement = myVariable.getTypeElement(); - LOG.assertTrue(typeElement != null, myVariable.getClass()); - final PsiTypeElement newTypeElement = JavaPsiFacade.getInstance(file.getProject()).getElementFactory().createTypeElement(getReturnType()); - typeElement.replace(newTypeElement); - JavaCodeStyleManager.getInstance(project).shortenClassReferences(myVariable); - LanguageUndoUtil.markPsiFileForUndo(file); - } catch (IncorrectOperationException e) { - LOG.error(e); - } - } - }.execute(); - } + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiVariable myVariable = (PsiVariable) startElement; + return myVariable.isValid() + && myVariable.getTypeElement() != null + && myVariable.getManager().isInProject(myVariable) + && getReturnType() != null + && getReturnType().isValid() + && !TypeConversionUtil.isNullType(getReturnType()) + && !TypeConversionUtil.isVoidType(getReturnType()); + } - private boolean changeMethodSignatureIfNeeded(PsiVariable myVariable) { - if (myVariable instanceof PsiParameter) { - final PsiElement scope = ((PsiParameter) myVariable).getDeclarationScope(); - if (scope instanceof PsiMethod) { - final PsiMethod method = (PsiMethod) scope; - final PsiMethod psiMethod = SuperMethodWarningUtil.checkSuperMethod(method, RefactoringLocalize.toRefactor().get()); - if (psiMethod == null) { - return true; - } - final int parameterIndex = method.getParameterList().getParameterIndex((PsiParameter) myVariable); - if (!FileModificationService.getInstance().prepareFileForWrite(psiMethod.getContainingFile())) { - return true; + @Override + public void invoke( + @Nonnull final Project project, + @Nonnull final PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiVariable myVariable = (PsiVariable) startElement; + if (changeMethodSignatureIfNeeded(myVariable)) { + return; } - final ArrayList infos = new ArrayList(); - int i = 0; - for (PsiParameter parameter : psiMethod.getParameterList().getParameters()) { - final boolean changeType = i == parameterIndex; - infos.add(new ParameterInfoImpl(i++, parameter.getName(), changeType ? getReturnType() : parameter.getType())); + if (!FileModificationService.getInstance().prepareFileForWrite(myVariable.getContainingFile())) { + return; } + new WriteCommandAction.Simple(project, getText().get(), file) { + @Override + protected void run() throws Throwable { + try { + myVariable.normalizeDeclaration(); + final PsiTypeElement typeElement = myVariable.getTypeElement(); + LOG.assertTrue(typeElement != null, myVariable.getClass()); + final PsiTypeElement newTypeElement = + JavaPsiFacade.getInstance(file.getProject()).getElementFactory().createTypeElement(getReturnType()); + typeElement.replace(newTypeElement); + JavaCodeStyleManager.getInstance(project).shortenClassReferences(myVariable); + LanguageUndoUtil.markPsiFileForUndo(file); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + } + }.execute(); + } + + private boolean changeMethodSignatureIfNeeded(PsiVariable myVariable) { + if (myVariable instanceof PsiParameter) { + final PsiElement scope = ((PsiParameter) myVariable).getDeclarationScope(); + if (scope instanceof PsiMethod) { + final PsiMethod method = (PsiMethod) scope; + final PsiMethod psiMethod = SuperMethodWarningUtil.checkSuperMethod(method, RefactoringLocalize.toRefactor().get()); + if (psiMethod == null) { + return true; + } + final int parameterIndex = method.getParameterList().getParameterIndex((PsiParameter) myVariable); + if (!FileModificationService.getInstance().prepareFileForWrite(psiMethod.getContainingFile())) { + return true; + } + final ArrayList infos = new ArrayList(); + int i = 0; + for (PsiParameter parameter : psiMethod.getParameterList().getParameters()) { + final boolean changeType = i == parameterIndex; + infos.add(new ParameterInfoImpl(i++, parameter.getName(), changeType ? getReturnType() : parameter.getType())); + } - if (!ApplicationManager.getApplication().isUnitTestMode()) { - final JavaChangeSignatureDialog dialog = new JavaChangeSignatureDialog(psiMethod.getProject(), psiMethod, false, myVariable); - dialog.setParameterInfos(infos); - dialog.show(); - } else { - ChangeSignatureProcessor processor = new ChangeSignatureProcessor(psiMethod.getProject(), psiMethod, false, null, psiMethod.getName(), psiMethod.getReturnType(), - infos.toArray(new ParameterInfoImpl[infos.size()])); - processor.run(); + if (!ApplicationManager.getApplication().isUnitTestMode()) { + final JavaChangeSignatureDialog dialog = + new JavaChangeSignatureDialog(psiMethod.getProject(), psiMethod, false, myVariable); + dialog.setParameterInfos(infos); + dialog.show(); + } + else { + ChangeSignatureProcessor processor = new ChangeSignatureProcessor( + psiMethod.getProject(), + psiMethod, + false, + null, + psiMethod.getName(), + psiMethod.getReturnType(), + infos.toArray(new ParameterInfoImpl[infos.size()]) + ); + processor.run(); + } + return true; + } } - return true; - } + return false; } - return false; - } - protected PsiType getReturnType() { - return myReturnType; - } + protected PsiType getReturnType() { + return myReturnType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/WrapLongWithMathToIntExactFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/WrapLongWithMathToIntExactFix.java index 963c550610..0bfb4a5614 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/WrapLongWithMathToIntExactFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/WrapLongWithMathToIntExactFix.java @@ -15,132 +15,122 @@ */ package com.intellij.java.impl.codeInsight.daemon.impl.quickfix; -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; - import com.intellij.java.analysis.impl.codeInsight.daemon.impl.quickfix.ArgumentFixerActionFactory; import com.intellij.java.analysis.impl.codeInsight.daemon.impl.quickfix.MethodArgumentFix; -import org.jetbrains.annotations.Nls; -import consulo.language.editor.intention.HighPriorityAction; -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.util.PsiUtil; import consulo.codeEditor.Editor; -import consulo.project.Project; -import com.intellij.java.language.psi.JavaPsiFacade; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; +import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; +import consulo.language.editor.intention.HighPriorityAction; import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiExpression; -import com.intellij.java.language.psi.PsiExpressionList; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiPrimitiveType; -import com.intellij.java.language.psi.PsiType; -import com.intellij.java.language.psi.util.PsiUtil; import consulo.language.util.IncorrectOperationException; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.localize.LocalizeValue; +import consulo.project.Project; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; /** * @author Dmitry Batkovich */ -public class WrapLongWithMathToIntExactFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction -{ - public final static MyMethodArgumentFixerFactory REGISTAR = new MyMethodArgumentFixerFactory(); - - private final PsiType myType; - - public WrapLongWithMathToIntExactFix(final PsiType type, final @Nonnull PsiExpression expression) - { - super(expression); - myType = type; - } - - @Nonnull - @Override - public String getText() - { - return getFamilyName(); - } - - @Override - public void invoke(@Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement) - { - startElement.replace(getModifiedExpression(startElement)); - } - - @Override - public boolean isAvailable(@Nonnull Project project, @Nonnull PsiFile file, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) - { - return startElement.isValid() && - startElement.getManager().isInProject(startElement) && - PsiUtil.isLanguageLevel8OrHigher(startElement) && - areSameTypes(myType, PsiType.INT) && - areSameTypes(((PsiExpression) startElement).getType(), PsiType.LONG); - } - - private static boolean areSameTypes(@Nullable PsiType type, @Nonnull PsiPrimitiveType expected) - { - return !(type == null || - !type.isValid() || - (!type.equals(expected) && !expected.getBoxedTypeName().equals(type.getCanonicalText(false)))); - } - - @Nls - @Nonnull - @Override - public String getFamilyName() - { - return JavaQuickFixBundle.message("wrap.long.with.math.to.int.text"); - } - - private static PsiElement getModifiedExpression(PsiElement expression) - { - return JavaPsiFacade.getElementFactory(expression.getProject()).createExpressionFromText("java.lang.Math.toIntExact(" + expression.getText() + ")", expression); - } - - private static class MyMethodArgumentFix extends MethodArgumentFix implements HighPriorityAction - { - - protected MyMethodArgumentFix(@Nonnull PsiExpressionList list, int i, @Nonnull PsiType toType, @Nonnull ArgumentFixerActionFactory fixerActionFactory) - { - super(list, i, toType, fixerActionFactory); - } - - @Nls - @Nonnull - @Override - public String getText() - { - return myArgList.getExpressions().length == 1 ? JavaQuickFixBundle.message("wrap.long.with.math.to.int.parameter.single.text") : JavaQuickFixBundle.message("wrap.long.with.math.to.int.parameter" + - ".multiple.text", myIndex + 1); - } - - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) - { - return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file); - } - } - - public static class MyMethodArgumentFixerFactory extends ArgumentFixerActionFactory - { - @Nullable - @Override - protected PsiExpression getModifiedArgument(final PsiExpression expression, final PsiType toType) throws IncorrectOperationException - { - return areSameTypes(toType, PsiType.INT) ? (PsiExpression) getModifiedExpression(expression) : null; - } - - @Override - public boolean areTypesConvertible(final PsiType exprType, final PsiType parameterType, @Nonnull final PsiElement context) - { - return parameterType.isConvertibleFrom(exprType) || (areSameTypes(parameterType, PsiType.INT) && areSameTypes(exprType, PsiType.LONG)); - } - - @Override - public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) - { - return new MyMethodArgumentFix(list, i, toType, this); - } - } +public class WrapLongWithMathToIntExactFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction { + public final static MyMethodArgumentFixerFactory REGISTAR = new MyMethodArgumentFixerFactory(); + + private final PsiType myType; + + public WrapLongWithMathToIntExactFix(final PsiType type, final @Nonnull PsiExpression expression) { + super(expression); + myType = type; + } + + @Nonnull + @Override + public LocalizeValue getText() { + return JavaQuickFixLocalize.wrapLongWithMathToIntText(); + } + + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + startElement.replace(getModifiedExpression(startElement)); + } + + @Override + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + return startElement.isValid() && + startElement.getManager().isInProject(startElement) && + PsiUtil.isLanguageLevel8OrHigher(startElement) && + areSameTypes(myType, PsiType.INT) && + areSameTypes(((PsiExpression) startElement).getType(), PsiType.LONG); + } + + private static boolean areSameTypes(@Nullable PsiType type, @Nonnull PsiPrimitiveType expected) { + return !(type == null || + !type.isValid() || + (!type.equals(expected) && !expected.getBoxedTypeName().equals(type.getCanonicalText(false)))); + } + + private static PsiElement getModifiedExpression(PsiElement expression) { + return JavaPsiFacade.getElementFactory(expression.getProject()) + .createExpressionFromText("java.lang.Math.toIntExact(" + expression.getText() + ")", expression); + } + + private static class MyMethodArgumentFix extends MethodArgumentFix implements HighPriorityAction { + protected MyMethodArgumentFix( + @Nonnull PsiExpressionList list, + int i, + @Nonnull PsiType toType, + @Nonnull ArgumentFixerActionFactory fixerActionFactory + ) { + super(list, i, toType, fixerActionFactory); + } + + @Nonnull + @Override + public LocalizeValue getText() { + return myArgList.getExpressions().length == 1 + ? JavaQuickFixLocalize.wrapLongWithMathToIntParameterSingleText() + : JavaQuickFixLocalize.wrapLongWithMathToIntParameterMultipleText(myIndex + 1); + } + + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file); + } + } + + public static class MyMethodArgumentFixerFactory extends ArgumentFixerActionFactory { + @Nullable + @Override + protected PsiExpression getModifiedArgument( + final PsiExpression expression, + final PsiType toType + ) throws IncorrectOperationException { + return areSameTypes(toType, PsiType.INT) ? (PsiExpression) getModifiedExpression(expression) : null; + } + + @Override + public boolean areTypesConvertible(final PsiType exprType, final PsiType parameterType, @Nonnull final PsiElement context) { + return parameterType.isConvertibleFrom(exprType) || (areSameTypes(parameterType, PsiType.INT) && areSameTypes( + exprType, + PsiType.LONG + )); + } + + @Override + public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) { + return new MyMethodArgumentFix(list, i, toType, this); + } + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/quickFix/CreateFieldOrPropertyFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/quickFix/CreateFieldOrPropertyFix.java index b97960eec8..3381413453 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/quickFix/CreateFieldOrPropertyFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/quickFix/CreateFieldOrPropertyFix.java @@ -27,7 +27,7 @@ import com.intellij.java.language.psi.util.PropertyUtil; import consulo.application.Result; import consulo.codeEditor.Editor; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.WriteCommandAction; import consulo.language.editor.generation.ClassMember; import consulo.language.editor.inspection.LocalQuickFix; @@ -38,122 +38,128 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; +import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; -import jakarta.annotation.Nonnull; import java.util.List; /** * @author peter -*/ + */ public class CreateFieldOrPropertyFix implements IntentionAction, LocalQuickFix { - private static final Logger LOG = Logger.getInstance(CreateFieldOrPropertyFix.class); - - private final PsiClass myClass; - private final String myName; - private final PsiType myType; - private final PropertyMemberType myMemberType; - private final PsiAnnotation[] myAnnotations; - - public CreateFieldOrPropertyFix(final PsiClass aClass, final String name, final PsiType type, final PropertyMemberType memberType, final PsiAnnotation[] annotations) { - myClass = aClass; - myName = name; - myType = type; - myMemberType = memberType; - myAnnotations = annotations; - } - - @Override - @Nonnull - public String getText() { - return JavaQuickFixBundle.message(myMemberType == PropertyMemberType.FIELD ? "create.field.text":"create.property.text", myName); - } - - @Override - @Nonnull - public String getName() { - return getText(); - } + private static final Logger LOG = Logger.getInstance(CreateFieldOrPropertyFix.class); + + private final PsiClass myClass; + private final String myName; + private final PsiType myType; + private final PropertyMemberType myMemberType; + private final PsiAnnotation[] myAnnotations; + + public CreateFieldOrPropertyFix( + final PsiClass aClass, + final String name, + final PsiType type, + final PropertyMemberType memberType, + final PsiAnnotation[] annotations + ) { + myClass = aClass; + myName = name; + myType = type; + myMemberType = memberType; + myAnnotations = annotations; + } - @Override - @Nonnull - public String getFamilyName() { - return getText(); - } + @Override + @Nonnull + public LocalizeValue getText() { + return myMemberType == PropertyMemberType.FIELD + ? JavaQuickFixLocalize.createFieldText(myName) + : JavaQuickFixLocalize.createPropertyText(myName); + } - @Override - public void applyFix(@Nonnull final Project project, @Nonnull ProblemDescriptor descriptor) { - applyFixInner(project); - } + @Nonnull + @Override + public LocalizeValue getName() { + return getText(); + } - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - return true; - } + @Override + public void applyFix(@Nonnull final Project project, @Nonnull ProblemDescriptor descriptor) { + applyFixInner(project); + } - @Override - public void invoke(@Nonnull Project project, Editor editor, PsiFile file) { - applyFixInner(project); - } + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return true; + } - private void applyFixInner(final Project project) { - final PsiFile file = myClass.getContainingFile(); - final Editor editor = CodeInsightUtil.positionCursor(project, myClass.getContainingFile(), myClass.getLBrace()); - if (editor != null) { - new WriteCommandAction(project, file) { - @Override - protected void run(Result result) throws Throwable { - generateMembers(project, editor, file); - } + @Override + public void invoke(@Nonnull Project project, Editor editor, PsiFile file) { + applyFixInner(project); + } - @Override - protected boolean isGlobalUndoAction() { - return true; // todo check + private void applyFixInner(final Project project) { + final PsiFile file = myClass.getContainingFile(); + final Editor editor = CodeInsightUtil.positionCursor(project, myClass.getContainingFile(), myClass.getLBrace()); + if (editor != null) { + new WriteCommandAction(project, file) { + @Override + protected void run(Result result) throws Throwable { + generateMembers(project, editor, file); + } + + @Override + protected boolean isGlobalUndoAction() { + return true; // todo check + } + }.execute(); } - }.execute(); } - } - private void generateMembers(final Project project, final Editor editor, final PsiFile file) { - try { - List prototypes = new GenerateFieldOrPropertyHandler(myName, myType, myMemberType, myAnnotations).generateMemberPrototypes(myClass, ClassMember.EMPTY_ARRAY); - prototypes = GenerateMembersUtil.insertMembersAtOffset(myClass.getContainingFile(), editor.getCaretModel().getOffset(), prototypes); - if (prototypes.isEmpty()) return; - final PsiElement scope = prototypes.get(0).getPsiMember().getContext(); - assert scope != null; - final Expression expression = new EmptyExpression() { - @Override - public consulo.language.editor.template.Result calculateResult(final ExpressionContext context) { - return new TextResult(myType.getCanonicalText()); + private void generateMembers(final Project project, final Editor editor, final PsiFile file) { + try { + List prototypes = new GenerateFieldOrPropertyHandler(myName, myType, myMemberType, myAnnotations) + .generateMemberPrototypes(myClass, ClassMember.EMPTY_ARRAY); + prototypes = + GenerateMembersUtil.insertMembersAtOffset(myClass.getContainingFile(), editor.getCaretModel().getOffset(), prototypes); + if (prototypes.isEmpty()) { + return; + } + final PsiElement scope = prototypes.get(0).getPsiMember().getContext(); + assert scope != null; + final Expression expression = new EmptyExpression() { + @Override + public consulo.language.editor.template.Result calculateResult(final ExpressionContext context) { + return new TextResult(myType.getCanonicalText()); + } + }; + final TemplateBuilder builder = TemplateBuilderFactory.getInstance().createTemplateBuilder(scope); + boolean first = true; + @NonNls final String TYPE_NAME_VAR = "TYPE_NAME_VAR"; + for (GenerationInfo prototype : prototypes) { + final PsiTypeElement typeElement = PropertyUtil.getPropertyTypeElement(prototype.getPsiMember()); + if (first) { + first = false; + builder.replaceElement(typeElement, TYPE_NAME_VAR, expression, true); + } + else { + builder.replaceElement(typeElement, TYPE_NAME_VAR, TYPE_NAME_VAR, false); + } + } + PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument()); + editor.getCaretModel().moveToOffset(scope.getTextRange().getStartOffset()); + TemplateManager.getInstance(project).startTemplate(editor, builder.buildInlineTemplate()); } - }; - final TemplateBuilder builder = TemplateBuilderFactory.getInstance().createTemplateBuilder(scope); - boolean first = true; - @NonNls final String TYPE_NAME_VAR = "TYPE_NAME_VAR"; - for (GenerationInfo prototype : prototypes) { - final PsiTypeElement typeElement = PropertyUtil.getPropertyTypeElement(prototype.getPsiMember()); - if (first) { - first = false; - builder.replaceElement(typeElement, TYPE_NAME_VAR, expression, true); + catch (IncorrectOperationException e) { + LOG.error(e); } - else { - builder.replaceElement(typeElement, TYPE_NAME_VAR, TYPE_NAME_VAR, false); - } - } - PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument()); - editor.getCaretModel().moveToOffset(scope.getTextRange().getStartOffset()); - TemplateManager.getInstance(project).startTemplate(editor, builder.buildInlineTemplate()); - } - catch (IncorrectOperationException e) { - LOG.error(e); } - } - - @Override - public boolean startInWriteAction() { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/ReplaceAssignmentWithComparisonFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/ReplaceAssignmentWithComparisonFix.java index 3f269cb18f..b85b995e78 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/ReplaceAssignmentWithComparisonFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/ReplaceAssignmentWithComparisonFix.java @@ -25,39 +25,39 @@ import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; public class ReplaceAssignmentWithComparisonFix extends LocalQuickFixAndIntentionActionOnPsiElement { - public ReplaceAssignmentWithComparisonFix(PsiAssignmentExpression expr) { - super(expr); - } + public ReplaceAssignmentWithComparisonFix(PsiAssignmentExpression expr) { + super(expr); + } - @Override - public void invoke(@Nonnull Project project, @Nonnull PsiFile file, @Nullable Editor editor, @Nonnull PsiElement startElement, @Nonnull PsiElement endElement) { - PsiBinaryExpression comparisonExpr = (PsiBinaryExpression) JavaPsiFacade.getElementFactory(project).createExpressionFromText("a==b", startElement); - PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) startElement; - comparisonExpr.getLOperand().replace(assignmentExpression.getLExpression()); - PsiExpression rOperand = comparisonExpr.getROperand(); - assert rOperand != null; - PsiExpression rExpression = assignmentExpression.getRExpression(); - assert rExpression != null; - rOperand.replace(rExpression); - CodeStyleManager.getInstance(project).reformat(assignmentExpression.replace(comparisonExpr)); - } + @Override + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + PsiBinaryExpression comparisonExpr = + (PsiBinaryExpression) JavaPsiFacade.getElementFactory(project).createExpressionFromText("a==b", startElement); + PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) startElement; + comparisonExpr.getLOperand().replace(assignmentExpression.getLExpression()); + PsiExpression rOperand = comparisonExpr.getROperand(); + assert rOperand != null; + PsiExpression rExpression = assignmentExpression.getRExpression(); + assert rExpression != null; + rOperand.replace(rExpression); + CodeStyleManager.getInstance(project).reformat(assignmentExpression.replace(comparisonExpr)); + } - @Nonnull - @Override - public String getText() { - return getFamilyName(); - } - - @Nls - @Nonnull - @Override - public String getFamilyName() { - return InspectionGadgetsLocalize.assignmentUsedAsConditionReplaceQuickfix().get(); - } + @Nonnull + @Override + public LocalizeValue getText() { + return InspectionGadgetsLocalize.assignmentUsedAsConditionReplaceQuickfix(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/AddAssertStatementFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/AddAssertStatementFix.java index 5ad029babe..41c74013f5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/AddAssertStatementFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/AddAssertStatementFix.java @@ -26,63 +26,58 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; - /** * @author ven */ public class AddAssertStatementFix implements LocalQuickFix { - private static final Logger LOG = Logger.getInstance(AddAssertStatementFix.class); - private final String myText; - - public AddAssertStatementFix(@Nonnull String text) { - myText = text; - } - - @Override - @Nonnull - public String getName() { - return InspectionLocalize.inspectionAssertQuickfix(myText).get(); - } + private static final Logger LOG = Logger.getInstance(AddAssertStatementFix.class); + private final String myText; - @Override - @RequiredWriteAction - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getPsiElement(); - PsiElement anchorElement = RefactoringUtil.getParentStatement(element, false); - LOG.assertTrue(anchorElement != null); - final PsiElement tempParent = anchorElement.getParent(); - if (tempParent instanceof PsiForStatement forStatement && !PsiTreeUtil.isAncestor(forStatement.getBody(), anchorElement, false)) { - anchorElement = tempParent; + public AddAssertStatementFix(@Nonnull String text) { + myText = text; } - PsiElement prev = PsiTreeUtil.skipWhitespacesBackward(anchorElement); - if (prev instanceof PsiComment && JavaSuppressionUtil.getSuppressedInspectionIdsIn(prev) != null) { - anchorElement = prev; + + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionLocalize.inspectionAssertQuickfix(myText); } - try { - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(element.getProject()); - @NonNls String text = "assert " + myText + ";"; - PsiAssertStatement assertStatement = (PsiAssertStatement) factory.createStatementFromText(text, null); + @Override + @RequiredWriteAction + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiElement element = descriptor.getPsiElement(); + PsiElement anchorElement = RefactoringUtil.getParentStatement(element, false); + LOG.assertTrue(anchorElement != null); + final PsiElement tempParent = anchorElement.getParent(); + if (tempParent instanceof PsiForStatement forStatement && !PsiTreeUtil.isAncestor(forStatement.getBody(), anchorElement, false)) { + anchorElement = tempParent; + } + PsiElement prev = PsiTreeUtil.skipWhitespacesBackward(anchorElement); + if (prev instanceof PsiComment && JavaSuppressionUtil.getSuppressedInspectionIdsIn(prev) != null) { + anchorElement = prev; + } - final PsiElement parent = anchorElement.getParent(); - if (parent instanceof PsiCodeBlock) { - parent.addBefore(assertStatement, anchorElement); - } else { - RefactoringUtil.putStatementInLoopBody(assertStatement, parent, anchorElement); - } - } catch (IncorrectOperationException e) { - LOG.error(e); - } - } + try { + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(element.getProject()); + String text = "assert " + myText + ";"; + PsiAssertStatement assertStatement = (PsiAssertStatement) factory.createStatementFromText(text, null); - @Override - @Nonnull - public String getFamilyName() { - return InspectionLocalize.inspectionQuickfixAssertFamily().get(); - } + final PsiElement parent = anchorElement.getParent(); + if (parent instanceof PsiCodeBlock) { + parent.addBefore(assertStatement, anchorElement); + } + else { + RefactoringUtil.putStatementInLoopBody(assertStatement, parent, anchorElement); + } + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/DeleteThrowsFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/DeleteThrowsFix.java index 884293b35f..c8409eb276 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/DeleteThrowsFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/DeleteThrowsFix.java @@ -15,47 +15,42 @@ */ package com.intellij.java.impl.codeInspection; -import consulo.language.editor.inspection.LocalQuickFix; -import consulo.language.editor.inspection.ProblemDescriptor; import com.intellij.java.impl.codeInsight.daemon.impl.quickfix.MethodThrowsFix; import com.intellij.java.language.psi.PsiClassType; import com.intellij.java.language.psi.PsiMethod; -import consulo.project.Project; +import consulo.language.editor.inspection.LocalQuickFix; +import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; -import consulo.java.analysis.impl.JavaQuickFixBundle; - +import consulo.localize.LocalizeValue; +import consulo.project.Project; import jakarta.annotation.Nonnull; /** * @author cdr */ public class DeleteThrowsFix implements LocalQuickFix { - private final MethodThrowsFix myQuickFix; - - public DeleteThrowsFix(PsiMethod method, PsiClassType exceptionClass) { - myQuickFix = new MethodThrowsFix(method, exceptionClass, false, false); - } + private final MethodThrowsFix myQuickFix; - @Override - @Nonnull - public String getName() { - return myQuickFix.getText(); - } + public DeleteThrowsFix(PsiMethod method, PsiClassType exceptionClass) { + myQuickFix = new MethodThrowsFix(method, exceptionClass, false, false); + } - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("fix.throws.list.family"); - } + @Nonnull + @Override + public LocalizeValue getName() { + return myQuickFix.getText(); + } - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getPsiElement(); - if (element == null) return; - final PsiFile psiFile = element.getContainingFile(); - if (myQuickFix.isAvailable(project, null, psiFile)) { - myQuickFix.invoke(project, null, psiFile); + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiElement element = descriptor.getPsiElement(); + if (element == null) { + return; + } + final PsiFile psiFile = element.getContainingFile(); + if (myQuickFix.isAvailable(project, null, psiFile)) { + myQuickFix.invoke(project, null, psiFile); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/RemoveInitializerFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/RemoveInitializerFix.java index 4cd2921ac4..881651b3f1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/RemoveInitializerFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/RemoveInitializerFix.java @@ -28,6 +28,7 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.inspection.localize.InspectionLocalize; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import jakarta.annotation.Nonnull; @@ -35,90 +36,70 @@ import java.util.ArrayList; import java.util.List; -public class RemoveInitializerFix implements LocalQuickFix -{ - private static final Logger LOG = Logger.getInstance(RemoveInitializerFix.class); +public class RemoveInitializerFix implements LocalQuickFix { + private static final Logger LOG = Logger.getInstance(RemoveInitializerFix.class); - @Override - @Nonnull - public String getName() - { - return InspectionLocalize.inspectionUnusedAssignmentRemoveQuickfix().get(); - } + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionLocalize.inspectionUnusedAssignmentRemoveQuickfix(); + } - @Override - @RequiredWriteAction - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) - { - final PsiElement psiInitializer = descriptor.getPsiElement(); - if (!(psiInitializer instanceof PsiExpression)) - { - return; - } - if (!(psiInitializer.getParent() instanceof PsiVariable)) - { - return; - } + @Override + @RequiredWriteAction + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + final PsiElement psiInitializer = descriptor.getPsiElement(); + if (!(psiInitializer instanceof PsiExpression)) { + return; + } + if (!(psiInitializer.getParent() instanceof PsiVariable)) { + return; + } - final PsiVariable variable = (PsiVariable) psiInitializer.getParent(); - sideEffectAwareRemove(project, psiInitializer, psiInitializer, variable); - } + final PsiVariable variable = (PsiVariable) psiInitializer.getParent(); + sideEffectAwareRemove(project, psiInitializer, psiInitializer, variable); + } - @RequiredReadAction - protected void sideEffectAwareRemove(Project project, PsiElement psiInitializer, PsiElement elementToDelete, PsiVariable variable) - { - if (!FileModificationService.getInstance().prepareFileForWrite(elementToDelete.getContainingFile())) - { - return; - } + @RequiredReadAction + protected void sideEffectAwareRemove(Project project, PsiElement psiInitializer, PsiElement elementToDelete, PsiVariable variable) { + if (!FileModificationService.getInstance().prepareFileForWrite(elementToDelete.getContainingFile())) { + return; + } - final PsiElement declaration = variable.getParent(); - final List sideEffects = new ArrayList<>(); - boolean hasSideEffects = RemoveUnusedVariableUtil.checkSideEffects(psiInitializer, variable, sideEffects); - int res; - if (hasSideEffects) - { - hasSideEffects = PsiUtil.isStatement(psiInitializer); - res = RemoveUnusedVariableFix.showSideEffectsWarning( - sideEffects, - variable, - FileEditorManager.getInstance(project).getSelectedTextEditor(), - hasSideEffects, - sideEffects.get(0).getText(), - variable.getTypeElement().getText() + " " + variable.getName() + ";
          " + - PsiExpressionTrimRenderer.render((PsiExpression) psiInitializer) - ); - } - else - { - res = RemoveUnusedVariableUtil.DELETE_ALL; - } + final PsiElement declaration = variable.getParent(); + final List sideEffects = new ArrayList<>(); + boolean hasSideEffects = RemoveUnusedVariableUtil.checkSideEffects(psiInitializer, variable, sideEffects); + int res; + if (hasSideEffects) { + hasSideEffects = PsiUtil.isStatement(psiInitializer); + res = RemoveUnusedVariableFix.showSideEffectsWarning( + sideEffects, + variable, + FileEditorManager.getInstance(project).getSelectedTextEditor(), + hasSideEffects, + sideEffects.get(0).getText(), + variable.getTypeElement().getText() + " " + variable.getName() + ";
          " + + PsiExpressionTrimRenderer.render((PsiExpression) psiInitializer) + ); + } + else { + res = RemoveUnusedVariableUtil.DELETE_ALL; + } - if (res == RemoveUnusedVariableUtil.DELETE_ALL) - { - elementToDelete.delete(); - } - else if (res == RemoveUnusedVariableUtil.MAKE_STATEMENT) - { - final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - final PsiStatement statementFromText = factory.createStatementFromText(psiInitializer.getText() + ";", null); - final PsiElement parent = elementToDelete.getParent(); - if (parent instanceof PsiExpressionStatement) - { - parent.replace(statementFromText); - } - else - { - declaration.getParent().addAfter(statementFromText, declaration); - elementToDelete.delete(); - } - } - } - - @Override - @Nonnull - public String getFamilyName() - { - return getName(); - } + if (res == RemoveUnusedVariableUtil.DELETE_ALL) { + elementToDelete.delete(); + } + else if (res == RemoveUnusedVariableUtil.MAKE_STATEMENT) { + final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + final PsiStatement statementFromText = factory.createStatementFromText(psiInitializer.getText() + ";", null); + final PsiElement parent = elementToDelete.getParent(); + if (parent instanceof PsiExpressionStatement) { + parent.replace(statementFromText); + } + else { + declaration.getParent().addAfter(statementFromText, declaration); + elementToDelete.delete(); + } + } + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceTypeInCastFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceTypeInCastFix.java index 92a7490157..8ac74ab8c8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceTypeInCastFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceTypeInCastFix.java @@ -8,41 +8,36 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.lang.ObjectUtil; import jakarta.annotation.Nonnull; public class ReplaceTypeInCastFix implements LocalQuickFix { - private final String myExistingTypeText; - private final String myWantedTypeText; - private final String myWantedTypeCanonicalText; + private final String myExistingTypeText; + private final String myWantedTypeText; + private final String myWantedTypeCanonicalText; - public ReplaceTypeInCastFix(PsiType existingType, PsiType wantedType) { - myExistingTypeText = existingType.getPresentableText(); - myWantedTypeText = wantedType.getPresentableText(); - myWantedTypeCanonicalText = wantedType.getCanonicalText(); - } - - @Override - @Nonnull - public String getName() { - return InspectionGadgetsLocalize.castConflictsWithInstanceofQuickfix1(myExistingTypeText, myWantedTypeText).get(); - } + public ReplaceTypeInCastFix(PsiType existingType, PsiType wantedType) { + myExistingTypeText = existingType.getPresentableText(); + myWantedTypeText = wantedType.getPresentableText(); + myWantedTypeCanonicalText = wantedType.getCanonicalText(); + } - @Nonnull - @Override - public String getFamilyName() { - return "Replace cast type"; - } + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.castConflictsWithInstanceofQuickfix1(myExistingTypeText, myWantedTypeText); + } - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiTypeElement typeElement = ObjectUtil.tryCast(descriptor.getStartElement(), PsiTypeElement.class); - if (typeElement == null) { - return; + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiTypeElement typeElement = ObjectUtil.tryCast(descriptor.getStartElement(), PsiTypeElement.class); + if (typeElement == null) { + return; + } + PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + PsiTypeElement replacement = factory.createTypeElement(factory.createTypeFromText(myWantedTypeCanonicalText, typeElement)); + typeElement.replace(replacement); } - PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - PsiTypeElement replacement = factory.createTypeElement(factory.createTypeFromText(myWantedTypeCanonicalText, typeElement)); - typeElement.replace(replacement); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTernaryOperatorFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTernaryOperatorFix.java index a236b40e8c..0fd604406d 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTernaryOperatorFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTernaryOperatorFix.java @@ -23,13 +23,14 @@ import consulo.annotation.access.RequiredReadAction; import consulo.annotation.access.RequiredWriteAction; import consulo.fileEditor.SelectInEditorManager; -import consulo.java.analysis.impl.codeInsight.JavaInspectionsBundle; +import consulo.java.analysis.impl.localize.JavaInspectionsLocalize; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.inspection.localize.InspectionLocalize; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.navigation.Navigatable; import consulo.project.Project; import consulo.util.collection.ArrayUtil; @@ -40,125 +41,122 @@ * @author Danila Ponomarenko */ public class ReplaceWithTernaryOperatorFix implements LocalQuickFix { - private final String myText; - - @Override - @Nonnull - public String getName() { - return InspectionLocalize.inspectionReplaceTernaryQuickfix(myText).get(); - } - - public ReplaceWithTernaryOperatorFix(@Nonnull PsiExpression expressionToAssert) { - myText = ParenthesesUtils.getText(expressionToAssert, ParenthesesUtils.BINARY_AND_PRECEDENCE); - } - - @Nonnull - @Override - public String getFamilyName() { - return InspectionLocalize.inspectionSurroundIfFamily().get(); - } - - @Override - @RequiredWriteAction - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiElement element = descriptor.getPsiElement(); - while (true) { - PsiElement parent = element.getParent(); - if (parent instanceof PsiReferenceExpression || parent instanceof PsiMethodCallExpression) { - element = parent; - } else { - break; - } - } - if (!(element instanceof PsiExpression)) { - return; - } - final PsiExpression expression = (PsiExpression) element; - - final PsiFile file = expression.getContainingFile(); - PsiConditionalExpression conditionalExpression = replaceWithConditionalExpression(project, myText + "!=null", expression, suggestDefaultValue(expression)); - - selectElseBranch(file, conditionalExpression); - } - - @RequiredReadAction - static void selectElseBranch(PsiFile file, PsiConditionalExpression conditionalExpression) { - PsiExpression elseExpression = conditionalExpression.getElseExpression(); - if (elseExpression != null) { - ((Navigatable) elseExpression).navigate(true); - SelectInEditorManager.getInstance(file.getProject()).selectInEditor( - file.getVirtualFile(), - elseExpression.getTextRange().getStartOffset(), - elseExpression.getTextRange().getEndOffset(), - false, - true - ); - } - } - - @Nonnull - @RequiredReadAction - private static PsiConditionalExpression replaceWithConditionalExpression( - @Nonnull Project project, - @Nonnull String condition, - @Nonnull PsiExpression expression, - @Nonnull String defaultValue - ) { - final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - - final PsiElement parent = expression.getParent(); - final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression) factory.createExpressionFromText( - condition + " ? " + expression.getText() + " : " + defaultValue, - parent - ); - - final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project); - return (PsiConditionalExpression) expression.replace(codeStyleManager.reformat(conditionalExpression)); - } - - @RequiredReadAction - public static boolean isAvailable(@Nonnull PsiExpression qualifier, @Nonnull PsiExpression expression) { - return qualifier.isValid() && qualifier.getText() != null && !(expression.getParent() instanceof PsiExpressionStatement) - && !PsiUtil.isAccessedForWriting(expression); - - } - - private static String suggestDefaultValue(@Nonnull PsiExpression expression) { - PsiType type = expression.getType(); - return PsiTypesUtil.getDefaultValueOfType(type); - } - - public static class ReplaceMethodRefWithTernaryOperatorFix implements LocalQuickFix { + private final String myText; + @Nonnull @Override - public String getFamilyName() { - return JavaInspectionsBundle.message("inspection.replace.methodref.ternary.quickfix"); + public LocalizeValue getName() { + return InspectionLocalize.inspectionReplaceTernaryQuickfix(myText); + } + + public ReplaceWithTernaryOperatorFix(@Nonnull PsiExpression expressionToAssert) { + myText = ParenthesesUtils.getText(expressionToAssert, ParenthesesUtils.BINARY_AND_PRECEDENCE); } @Override @RequiredWriteAction public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiMethodReferenceExpression element = ObjectUtil.tryCast(descriptor.getPsiElement(), PsiMethodReferenceExpression.class); - if (element == null) { - return; - } - PsiLambdaExpression lambda = LambdaRefactoringUtil.convertMethodReferenceToLambda(element, false, true); - if (lambda == null) { - return; - } - PsiExpression expression = LambdaUtil.extractSingleExpressionFromBody(lambda.getBody()); - if (expression == null) { - return; - } - PsiParameter parameter = ArrayUtil.getFirstElement(lambda.getParameterList().getParameters()); - if (parameter == null) { - return; - } - String text = parameter.getName(); - final PsiFile file = expression.getContainingFile(); - PsiConditionalExpression conditionalExpression = replaceWithConditionalExpression(project, text + "!=null", expression, suggestDefaultValue(expression)); - - selectElseBranch(file, conditionalExpression); + PsiElement element = descriptor.getPsiElement(); + while (true) { + PsiElement parent = element.getParent(); + if (parent instanceof PsiReferenceExpression || parent instanceof PsiMethodCallExpression) { + element = parent; + } + else { + break; + } + } + if (!(element instanceof PsiExpression)) { + return; + } + final PsiExpression expression = (PsiExpression) element; + + final PsiFile file = expression.getContainingFile(); + PsiConditionalExpression conditionalExpression = + replaceWithConditionalExpression(project, myText + "!=null", expression, suggestDefaultValue(expression)); + + selectElseBranch(file, conditionalExpression); + } + + @RequiredReadAction + static void selectElseBranch(PsiFile file, PsiConditionalExpression conditionalExpression) { + PsiExpression elseExpression = conditionalExpression.getElseExpression(); + if (elseExpression != null) { + ((Navigatable) elseExpression).navigate(true); + SelectInEditorManager.getInstance(file.getProject()).selectInEditor( + file.getVirtualFile(), + elseExpression.getTextRange().getStartOffset(), + elseExpression.getTextRange().getEndOffset(), + false, + true + ); + } + } + + @Nonnull + @RequiredReadAction + private static PsiConditionalExpression replaceWithConditionalExpression( + @Nonnull Project project, + @Nonnull String condition, + @Nonnull PsiExpression expression, + @Nonnull String defaultValue + ) { + final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + + final PsiElement parent = expression.getParent(); + final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression) factory.createExpressionFromText( + condition + " ? " + expression.getText() + " : " + defaultValue, + parent + ); + + final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project); + return (PsiConditionalExpression) expression.replace(codeStyleManager.reformat(conditionalExpression)); + } + + @RequiredReadAction + public static boolean isAvailable(@Nonnull PsiExpression qualifier, @Nonnull PsiExpression expression) { + return qualifier.isValid() && qualifier.getText() != null && !(expression.getParent() instanceof PsiExpressionStatement) + && !PsiUtil.isAccessedForWriting(expression); + + } + + private static String suggestDefaultValue(@Nonnull PsiExpression expression) { + PsiType type = expression.getType(); + return PsiTypesUtil.getDefaultValueOfType(type); + } + + public static class ReplaceMethodRefWithTernaryOperatorFix implements LocalQuickFix { + @Nonnull + @Override + public LocalizeValue getName() { + return JavaInspectionsLocalize.inspectionReplaceMethodrefTernaryQuickfix(); + } + + @Override + @RequiredWriteAction + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiMethodReferenceExpression element = ObjectUtil.tryCast(descriptor.getPsiElement(), PsiMethodReferenceExpression.class); + if (element == null) { + return; + } + PsiLambdaExpression lambda = LambdaRefactoringUtil.convertMethodReferenceToLambda(element, false, true); + if (lambda == null) { + return; + } + PsiExpression expression = LambdaUtil.extractSingleExpressionFromBody(lambda.getBody()); + if (expression == null) { + return; + } + PsiParameter parameter = ArrayUtil.getFirstElement(lambda.getParameterList().getParameters()); + if (parameter == null) { + return; + } + String text = parameter.getName(); + final PsiFile file = expression.getContainingFile(); + PsiConditionalExpression conditionalExpression = + replaceWithConditionalExpression(project, text + "!=null", expression, suggestDefaultValue(expression)); + + selectElseBranch(file, conditionalExpression); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTrivialLambdaFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTrivialLambdaFix.java index bd24ff098f..1cbb0060a5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTrivialLambdaFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceWithTrivialLambdaFix.java @@ -15,58 +15,49 @@ */ package com.intellij.java.impl.codeInspection; -import consulo.language.editor.inspection.LocalQuickFix; -import consulo.language.editor.inspection.ProblemDescriptor; import com.intellij.java.impl.refactoring.util.LambdaRefactoringUtil; import com.intellij.java.language.psi.JavaPsiFacade; import com.intellij.java.language.psi.PsiLambdaExpression; import com.intellij.java.language.psi.PsiMethodReferenceExpression; -import consulo.project.Project; +import consulo.java.analysis.impl.localize.JavaInspectionsLocalize; +import consulo.language.editor.inspection.LocalQuickFix; +import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; +import consulo.project.Project; import consulo.util.lang.ObjectUtil; -import consulo.java.analysis.impl.codeInsight.JavaInspectionsBundle; -import org.jetbrains.annotations.Nls; - import jakarta.annotation.Nonnull; /** * @author Tagir Valeev */ public class ReplaceWithTrivialLambdaFix implements LocalQuickFix { - private final String myValue; - - public ReplaceWithTrivialLambdaFix(Object value) { - myValue = String.valueOf(value); - } - - @Nls - @Nonnull - @Override - public String getName() { - return JavaInspectionsBundle.message("inspection.replace.with.trivial.lambda.fix.name", myValue); - } + private final String myValue; - @Nls - @Nonnull - @Override - public String getFamilyName() { - return JavaInspectionsBundle.message("inspection.replace.with.trivial.lambda.fix.family.name"); - } - - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiMethodReferenceExpression methodRef = ObjectUtil.tryCast(descriptor.getStartElement(), PsiMethodReferenceExpression.class); - if (methodRef == null) { - return; + public ReplaceWithTrivialLambdaFix(Object value) { + myValue = String.valueOf(value); } - PsiLambdaExpression lambdaExpression = LambdaRefactoringUtil.convertMethodReferenceToLambda(methodRef, true, true); - if (lambdaExpression == null) { - return; + + @Nonnull + @Override + public LocalizeValue getName() { + return JavaInspectionsLocalize.inspectionReplaceWithTrivialLambdaFixName(myValue); } - PsiElement body = lambdaExpression.getBody(); - if (body == null) { - return; + + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiMethodReferenceExpression methodRef = ObjectUtil.tryCast(descriptor.getStartElement(), PsiMethodReferenceExpression.class); + if (methodRef == null) { + return; + } + PsiLambdaExpression lambdaExpression = LambdaRefactoringUtil.convertMethodReferenceToLambda(methodRef, true, true); + if (lambdaExpression == null) { + return; + } + PsiElement body = lambdaExpression.getBody(); + if (body == null) { + return; + } + body.replace(JavaPsiFacade.getElementFactory(project).createExpressionFromText(myValue, lambdaExpression)); } - body.replace(JavaPsiFacade.getElementFactory(project).createExpressionFromText(myValue, lambdaExpression)); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/StreamFilterNotNullFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/StreamFilterNotNullFix.java index bb1491a7d5..7682a46d02 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/StreamFilterNotNullFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/StreamFilterNotNullFix.java @@ -22,13 +22,14 @@ import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.PsiUtil; import com.siyeh.ig.psiutils.StreamApiUtil; -import consulo.java.analysis.impl.codeInsight.JavaInspectionsBundle; +import consulo.java.analysis.impl.localize.JavaInspectionsLocalize; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.intention.HighPriorityAction; import consulo.language.editor.refactoring.rename.SuggestedNameInfo; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ArrayUtil; import jakarta.annotation.Nonnull; @@ -37,92 +38,93 @@ import static consulo.util.lang.ObjectUtil.tryCast; public class StreamFilterNotNullFix implements LocalQuickFix, HighPriorityAction { - @Override - @Nonnull - public String getFamilyName() { - return JavaInspectionsBundle.message("inspection.data.flow.filter.notnull.quickfix"); - } - - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - PsiFunctionalExpression function = findFunction(descriptor.getStartElement()); - if (function == null) { - return; - } - PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(function, PsiMethodCallExpression.class); - if (call == null) { - return; - } - PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); - if (qualifier == null) { - return; + @Nonnull + @Override + public LocalizeValue getName() { + return JavaInspectionsLocalize.inspectionDataFlowFilterNotnullQuickfix(); } - String name = suggestVariableName(function, qualifier); - // We create first lambda, then convert to method reference as user code style might be set to prefer lambdas - PsiExpression replacement = JavaPsiFacade.getElementFactory(project).createExpressionFromText(qualifier.getText() + ".filter(" + name + "->" + name + "!=null)", qualifier); - PsiMethodCallExpression result = (PsiMethodCallExpression) qualifier.replace(replacement); - LambdaCanBeMethodReferenceInspection.replaceAllLambdasWithMethodReferences(result.getArgumentList()); - } - @Nonnull - private static String suggestVariableName(@Nonnull PsiFunctionalExpression function, @Nonnull PsiExpression qualifier) { - String name = null; - if (function instanceof PsiLambdaExpression) { - PsiParameter parameter = ArrayUtil.getFirstElement(((PsiLambdaExpression) function).getParameterList().getParameters()); - if (parameter != null) { - name = parameter.getName(); - } + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiFunctionalExpression function = findFunction(descriptor.getStartElement()); + if (function == null) { + return; + } + PsiMethodCallExpression call = PsiTreeUtil.getParentOfType(function, PsiMethodCallExpression.class); + if (call == null) { + return; + } + PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); + if (qualifier == null) { + return; + } + String name = suggestVariableName(function, qualifier); + // We create first lambda, then convert to method reference as user code style might be set to prefer lambdas + PsiExpression replacement = JavaPsiFacade.getElementFactory(project) + .createExpressionFromText(qualifier.getText() + ".filter(" + name + "->" + name + "!=null)", qualifier); + PsiMethodCallExpression result = (PsiMethodCallExpression) qualifier.replace(replacement); + LambdaCanBeMethodReferenceInspection.replaceAllLambdasWithMethodReferences(result.getArgumentList()); } - PsiType type = StreamApiUtil.getStreamElementType(qualifier.getType()); - JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(function.getProject()); - SuggestedNameInfo info = javaCodeStyleManager.suggestVariableName(VariableKind.PARAMETER, name, null, type, true); - name = ArrayUtil.getFirstElement(info.names); - return javaCodeStyleManager.suggestUniqueVariableName(name == null ? "obj" : name, qualifier, false); - } - @Nullable - private static PsiFunctionalExpression findFunction(PsiElement reference) { - if (reference instanceof PsiFunctionalExpression) { - return (PsiFunctionalExpression) reference; + @Nonnull + private static String suggestVariableName(@Nonnull PsiFunctionalExpression function, @Nonnull PsiExpression qualifier) { + String name = null; + if (function instanceof PsiLambdaExpression) { + PsiParameter parameter = ArrayUtil.getFirstElement(((PsiLambdaExpression) function).getParameterList().getParameters()); + if (parameter != null) { + name = parameter.getName(); + } + } + PsiType type = StreamApiUtil.getStreamElementType(qualifier.getType()); + JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(function.getProject()); + SuggestedNameInfo info = javaCodeStyleManager.suggestVariableName(VariableKind.PARAMETER, name, null, type, true); + name = ArrayUtil.getFirstElement(info.names); + return javaCodeStyleManager.suggestUniqueVariableName(name == null ? "obj" : name, qualifier, false); } - if (reference instanceof PsiIdentifier) { - // in "str.trim()" go from "trim" to "str" - reference = reference.getParent(); - if (reference instanceof PsiReferenceExpression) { - reference = PsiUtil.skipParenthesizedExprDown(((PsiReferenceExpression) reference).getQualifierExpression()); - } - } - if (reference instanceof PsiReferenceExpression) { - PsiParameter parameter = tryCast(((PsiReferenceExpression) reference).resolve(), PsiParameter.class); - if (parameter == null) { - return null; - } - PsiParameterList parameterList = tryCast(parameter.getParent(), PsiParameterList.class); - if (parameterList == null || parameterList.getParametersCount() != 1) { + + @Nullable + private static PsiFunctionalExpression findFunction(PsiElement reference) { + if (reference instanceof PsiFunctionalExpression) { + return (PsiFunctionalExpression) reference; + } + if (reference instanceof PsiIdentifier) { + // in "str.trim()" go from "trim" to "str" + reference = reference.getParent(); + if (reference instanceof PsiReferenceExpression) { + reference = PsiUtil.skipParenthesizedExprDown(((PsiReferenceExpression) reference).getQualifierExpression()); + } + } + if (reference instanceof PsiReferenceExpression) { + PsiParameter parameter = tryCast(((PsiReferenceExpression) reference).resolve(), PsiParameter.class); + if (parameter == null) { + return null; + } + PsiParameterList parameterList = tryCast(parameter.getParent(), PsiParameterList.class); + if (parameterList == null || parameterList.getParametersCount() != 1) { + return null; + } + return tryCast(parameterList.getParent(), PsiLambdaExpression.class); + } return null; - } - return tryCast(parameterList.getParent(), PsiLambdaExpression.class); } - return null; - } - public static StreamFilterNotNullFix makeFix(PsiElement reference) { - PsiFunctionalExpression fn = findFunction(reference); - if (fn == null) { - return null; - } - PsiExpressionList args = tryCast(PsiUtil.skipParenthesizedExprUp(fn.getParent()), PsiExpressionList.class); - if (args == null || args.getExpressions().length != 1) { - return null; - } - PsiMethodCallExpression call = tryCast(args.getParent(), PsiMethodCallExpression.class); - if (call == null) { - return null; - } - PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); - if (qualifier == null || !InheritanceUtil.isInheritor(qualifier.getType(), CommonClassNames.JAVA_UTIL_STREAM_STREAM)) { - return null; + public static StreamFilterNotNullFix makeFix(PsiElement reference) { + PsiFunctionalExpression fn = findFunction(reference); + if (fn == null) { + return null; + } + PsiExpressionList args = tryCast(PsiUtil.skipParenthesizedExprUp(fn.getParent()), PsiExpressionList.class); + if (args == null || args.getExpressions().length != 1) { + return null; + } + PsiMethodCallExpression call = tryCast(args.getParent(), PsiMethodCallExpression.class); + if (call == null) { + return null; + } + PsiExpression qualifier = call.getMethodExpression().getQualifierExpression(); + if (qualifier == null || !InheritanceUtil.isInheritor(qualifier.getType(), CommonClassNames.JAVA_UTIL_STREAM_STREAM)) { + return null; + } + return new StreamFilterNotNullFix(); } - return new StreamFilterNotNullFix(); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/WrapWithMutableCollectionFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/WrapWithMutableCollectionFix.java index 0f61b49bd0..9b2042e195 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/WrapWithMutableCollectionFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/WrapWithMutableCollectionFix.java @@ -12,13 +12,13 @@ import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.lang.ObjectUtil; import consulo.util.lang.StringUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; import org.jetbrains.annotations.Contract; -import org.jetbrains.annotations.Nls; public class WrapWithMutableCollectionFix implements LocalQuickFix { private final String myVariableName; @@ -31,18 +31,10 @@ public WrapWithMutableCollectionFix(String variableName, String collectionName, myOnTheFly = onTheFly; } - @Nls(capitalization = Nls.Capitalization.Sentence) @Nonnull @Override - public String getName() { - return "Wrap '" + myVariableName + "' with '" + StringUtil.getShortName(myCollectionName) + "'"; - } - - @Nls(capitalization = Nls.Capitalization.Sentence) - @Nonnull - @Override - public String getFamilyName() { - return "Wrap with mutable collection"; + public LocalizeValue getName() { + return LocalizeValue.localizeTODO("Wrap '" + myVariableName + "' with '" + StringUtil.getShortName(myCollectionName) + "'"); } @Override diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/JavacQuirksInspectionVisitor.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/JavacQuirksInspectionVisitor.java index b9f02be22a..c7690d9554 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/JavacQuirksInspectionVisitor.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/JavacQuirksInspectionVisitor.java @@ -31,43 +31,47 @@ import static com.intellij.java.language.patterns.PsiJavaPatterns.psiElement; public class JavacQuirksInspectionVisitor extends JavaElementVisitor { - private static final ElementPattern QUALIFIER_REFERENCE = - psiElement().withParent(PsiJavaCodeReferenceElement.class).withSuperParent(2, PsiJavaCodeReferenceElement.class); + private static final ElementPattern QUALIFIER_REFERENCE = + psiElement().withParent(PsiJavaCodeReferenceElement.class).withSuperParent(2, PsiJavaCodeReferenceElement.class); - private final ProblemsHolder myHolder; + private final ProblemsHolder myHolder; - public JavacQuirksInspectionVisitor(ProblemsHolder holder) { - myHolder = holder; - } + public JavacQuirksInspectionVisitor(ProblemsHolder holder) { + myHolder = holder; + } - @Override - @RequiredReadAction - public void visitAnnotationArrayInitializer(@Nonnull final PsiArrayInitializerMemberValue initializer) { - if (PsiUtil.isLanguageLevel7OrHigher(initializer)) return; - final PsiElement lastElement = PsiTreeUtil.skipSiblingsBackward(initializer.getLastChild(), PsiWhiteSpace.class, PsiComment.class); - if (lastElement != null && PsiUtil.isJavaToken(lastElement, JavaTokenType.COMMA)) { - final LocalizeValue message = InspectionLocalize.inspectionCompilerJavacQuirksAnnoArrayCommaProblem(); - final LocalizeValue fixName = InspectionLocalize.inspectionCompilerJavacQuirksAnnoArrayCommaFix(); - myHolder.registerProblem(lastElement, message.get(), new RemoveElementQuickFix(fixName.get())); + @Override + @RequiredReadAction + public void visitAnnotationArrayInitializer(@Nonnull final PsiArrayInitializerMemberValue initializer) { + if (PsiUtil.isLanguageLevel7OrHigher(initializer)) { + return; + } + final PsiElement lastElement = PsiTreeUtil.skipSiblingsBackward(initializer.getLastChild(), PsiWhiteSpace.class, PsiComment.class); + if (lastElement != null && PsiUtil.isJavaToken(lastElement, JavaTokenType.COMMA)) { + final LocalizeValue message = InspectionLocalize.inspectionCompilerJavacQuirksAnnoArrayCommaProblem(); + final LocalizeValue fixName = InspectionLocalize.inspectionCompilerJavacQuirksAnnoArrayCommaFix(); + myHolder.registerProblem(lastElement, message.get(), new RemoveElementQuickFix(fixName)); + } } - } - @Override - public void visitTypeCastExpression(@Nonnull final PsiTypeCastExpression expression) { - if (PsiUtil.isLanguageLevel7OrHigher(expression)) return; - final PsiTypeElement type = expression.getCastType(); - if (type != null) { - type.accept(new JavaRecursiveElementWalkingVisitor() { - @Override - public void visitReferenceParameterList(final PsiReferenceParameterList list) { - super.visitReferenceParameterList(list); - if (list.getFirstChild() != null && QUALIFIER_REFERENCE.accepts(list)) { - final LocalizeValue message = InspectionLocalize.inspectionCompilerJavacQuirksQualifierTypeArgsProblem(); - final LocalizeValue fixName = InspectionLocalize.inspectionCompilerJavacQuirksQualifierTypeArgsFix(); - myHolder.registerProblem(list, message.get(), new RemoveElementQuickFix(fixName.get())); - } + @Override + public void visitTypeCastExpression(@Nonnull final PsiTypeCastExpression expression) { + if (PsiUtil.isLanguageLevel7OrHigher(expression)) { + return; + } + final PsiTypeElement type = expression.getCastType(); + if (type != null) { + type.accept(new JavaRecursiveElementWalkingVisitor() { + @Override + public void visitReferenceParameterList(final PsiReferenceParameterList list) { + super.visitReferenceParameterList(list); + if (list.getFirstChild() != null && QUALIFIER_REFERENCE.accepts(list)) { + final LocalizeValue message = InspectionLocalize.inspectionCompilerJavacQuirksQualifierTypeArgsProblem(); + final LocalizeValue fixName = InspectionLocalize.inspectionCompilerJavacQuirksQualifierTypeArgsFix(); + myHolder.registerProblem(list, message.get(), new RemoveElementQuickFix(fixName)); + } + } + }); } - }); } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/RemoveElementQuickFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/RemoveElementQuickFix.java index 93b660f31d..128f9e5de8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/RemoveElementQuickFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/compiler/RemoveElementQuickFix.java @@ -17,35 +17,30 @@ import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; -import consulo.project.Project; import consulo.language.psi.PsiElement; -import org.jetbrains.annotations.Nls; +import consulo.localize.LocalizeValue; +import consulo.project.Project; import jakarta.annotation.Nonnull; public class RemoveElementQuickFix implements LocalQuickFix { - private final String myName; - - public RemoveElementQuickFix(@Nonnull @Nls final String name) { - myName = name; - } + @Nonnull + private final LocalizeValue myName; - @Nonnull - @Override - public String getName() { - return myName; - } + public RemoveElementQuickFix(@Nonnull LocalizeValue name) { + myName = name; + } - @Nonnull - @Override - public String getFamilyName() { - return myName; - } + @Nonnull + @Override + public LocalizeValue getName() { + return myName; + } - @Override - public void applyFix(@Nonnull final Project project, @Nonnull final ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - if (element != null) { - element.delete(); + @Override + public void applyFix(@Nonnull final Project project, @Nonnull final ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + if (element != null) { + element.delete(); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java index 1344addc5c..a2921dab7f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java @@ -1,204 +1,181 @@ // Copyright 2000-2019 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. package com.intellij.java.impl.codeInspection.dataFlow.fix; +import com.intellij.java.analysis.impl.codeInspection.dataFlow.TrackingRunner; +import com.intellij.java.language.psi.PsiExpression; +import consulo.application.ReadAction; +import consulo.application.progress.ProgressManager; +import consulo.application.util.function.ThrowableComputable; +import consulo.codeEditor.Editor; import consulo.codeEditor.EditorPopupHelper; -import consulo.language.editor.hint.HintManager; +import consulo.document.Document; +import consulo.document.util.Segment; +import consulo.document.util.TextRange; +import consulo.fileEditor.FileEditorManager; import consulo.ide.impl.idea.codeInsight.hint.HintManagerImpl; -import consulo.language.editor.intention.LowPriorityAction; -import consulo.language.editor.refactoring.unwrap.ScopeHighlighter; +import consulo.language.editor.hint.HintManager; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; -import com.intellij.java.analysis.impl.codeInspection.dataFlow.TrackingRunner; -import consulo.language.psi.PsiNavigationSupport; +import consulo.language.editor.intention.LowPriorityAction; +import consulo.language.editor.refactoring.unwrap.ScopeHighlighter; import consulo.language.inject.InjectedLanguageManager; -import consulo.application.ReadAction; -import consulo.document.Document; -import consulo.codeEditor.Editor; -import consulo.fileEditor.FileEditorManager; -import consulo.application.progress.ProgressManager; +import consulo.language.psi.PsiFile; +import consulo.language.psi.PsiNavigationSupport; +import consulo.language.psi.SmartPointerManager; +import consulo.language.psi.SmartPsiElementPointer; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.ui.ex.popup.JBPopup; import consulo.ui.ex.popup.JBPopupFactory; import consulo.ui.ex.popup.event.JBPopupAdapter; import consulo.ui.ex.popup.event.LightweightWindowEvent; import consulo.util.lang.Pair; -import consulo.document.util.Segment; -import consulo.document.util.TextRange; -import consulo.application.util.function.ThrowableComputable; import consulo.util.lang.StringUtil; -import com.intellij.java.language.psi.PsiExpression; -import consulo.language.psi.PsiFile; -import consulo.language.psi.SmartPointerManager; -import consulo.language.psi.SmartPsiElementPointer; import jakarta.annotation.Nonnull; import one.util.streamex.StreamEx; -import org.jetbrains.annotations.Nls; import javax.swing.*; import java.util.Collections; import java.util.List; import java.util.concurrent.atomic.AtomicReference; -public class FindDfaProblemCauseFix implements LocalQuickFix, LowPriorityAction -{ - private final boolean myUnknownMembersAsNullable; - private final boolean myIgnoreAssertStatements; - private final SmartPsiElementPointer myAnchor; - private final TrackingRunner.DfaProblemType myProblemType; +public class FindDfaProblemCauseFix implements LocalQuickFix, LowPriorityAction { + private final boolean myUnknownMembersAsNullable; + private final boolean myIgnoreAssertStatements; + private final SmartPsiElementPointer myAnchor; + private final TrackingRunner.DfaProblemType myProblemType; - public FindDfaProblemCauseFix(boolean unknownMembersAsNullable, - boolean ignoreAssertStatements, - PsiExpression anchor, - TrackingRunner.DfaProblemType problemType) - { - myUnknownMembersAsNullable = unknownMembersAsNullable; - myIgnoreAssertStatements = ignoreAssertStatements; - myAnchor = SmartPointerManager.createPointer(anchor); - myProblemType = problemType; - } + public FindDfaProblemCauseFix( + boolean unknownMembersAsNullable, + boolean ignoreAssertStatements, + PsiExpression anchor, + TrackingRunner.DfaProblemType problemType + ) { + myUnknownMembersAsNullable = unknownMembersAsNullable; + myIgnoreAssertStatements = ignoreAssertStatements; + myAnchor = SmartPointerManager.createPointer(anchor); + myProblemType = problemType; + } - @Override - public boolean startInWriteAction() - { - return false; - } + @Override + public boolean startInWriteAction() { + return false; + } - @Nls(capitalization = Nls.Capitalization.Sentence) - @Nonnull - @Override - public String getFamilyName() - { - return "Find cause"; - } + @Nonnull + @Override + public LocalizeValue getName() { + return LocalizeValue.localizeTODO("Find cause"); + } - @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) - { - ThrowableComputable causeFinder = () -> { - PsiExpression element = myAnchor.getElement(); - if(element == null) - { - return null; - } - return TrackingRunner.findProblemCause(myUnknownMembersAsNullable, myIgnoreAssertStatements, element, myProblemType); - }; - TrackingRunner.CauseItem item = ProgressManager.getInstance().runProcessWithProgressSynchronously( - () -> ReadAction.compute(causeFinder), "Finding Cause", true, project); - PsiFile file = myAnchor.getContainingFile(); - if(item != null && file != null) - { - displayProblemCause(file, item); - } - } + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + ThrowableComputable causeFinder = () -> { + PsiExpression element = myAnchor.getElement(); + if (element == null) { + return null; + } + return TrackingRunner.findProblemCause(myUnknownMembersAsNullable, myIgnoreAssertStatements, element, myProblemType); + }; + TrackingRunner.CauseItem item = ProgressManager.getInstance().runProcessWithProgressSynchronously( + () -> ReadAction.compute(causeFinder), "Finding Cause", true, project); + PsiFile file = myAnchor.getContainingFile(); + if (item != null && file != null) { + displayProblemCause(file, item); + } + } - private static void displayProblemCause(PsiFile file, TrackingRunner.CauseItem root) - { - Project project = file.getProject(); - Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); - if(editor == null) - { - return; - } - Document document = editor.getDocument(); - PsiFile topLevelFile = InjectedLanguageManager.getInstance(project).getTopLevelFile(file); - if(topLevelFile == null || document != topLevelFile.getViewProvider().getDocument()) - { - return; - } - class CauseWithDepth - { - final int myDepth; - final TrackingRunner.CauseItem myCauseItem; - final CauseWithDepth myParent; + private static void displayProblemCause(PsiFile file, TrackingRunner.CauseItem root) { + Project project = file.getProject(); + Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); + if (editor == null) { + return; + } + Document document = editor.getDocument(); + PsiFile topLevelFile = InjectedLanguageManager.getInstance(project).getTopLevelFile(file); + if (topLevelFile == null || document != topLevelFile.getViewProvider().getDocument()) { + return; + } + class CauseWithDepth { + final int myDepth; + final TrackingRunner.CauseItem myCauseItem; + final CauseWithDepth myParent; - CauseWithDepth(CauseWithDepth parent, TrackingRunner.CauseItem item) - { - myParent = parent; - myDepth = parent == null ? 0 : parent.myDepth + 1; - myCauseItem = item; - } + CauseWithDepth(CauseWithDepth parent, TrackingRunner.CauseItem item) { + myParent = parent; + myDepth = parent == null ? 0 : parent.myDepth + 1; + myCauseItem = item; + } - @Override - public String toString() - { - return StringUtil.repeat(" ", myDepth - 1) + myCauseItem.render(document, myParent == null ? null : myParent.myCauseItem); - } - } - List causes; - if(root == null) - { - causes = Collections.emptyList(); - } - else - { - causes = StreamEx.ofTree(new CauseWithDepth(null, root), cwd -> cwd.myCauseItem.children() - .map(child -> new CauseWithDepth(cwd, child))).skip(1).toList(); - } - if(causes.isEmpty()) - { - HintManagerImpl hintManager = (HintManagerImpl) HintManager.getInstance(); - hintManager.showErrorHint(editor, "Unable to find the cause"); - return; - } - if(causes.size() == 1) - { - TrackingRunner.CauseItem item = causes.get(0).myCauseItem; - navigate(editor, file, item); - return; - } - AtomicReference highlighter = new AtomicReference<>(new ScopeHighlighter(editor)); - JBPopup popup = JBPopupFactory.getInstance().createPopupChooserBuilder(causes) - .setSelectionMode(ListSelectionModel.SINGLE_SELECTION) - .setAccessibleName(root.toString()) - .setTitle(StringUtil.wordsToBeginFromUpperCase(root.toString())) - .setMovable(false) - .setResizable(false) - .setRequestFocus(true) - .setItemSelectedCallback((cause) -> { - ScopeHighlighter h = highlighter.get(); - if(h == null) - { - return; - } - h.dropHighlight(); - if(cause == null) - { - return; - } - Segment target = cause.myCauseItem.getTargetSegment(); - if(target == null) - { - return; - } - TextRange range = TextRange.create(target); - h.highlight(Pair.create(range, Collections.singletonList(range))); - }) - .addListener(new JBPopupAdapter() - { - @Override - public void onClosed(@Nonnull LightweightWindowEvent event) - { - highlighter.getAndSet(null).dropHighlight(); - } - }) - .setItemChosenCallback(cause -> navigate(editor, file, cause.myCauseItem)) - .createPopup(); + @Override + public String toString() { + return StringUtil.repeat(" ", myDepth - 1) + myCauseItem.render(document, myParent == null ? null : myParent.myCauseItem); + } + } + List causes; + if (root == null) { + causes = Collections.emptyList(); + } + else { + causes = StreamEx.ofTree(new CauseWithDepth(null, root), cwd -> cwd.myCauseItem.children() + .map(child -> new CauseWithDepth(cwd, child))).skip(1).toList(); + } + if (causes.isEmpty()) { + HintManagerImpl hintManager = (HintManagerImpl) HintManager.getInstance(); + hintManager.showErrorHint(editor, "Unable to find the cause"); + return; + } + if (causes.size() == 1) { + TrackingRunner.CauseItem item = causes.get(0).myCauseItem; + navigate(editor, file, item); + return; + } + AtomicReference highlighter = new AtomicReference<>(new ScopeHighlighter(editor)); + JBPopup popup = JBPopupFactory.getInstance().createPopupChooserBuilder(causes) + .setSelectionMode(ListSelectionModel.SINGLE_SELECTION) + .setAccessibleName(root.toString()) + .setTitle(StringUtil.wordsToBeginFromUpperCase(root.toString())) + .setMovable(false) + .setResizable(false) + .setRequestFocus(true) + .setItemSelectedCallback((cause) -> { + ScopeHighlighter h = highlighter.get(); + if (h == null) { + return; + } + h.dropHighlight(); + if (cause == null) { + return; + } + Segment target = cause.myCauseItem.getTargetSegment(); + if (target == null) { + return; + } + TextRange range = TextRange.create(target); + h.highlight(Pair.create(range, Collections.singletonList(range))); + }) + .addListener(new JBPopupAdapter() { + @Override + public void onClosed(@Nonnull LightweightWindowEvent event) { + highlighter.getAndSet(null).dropHighlight(); + } + }) + .setItemChosenCallback(cause -> navigate(editor, file, cause.myCauseItem)) + .createPopup(); - EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); - } + EditorPopupHelper.getInstance().showPopupInBestPositionFor(editor, popup); + } - private static void navigate(Editor editor, PsiFile file, TrackingRunner.CauseItem item) - { - Segment range = item.getTargetSegment(); - if(range == null) - { - return; - } - PsiFile targetFile = item.getFile(); - assert targetFile == file; - PsiNavigationSupport.getInstance().createNavigatable(file.getProject(), targetFile.getVirtualFile(), range.getStartOffset()) - .navigate(true); - HintManagerImpl hintManager = (HintManagerImpl) HintManager.getInstance(); - hintManager.showInformationHint(editor, StringUtil.escapeXmlEntities(StringUtil.capitalize(item.toString()))); - } + private static void navigate(Editor editor, PsiFile file, TrackingRunner.CauseItem item) { + Segment range = item.getTargetSegment(); + if (range == null) { + return; + } + PsiFile targetFile = item.getFile(); + assert targetFile == file; + PsiNavigationSupport.getInstance().createNavigatable(file.getProject(), targetFile.getVirtualFile(), range.getStartOffset()) + .navigate(true); + HintManagerImpl hintManager = (HintManagerImpl) HintManager.getInstance(); + hintManager.showInformationHint(editor, StringUtil.escapeXmlEntities(StringUtil.capitalize(item.toString()))); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/defaultFileTemplateUsage/ReplaceWithFileTemplateFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/defaultFileTemplateUsage/ReplaceWithFileTemplateFix.java index eaf56a04c3..ca8d3e0aa7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/defaultFileTemplateUsage/ReplaceWithFileTemplateFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/defaultFileTemplateUsage/ReplaceWithFileTemplateFix.java @@ -17,21 +17,16 @@ import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.localize.InspectionLocalize; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; /** * @author cdr */ public abstract class ReplaceWithFileTemplateFix implements LocalQuickFix { - @Override - @Nonnull - public String getName() { - return InspectionLocalize.defaultFileTemplateReplaceWithActualFileTemplate().get(); - } - - @Override - @Nonnull - public String getFamilyName() { - return getName(); - } + @Override + @Nonnull + public LocalizeValue getName() { + return InspectionLocalize.defaultFileTemplateReplaceWithActualFileTemplate(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dependencyViolation/DependencyInspection.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dependencyViolation/DependencyInspection.java index 4c794993b5..f46630f251 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dependencyViolation/DependencyInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dependencyViolation/DependencyInspection.java @@ -45,109 +45,119 @@ import java.util.ArrayList; /** - * User: anna - * Date: Feb 6, 2005 + * @author anna + * @since 2005-02-06 */ @ExtensionImpl public class DependencyInspection extends BaseLocalInspectionTool { - public static final String SHORT_NAME = "Dependency"; - - @Override - public boolean isEnabledByDefault() { - return true; - } - - @Override - @Nonnull - public LocalizeValue getGroupDisplayName() { - return LocalizeValue.empty(); - } - - @Override - @Nonnull - public LocalizeValue getDisplayName() { - return InspectionLocalize.illegalPackageDependencies(); - } - - @Override - @Nonnull - public String getShortName() { - return DependencyInspection.SHORT_NAME; - } - - @Override - public JComponent createOptionsPanel() { - final JButton editDependencies = new JButton(InspectionLocalize.inspectionDependencyConfigureButtonText().get()); - editDependencies.addActionListener(e-> { - Project project = DataManager.getInstance().getDataContext(editDependencies).getData(Project.KEY); - if (project == null) project = ProjectManager.getInstance().getDefaultProject(); - ShowSettingsUtil.getInstance().editConfigurable(editDependencies, new DependencyConfigurable(project)); - }); - - JPanel depPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); - depPanel.add(editDependencies); - return depPanel; - } - - @Override - @Nullable - public ProblemDescriptor[] checkFile(@Nonnull final PsiFile file, @Nonnull final InspectionManager manager, final boolean isOnTheFly, Object state) { - if (file == null) return null; - if (file.getViewProvider().getPsi(JavaLanguage.INSTANCE) == null) return null; - final DependencyValidationManager validationManager = DependencyValidationManager.getInstance(file.getProject()); - if (!validationManager.hasRules()) return null; - if (validationManager.getApplicableRules(file).length == 0) return null; - final ArrayList problems = new ArrayList<>(); - ForwardDependenciesBuilder builder = new ForwardDependenciesBuilder(file.getProject(), new AnalysisScope(file)); - DependenciesBuilder.analyzeFileDependencies(file, (place, dependency) -> { - PsiFile dependencyFile = dependency.getContainingFile(); - if (dependencyFile != null && dependencyFile.isPhysical() && dependencyFile.getVirtualFile() != null) { - final DependencyRule[] rule = validationManager.getViolatorDependencyRules(file, dependencyFile); - for (DependencyRule dependencyRule : rule) { - StringBuilder message = new StringBuilder(); - message.append(InspectionLocalize.inspectionDependencyViolatorProblemDescriptor(dependencyRule.getDisplayText())); - problems.add(manager.createProblemDescriptor( - place, - message.toString(), - isOnTheFly, - new LocalQuickFix[]{new EditDependencyRulesAction(dependencyRule)}, - ProblemHighlightType.GENERIC_ERROR_OR_WARNING - )); - } - } - }); - return problems.isEmpty() ? null : problems.toArray(new ProblemDescriptor[problems.size()]); - } - - @Override - @Nonnull - public HighlightDisplayLevel getDefaultLevel() { - return HighlightDisplayLevel.ERROR; - } - - private static class EditDependencyRulesAction implements LocalQuickFix { - private final DependencyRule myRule; - public EditDependencyRulesAction(DependencyRule rule) { - myRule = rule; + public static final String SHORT_NAME = "Dependency"; + + @Override + public boolean isEnabledByDefault() { + return true; + } + + @Override + @Nonnull + public LocalizeValue getGroupDisplayName() { + return LocalizeValue.empty(); } @Override @Nonnull - public LocalizeValue getName() { - return InspectionLocalize.editDependencyRulesText(myRule.getDisplayText()); + public LocalizeValue getDisplayName() { + return InspectionLocalize.illegalPackageDependencies(); } + @Override @Nonnull - public String getFamilyName() { - return InspectionLocalize.editDependencyRulesFamily().get(); + public String getShortName() { + return DependencyInspection.SHORT_NAME; } - @RequiredUIAccess @Override - public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { - ShowSettingsUtil.getInstance().editConfigurable(project, new DependencyConfigurable(project)); + public JComponent createOptionsPanel() { + final JButton editDependencies = new JButton(InspectionLocalize.inspectionDependencyConfigureButtonText().get()); + editDependencies.addActionListener(e -> { + Project project = DataManager.getInstance().getDataContext(editDependencies).getData(Project.KEY); + if (project == null) { + project = ProjectManager.getInstance().getDefaultProject(); + } + ShowSettingsUtil.getInstance().editConfigurable(editDependencies, new DependencyConfigurable(project)); + }); + + JPanel depPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); + depPanel.add(editDependencies); + return depPanel; } - } + @Override + @Nullable + public ProblemDescriptor[] checkFile( + @Nonnull final PsiFile file, + @Nonnull final InspectionManager manager, + final boolean isOnTheFly, + Object state + ) { + if (file == null) { + return null; + } + if (file.getViewProvider().getPsi(JavaLanguage.INSTANCE) == null) { + return null; + } + final DependencyValidationManager validationManager = DependencyValidationManager.getInstance(file.getProject()); + if (!validationManager.hasRules()) { + return null; + } + if (validationManager.getApplicableRules(file).length == 0) { + return null; + } + final ArrayList problems = new ArrayList<>(); + ForwardDependenciesBuilder builder = new ForwardDependenciesBuilder(file.getProject(), new AnalysisScope(file)); + DependenciesBuilder.analyzeFileDependencies(file, (place, dependency) -> { + PsiFile dependencyFile = dependency.getContainingFile(); + if (dependencyFile != null && dependencyFile.isPhysical() && dependencyFile.getVirtualFile() != null) { + final DependencyRule[] rule = validationManager.getViolatorDependencyRules(file, dependencyFile); + for (DependencyRule dependencyRule : rule) { + StringBuilder message = new StringBuilder(); + message.append(InspectionLocalize.inspectionDependencyViolatorProblemDescriptor(dependencyRule.getDisplayText())); + problems.add(manager.createProblemDescriptor( + place, + message.toString(), + isOnTheFly, + new LocalQuickFix[]{new EditDependencyRulesAction(dependencyRule)}, + ProblemHighlightType.GENERIC_ERROR_OR_WARNING + )); + } + } + }); + return problems.isEmpty() ? null : problems.toArray(new ProblemDescriptor[problems.size()]); + } + + @Override + @Nonnull + public HighlightDisplayLevel getDefaultLevel() { + return HighlightDisplayLevel.ERROR; + } + + private static class EditDependencyRulesAction implements LocalQuickFix { + private final DependencyRule myRule; + + public EditDependencyRulesAction(DependencyRule rule) { + myRule = rule; + } + + @Override + @Nonnull + public LocalizeValue getName() { + return InspectionLocalize.editDependencyRulesText(myRule.getDisplayText()); + } + + @RequiredUIAccess + @Override + public void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + ShowSettingsUtil.getInstance().editConfigurable(project, new DependencyConfigurable(project)); + } + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/duplicateStringLiteral/DuplicateStringLiteralInspection.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/duplicateStringLiteral/DuplicateStringLiteralInspection.java index 10ef43d96a..6d4eaf1b80 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/duplicateStringLiteral/DuplicateStringLiteralInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/duplicateStringLiteral/DuplicateStringLiteralInspection.java @@ -62,381 +62,384 @@ @ExtensionImpl public class DuplicateStringLiteralInspection extends BaseLocalInspectionTool { - private static final Logger LOG = Logger.getInstance(DuplicateStringLiteralInspection.class); - @SuppressWarnings({"WeakerAccess"}) - public int MIN_STRING_LENGTH = 5; - @SuppressWarnings({"WeakerAccess"}) - public boolean IGNORE_PROPERTY_KEYS = false; - @NonNls - private static final String BR = "
          "; - - @Override - @Nonnull - public PsiElementVisitor buildVisitorImpl( - @Nonnull final ProblemsHolder holder, - final boolean isOnTheFly, - LocalInspectionToolSession session, - Object state - ) { - return new JavaElementVisitor() { - @Override - public void visitReferenceExpression(@Nonnull final PsiReferenceExpression expression) { - visitExpression(expression); - } - - @Override - public void visitLiteralExpression(@Nonnull PsiLiteralExpression expression) { - checkStringLiteralExpression(expression, holder, isOnTheFly); - } - }; - } - - @Override - @Nonnull - public LocalizeValue getDisplayName() { - return InspectionLocalize.inspectionDuplicatesDisplayName(); - } - - @Override - @Nonnull - public LocalizeValue getGroupDisplayName() { - return InspectionLocalize.groupNamesInternationalizationIssues(); - } - - @Override - @Nonnull - public String getShortName() { - return "DuplicateStringLiteralInspection"; - } - - @RequiredReadAction - private void checkStringLiteralExpression( - @Nonnull final PsiLiteralExpression originalExpression, - @Nonnull ProblemsHolder holder, - final boolean isOnTheFly - ) { - Object value = originalExpression.getValue(); - if (!(value instanceof String)) { - return; - } - final Project project = holder.getProject(); - if (!shouldCheck(project, originalExpression)) { - return; - } - final String stringToFind = (String) value; - if (stringToFind.isEmpty()) { - return; + private static final Logger LOG = Logger.getInstance(DuplicateStringLiteralInspection.class); + @SuppressWarnings({"WeakerAccess"}) + public int MIN_STRING_LENGTH = 5; + @SuppressWarnings({"WeakerAccess"}) + public boolean IGNORE_PROPERTY_KEYS = false; + @NonNls + private static final String BR = "
          "; + + @Override + @Nonnull + public PsiElementVisitor buildVisitorImpl( + @Nonnull final ProblemsHolder holder, + final boolean isOnTheFly, + LocalInspectionToolSession session, + Object state + ) { + return new JavaElementVisitor() { + @Override + public void visitReferenceExpression(@Nonnull final PsiReferenceExpression expression) { + visitExpression(expression); + } + + @Override + public void visitLiteralExpression(@Nonnull PsiLiteralExpression expression) { + checkStringLiteralExpression(expression, holder, isOnTheFly); + } + }; } - final GlobalSearchScope scope = GlobalSearchScope.projectScope(originalExpression.getProject()); - final PsiSearchHelper searchHelper = PsiSearchHelper.SERVICE.getInstance(holder.getFile().getProject()); - final List words = StringUtil.getWordsIn(stringToFind); - if (words.isEmpty()) { - return; + + @Override + @Nonnull + public LocalizeValue getDisplayName() { + return InspectionLocalize.inspectionDuplicatesDisplayName(); } - // put longer strings first - Collections.sort(words, (o1, o2) -> o2.length() - o1.length()); - - final ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); - Set resultFiles = null; - for (String word : words) { - if (word.length() < MIN_STRING_LENGTH) { - continue; - } - progress.checkCanceled(); - final Set files = new HashSet<>(); - searchHelper.processAllFilesWithWordInLiterals(word, scope, new CommonProcessors.CollectProcessor<>(files)); - if (resultFiles == null) { - resultFiles = files; - } else { - resultFiles.retainAll(files); - } - if (resultFiles.isEmpty()) { - return; - } + + @Override + @Nonnull + public LocalizeValue getGroupDisplayName() { + return InspectionLocalize.groupNamesInternationalizationIssues(); } - if (resultFiles == null || resultFiles.isEmpty()) { - return; + @Override + @Nonnull + public String getShortName() { + return "DuplicateStringLiteralInspection"; } - final List foundExpr = new ArrayList<>(); - - for (final PsiFile file : resultFiles) { - progress.checkCanceled(); - FileViewProvider viewProvider = file.getViewProvider(); - // important: skip non-java files with given word in literal (IDEA-126201) - if (viewProvider.getPsi(JavaLanguage.INSTANCE) == null) { - continue; - } - CharSequence text = viewProvider.getContents(); - StringSearcher searcher = new StringSearcher(stringToFind, true, true); - - LowLevelSearchUtil.processTextOccurrences(text, 0, text.length(), searcher, progress, offset -> { - PsiElement element = file.findElementAt(offset); - if (element == null || !(element.getParent() instanceof PsiLiteralExpression)) { - return true; + + @RequiredReadAction + private void checkStringLiteralExpression( + @Nonnull final PsiLiteralExpression originalExpression, + @Nonnull ProblemsHolder holder, + final boolean isOnTheFly + ) { + Object value = originalExpression.getValue(); + if (!(value instanceof String)) { + return; } - PsiLiteralExpression expression = (PsiLiteralExpression) element.getParent(); - if (expression != originalExpression && Comparing.equal(stringToFind, - expression.getValue()) && shouldCheck(project, expression)) { - foundExpr.add(expression); + final Project project = holder.getProject(); + if (!shouldCheck(project, originalExpression)) { + return; + } + final String stringToFind = (String) value; + if (stringToFind.isEmpty()) { + return; + } + final GlobalSearchScope scope = GlobalSearchScope.projectScope(originalExpression.getProject()); + final PsiSearchHelper searchHelper = PsiSearchHelper.SERVICE.getInstance(holder.getFile().getProject()); + final List words = StringUtil.getWordsIn(stringToFind); + if (words.isEmpty()) { + return; + } + // put longer strings first + Collections.sort(words, (o1, o2) -> o2.length() - o1.length()); + + final ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); + Set resultFiles = null; + for (String word : words) { + if (word.length() < MIN_STRING_LENGTH) { + continue; + } + progress.checkCanceled(); + final Set files = new HashSet<>(); + searchHelper.processAllFilesWithWordInLiterals(word, scope, new CommonProcessors.CollectProcessor<>(files)); + if (resultFiles == null) { + resultFiles = files; + } + else { + resultFiles.retainAll(files); + } + if (resultFiles.isEmpty()) { + return; + } } - return true; - }); - } - if (foundExpr.isEmpty()) { - return; - } - Set classes = new HashSet<>(); - for (PsiElement aClass : foundExpr) { - progress.checkCanceled(); - do { - aClass = PsiTreeUtil.getParentOfType(aClass, PsiClass.class); - } - while (aClass != null && ((PsiClass) aClass).getQualifiedName() == null); - if (aClass != null) { - classes.add((PsiClass) aClass); - } - } - if (classes.isEmpty()) { - return; - } - List tenClassesMost = Arrays.asList(classes.toArray(new PsiClass[classes.size()])); - if (tenClassesMost.size() > 10) { - tenClassesMost = tenClassesMost.subList(0, 10); - } + if (resultFiles == null || resultFiles.isEmpty()) { + return; + } + final List foundExpr = new ArrayList<>(); + + for (final PsiFile file : resultFiles) { + progress.checkCanceled(); + FileViewProvider viewProvider = file.getViewProvider(); + // important: skip non-java files with given word in literal (IDEA-126201) + if (viewProvider.getPsi(JavaLanguage.INSTANCE) == null) { + continue; + } + CharSequence text = viewProvider.getContents(); + StringSearcher searcher = new StringSearcher(stringToFind, true, true); + + LowLevelSearchUtil.processTextOccurrences(text, 0, text.length(), searcher, progress, offset -> { + PsiElement element = file.findElementAt(offset); + if (element == null || !(element.getParent() instanceof PsiLiteralExpression)) { + return true; + } + PsiLiteralExpression expression = (PsiLiteralExpression) element.getParent(); + if (expression != originalExpression && Comparing.equal( + stringToFind, + expression.getValue() + ) && shouldCheck(project, expression)) { + foundExpr.add(expression); + } + return true; + }); + } + if (foundExpr.isEmpty()) { + return; + } + Set classes = new HashSet<>(); + for (PsiElement aClass : foundExpr) { + progress.checkCanceled(); + do { + aClass = PsiTreeUtil.getParentOfType(aClass, PsiClass.class); + } + while (aClass != null && ((PsiClass) aClass).getQualifiedName() == null); + if (aClass != null) { + classes.add((PsiClass) aClass); + } + } + if (classes.isEmpty()) { + return; + } - String classList; - if (isOnTheFly) { - classList = StringUtil.join(tenClassesMost, aClass -> { - final boolean thisFile = aClass.getContainingFile() == originalExpression.getContainingFile(); - //noinspection HardCodedStringLiteral - return "   '" + aClass.getQualifiedName() + "'" + - (thisFile ? " " + InspectionLocalize.inspectionDuplicatesMessageInThisFile().get() - : ""); - }, ", " + BR); - } else { - classList = StringUtil.join(tenClassesMost, aClass -> "'" + aClass.getQualifiedName() + "'", ", "); - } + List tenClassesMost = Arrays.asList(classes.toArray(new PsiClass[classes.size()])); + if (tenClassesMost.size() > 10) { + tenClassesMost = tenClassesMost.subList(0, 10); + } - if (classes.size() > tenClassesMost.size()) { - classList += BR + InspectionLocalize.inspectionDuplicatesMessageMore(classes.size() - 10).get(); - } + String classList; + if (isOnTheFly) { + classList = StringUtil.join(tenClassesMost, aClass -> { + final boolean thisFile = aClass.getContainingFile() == originalExpression.getContainingFile(); + //noinspection HardCodedStringLiteral + return "   '" + aClass.getQualifiedName() + "'" + + (thisFile ? " " + InspectionLocalize.inspectionDuplicatesMessageInThisFile().get() + : ""); + }, ", " + BR); + } + else { + classList = StringUtil.join(tenClassesMost, aClass -> "'" + aClass.getQualifiedName() + "'", ", "); + } + + if (classes.size() > tenClassesMost.size()) { + classList += BR + InspectionLocalize.inspectionDuplicatesMessageMore(classes.size() - 10).get(); + } - String msg = InspectionLocalize.inspectionDuplicatesMessage(classList).get(); + String msg = InspectionLocalize.inspectionDuplicatesMessage(classList).get(); - Collection fixes = new SmartList<>(); - if (isOnTheFly) { - final LocalQuickFix introduceConstFix = createIntroduceConstFix(foundExpr, originalExpression); - fixes.add(introduceConstFix); - } - createReplaceFixes(foundExpr, originalExpression, fixes); - LocalQuickFix[] array = fixes.toArray(new LocalQuickFix[fixes.size()]); - holder.registerProblem(originalExpression, msg, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, array); - } - - private boolean shouldCheck(@Nonnull Project project, @Nonnull PsiLiteralExpression expression) { - return !(IGNORE_PROPERTY_KEYS && JavaI18nUtil.mustBePropertyKey(project, expression, new HashMap<>())) - && !SuppressManager.isSuppressedInspectionName(expression); - } - - private static void createReplaceFixes( - final List foundExpr, - final PsiLiteralExpression originalExpression, - final Collection fixes - ) { - Set constants = new HashSet<>(); - for (Iterator iterator = foundExpr.iterator(); iterator.hasNext(); ) { - PsiExpression expression1 = iterator.next(); - PsiElement parent = expression1.getParent(); - if (parent instanceof PsiField field) { - if (field.getInitializer() == expression1 && field.hasModifierProperty(PsiModifier.STATIC)) { - constants.add(field); - iterator.remove(); + Collection fixes = new SmartList<>(); + if (isOnTheFly) { + final LocalQuickFix introduceConstFix = createIntroduceConstFix(foundExpr, originalExpression); + fixes.add(introduceConstFix); } - } - } - for (final PsiField constant : constants) { - final PsiClass containingClass = constant.getContainingClass(); - if (containingClass == null) { - continue; - } - boolean isAccessible = JavaPsiFacade.getInstance(constant.getProject()).getResolveHelper() - .isAccessible(constant, originalExpression, containingClass); - if (!isAccessible && containingClass.getQualifiedName() == null) { - continue; - } - final LocalQuickFix replaceQuickFix = new ReplaceFix(constant, originalExpression); - fixes.add(replaceQuickFix); - } - } - - private static LocalQuickFix createIntroduceConstFix( - final List foundExpr, - final PsiLiteralExpression originalExpression - ) { - final PsiExpression[] expressions = foundExpr.toArray(new PsiExpression[foundExpr.size() + 1]); - expressions[foundExpr.size()] = originalExpression; - - return new IntroduceLiteralConstantFix(expressions); - } - - @Nullable - @RequiredWriteAction - private static PsiReferenceExpression createReferenceTo( - final PsiField constant, - final PsiLiteralExpression context - ) throws IncorrectOperationException { - PsiElementFactory factory = JavaPsiFacade.getInstance(constant.getProject()).getElementFactory(); - PsiReferenceExpression reference = (PsiReferenceExpression) factory.createExpressionFromText(constant.getName(), context); - if (reference.isReferenceTo(constant)) { - return reference; - } - reference = (PsiReferenceExpression) factory.createExpressionFromText("XXX." + constant.getName(), null); - final PsiReferenceExpression classQualifier = (PsiReferenceExpression) reference.getQualifierExpression(); - PsiClass containingClass = constant.getContainingClass(); - if (containingClass.getQualifiedName() == null) { - return null; + createReplaceFixes(foundExpr, originalExpression, fixes); + LocalQuickFix[] array = fixes.toArray(new LocalQuickFix[fixes.size()]); + holder.registerProblem(originalExpression, msg, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, array); } - classQualifier.bindToElement(containingClass); - if (reference.isReferenceTo(constant)) { - return reference; + private boolean shouldCheck(@Nonnull Project project, @Nonnull PsiLiteralExpression expression) { + return !(IGNORE_PROPERTY_KEYS && JavaI18nUtil.mustBePropertyKey(project, expression, new HashMap<>())) + && !SuppressManager.isSuppressedInspectionName(expression); } - return null; - } - - @Override - public boolean isEnabledByDefault() { - return false; - } - - @Override - public JComponent createOptionsPanel() { - final OptionsPanel optionsPanel = new OptionsPanel(); - optionsPanel.myIgnorePropertyKeyExpressions - .addActionListener(e -> IGNORE_PROPERTY_KEYS = optionsPanel.myIgnorePropertyKeyExpressions.isSelected()); - optionsPanel.myMinStringLengthField.getDocument().addDocumentListener(new DocumentAdapter() { - @Override - protected void textChanged(final DocumentEvent e) { - try { - MIN_STRING_LENGTH = Integer.parseInt(optionsPanel.myMinStringLengthField.getText()); - } catch (NumberFormatException ignored) { + + private static void createReplaceFixes( + final List foundExpr, + final PsiLiteralExpression originalExpression, + final Collection fixes + ) { + Set constants = new HashSet<>(); + for (Iterator iterator = foundExpr.iterator(); iterator.hasNext(); ) { + PsiExpression expression1 = iterator.next(); + PsiElement parent = expression1.getParent(); + if (parent instanceof PsiField field) { + if (field.getInitializer() == expression1 && field.hasModifierProperty(PsiModifier.STATIC)) { + constants.add(field); + iterator.remove(); + } + } + } + for (final PsiField constant : constants) { + final PsiClass containingClass = constant.getContainingClass(); + if (containingClass == null) { + continue; + } + boolean isAccessible = JavaPsiFacade.getInstance(constant.getProject()).getResolveHelper() + .isAccessible(constant, originalExpression, containingClass); + if (!isAccessible && containingClass.getQualifiedName() == null) { + continue; + } + final LocalQuickFix replaceQuickFix = new ReplaceFix(constant, originalExpression); + fixes.add(replaceQuickFix); } - } - }); - optionsPanel.myIgnorePropertyKeyExpressions.setSelected(IGNORE_PROPERTY_KEYS); - optionsPanel.myMinStringLengthField.setText(Integer.toString(MIN_STRING_LENGTH)); - return optionsPanel.myPanel; - } - - public static class OptionsPanel { - private JTextField myMinStringLengthField; - private JPanel myPanel; - private JCheckBox myIgnorePropertyKeyExpressions; - } - - private static class IntroduceLiteralConstantFix implements LocalQuickFix { - private final SmartPsiElementPointer[] myExpressions; - - public IntroduceLiteralConstantFix(final PsiExpression[] expressions) { - myExpressions = new SmartPsiElementPointer[expressions.length]; - for (int i = 0; i < expressions.length; i++) { - PsiExpression expression = expressions[i]; - myExpressions[i] = SmartPointerManager.getInstance(expression.getProject()) - .createSmartPsiElementPointer(expression); - } } - @Override - @Nonnull - public LocalizeValue getName() { - return InspectionLocalize.introduceConstantAcrossTheProject(); + private static LocalQuickFix createIntroduceConstFix( + final List foundExpr, + final PsiLiteralExpression originalExpression + ) { + final PsiExpression[] expressions = foundExpr.toArray(new PsiExpression[foundExpr.size() + 1]); + expressions[foundExpr.size()] = originalExpression; + + return new IntroduceLiteralConstantFix(expressions); } - @Override - public void applyFix(@Nonnull final Project project, @Nonnull ProblemDescriptor descriptor) { - SwingUtilities.invokeLater(() -> { - if (project.isDisposed()) { - return; + @Nullable + @RequiredWriteAction + private static PsiReferenceExpression createReferenceTo( + final PsiField constant, + final PsiLiteralExpression context + ) throws IncorrectOperationException { + PsiElementFactory factory = JavaPsiFacade.getInstance(constant.getProject()).getElementFactory(); + PsiReferenceExpression reference = (PsiReferenceExpression) factory.createExpressionFromText(constant.getName(), context); + if (reference.isReferenceTo(constant)) { + return reference; } - final List expressions = new ArrayList<>(); - for (SmartPsiElementPointer ptr : myExpressions) { - final PsiElement element = ptr.getElement(); - if (element != null) { - expressions.add((PsiExpression) element); - } + reference = (PsiReferenceExpression) factory.createExpressionFromText("XXX." + constant.getName(), null); + final PsiReferenceExpression classQualifier = (PsiReferenceExpression) reference.getQualifierExpression(); + PsiClass containingClass = constant.getContainingClass(); + if (containingClass.getQualifiedName() == null) { + return null; } - final PsiExpression[] expressionArray = expressions.toArray(new PsiExpression[expressions.size()]); - final IntroduceConstantHandlerImpl handler = new IntroduceConstantHandlerImpl() { - @Override - protected OccurrenceManager createOccurrenceManager(PsiExpression selectedExpr, PsiClass parentClass) { - final OccurrenceFilter filter = occurrence -> true; - return new BaseOccurrenceManager(filter) { - @Override - protected PsiExpression[] defaultOccurrences() { - return expressionArray; - } - - @Override - protected PsiExpression[] findOccurrences() { - return expressionArray; - } - }; - } - }; - handler.invoke(project, expressionArray); - }); - } - } - - private static class ReplaceFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private final LocalizeValue myText; - private final SmartPsiElementPointer myConst; - - public ReplaceFix(PsiField constant, PsiLiteralExpression originalExpression) { - super(originalExpression); - myText = InspectionLocalize.inspectionDuplicatesReplaceQuickfix(PsiFormatUtil.formatVariable( - constant, - PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_FQ_NAME | PsiFormatUtilBase.SHOW_NAME, - PsiSubstitutor.EMPTY) - ); - myConst = SmartPointerManager.getInstance(constant.getProject()).createSmartPsiElementPointer(constant); + classQualifier.bindToElement(containingClass); + + if (reference.isReferenceTo(constant)) { + return reference; + } + return null; } - @Nonnull @Override - public LocalizeValue getText() { - return myText; + public boolean isEnabledByDefault() { + return false; } @Override - @RequiredWriteAction - public void invoke( - @Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement - ) { - final PsiLiteralExpression myOriginalExpression = (PsiLiteralExpression) startElement; - final PsiField myConstant = myConst.getElement(); - if (myConstant == null || !FileModificationService.getInstance().prepareFileForWrite(myOriginalExpression.getContainingFile())) { - return; - } - try { - final PsiReferenceExpression reference = createReferenceTo(myConstant, myOriginalExpression); - if (reference != null) { - myOriginalExpression.replace(reference); + public JComponent createOptionsPanel() { + final OptionsPanel optionsPanel = new OptionsPanel(); + optionsPanel.myIgnorePropertyKeyExpressions + .addActionListener(e -> IGNORE_PROPERTY_KEYS = optionsPanel.myIgnorePropertyKeyExpressions.isSelected()); + optionsPanel.myMinStringLengthField.getDocument().addDocumentListener(new DocumentAdapter() { + @Override + protected void textChanged(final DocumentEvent e) { + try { + MIN_STRING_LENGTH = Integer.parseInt(optionsPanel.myMinStringLengthField.getText()); + } + catch (NumberFormatException ignored) { + } + } + }); + optionsPanel.myIgnorePropertyKeyExpressions.setSelected(IGNORE_PROPERTY_KEYS); + optionsPanel.myMinStringLengthField.setText(Integer.toString(MIN_STRING_LENGTH)); + return optionsPanel.myPanel; + } + + public static class OptionsPanel { + private JTextField myMinStringLengthField; + private JPanel myPanel; + private JCheckBox myIgnorePropertyKeyExpressions; + } + + private static class IntroduceLiteralConstantFix implements LocalQuickFix { + private final SmartPsiElementPointer[] myExpressions; + + public IntroduceLiteralConstantFix(final PsiExpression[] expressions) { + myExpressions = new SmartPsiElementPointer[expressions.length]; + for (int i = 0; i < expressions.length; i++) { + PsiExpression expression = expressions[i]; + myExpressions[i] = SmartPointerManager.getInstance(expression.getProject()) + .createSmartPsiElementPointer(expression); + } + } + + @Override + @Nonnull + public LocalizeValue getName() { + return InspectionLocalize.introduceConstantAcrossTheProject(); + } + + @Override + public void applyFix(@Nonnull final Project project, @Nonnull ProblemDescriptor descriptor) { + SwingUtilities.invokeLater(() -> { + if (project.isDisposed()) { + return; + } + final List expressions = new ArrayList<>(); + for (SmartPsiElementPointer ptr : myExpressions) { + final PsiElement element = ptr.getElement(); + if (element != null) { + expressions.add((PsiExpression) element); + } + } + final PsiExpression[] expressionArray = expressions.toArray(new PsiExpression[expressions.size()]); + final IntroduceConstantHandlerImpl handler = new IntroduceConstantHandlerImpl() { + @Override + protected OccurrenceManager createOccurrenceManager(PsiExpression selectedExpr, PsiClass parentClass) { + final OccurrenceFilter filter = occurrence -> true; + return new BaseOccurrenceManager(filter) { + @Override + protected PsiExpression[] defaultOccurrences() { + return expressionArray; + } + + @Override + protected PsiExpression[] findOccurrences() { + return expressionArray; + } + }; + } + }; + handler.invoke(project, expressionArray); + }); } - } catch (IncorrectOperationException e) { - LOG.error(e); - } } - @Nonnull - public LocalizeValue getFamilyName() { - return InspectionLocalize.inspectionDuplicatesReplaceFamilyQuickfix(); + private static class ReplaceFix extends LocalQuickFixAndIntentionActionOnPsiElement { + private final LocalizeValue myText; + private final SmartPsiElementPointer myConst; + + public ReplaceFix(PsiField constant, PsiLiteralExpression originalExpression) { + super(originalExpression); + myText = InspectionLocalize.inspectionDuplicatesReplaceQuickfix(PsiFormatUtil.formatVariable( + constant, + PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_FQ_NAME | PsiFormatUtilBase.SHOW_NAME, + PsiSubstitutor.EMPTY + ) + ); + myConst = SmartPointerManager.getInstance(constant.getProject()).createSmartPsiElementPointer(constant); + } + + @Nonnull + @Override + public LocalizeValue getText() { + return myText; + } + + @Override + @RequiredWriteAction + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiLiteralExpression myOriginalExpression = (PsiLiteralExpression) startElement; + final PsiField myConstant = myConst.getElement(); + if (myConstant == null || !FileModificationService.getInstance() + .prepareFileForWrite(myOriginalExpression.getContainingFile())) { + return; + } + try { + final PsiReferenceExpression reference = createReferenceTo(myConstant, myOriginalExpression); + if (reference != null) { + myOriginalExpression.replace(reference); + } + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + } } - } }