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 35cd2c9ea..894f6fd81 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 @@ -22,6 +22,7 @@ import com.intellij.java.language.psi.PsiField; import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; import consulo.java.deadCodeNotWorking.OldStyleInspection; import consulo.language.Language; import consulo.language.editor.inspection.*; @@ -50,6 +51,7 @@ public Set requiredFeatures() { } @Override + @RequiredReadAction public boolean isAvailableForFile(@Nonnull PsiFile file) { for (JavaFeature feature : requiredFeatures()) { if (!PsiUtil.isAvailable(feature, file)) { @@ -154,26 +156,31 @@ public PsiElementVisitor buildVisitorImpl( ) { return new JavaElementVisitor() { @Override - public void visitMethod(PsiMethod method) { + @RequiredReadAction + public void visitMethod(@Nonnull PsiMethod method) { addDescriptors(checkMethod(method, holder.getManager(), isOnTheFly, state)); } @Override - public void visitClass(PsiClass aClass) { + @RequiredReadAction + public void visitClass(@Nonnull PsiClass aClass) { addDescriptors(checkClass(aClass, holder.getManager(), isOnTheFly, state)); } @Override - public void visitField(PsiField field) { + @RequiredReadAction + public void visitField(@Nonnull PsiField field) { addDescriptors(checkField(field, holder.getManager(), isOnTheFly, state)); } @Override + @RequiredReadAction public void visitFile(PsiFile file) { addDescriptors(checkFile(file, holder.getManager(), isOnTheFly, state)); } - private void addDescriptors(final ProblemDescriptor[] descriptors) { + @RequiredReadAction + private void addDescriptors(ProblemDescriptor[] descriptors) { if (descriptors != null) { for (ProblemDescriptor descriptor : descriptors) { holder.registerProblem(descriptor); @@ -184,7 +191,7 @@ private void addDescriptors(final ProblemDescriptor[] descriptors) { } @Override - public PsiNamedElement getProblemElement(final PsiElement psiElement) { + public PsiNamedElement getProblemElement(PsiElement psiElement) { return PsiTreeUtil.getNonStrictParentOfType(psiElement, PsiFile.class, PsiClass.class, PsiMethod.class, PsiField.class); } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DataFlowInspectionStateBase.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DataFlowInspectionStateBase.java index af4bf16ac..733311a6f 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DataFlowInspectionStateBase.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/DataFlowInspectionStateBase.java @@ -2,16 +2,15 @@ /** * @author VISTALL - * @since 19/03/2023 + * @since 2023-03-19 */ -public class DataFlowInspectionStateBase -{ - public boolean SUGGEST_NULLABLE_ANNOTATIONS; - public boolean DONT_REPORT_TRUE_ASSERT_STATEMENTS; - public boolean TREAT_UNKNOWN_MEMBERS_AS_NULLABLE; - public boolean IGNORE_ASSERT_STATEMENTS; - public boolean REPORT_CONSTANT_REFERENCE_VALUES = true; - public boolean REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER = true; - public boolean REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL = true; - public boolean REPORT_UNSOUND_WARNINGS = true; +public class DataFlowInspectionStateBase { + public boolean SUGGEST_NULLABLE_ANNOTATIONS; + public boolean DONT_REPORT_TRUE_ASSERT_STATEMENTS; + public boolean TREAT_UNKNOWN_MEMBERS_AS_NULLABLE; + public boolean IGNORE_ASSERT_STATEMENTS; + public boolean REPORT_CONSTANT_REFERENCE_VALUES = true; + public boolean REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER = true; + public boolean REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL = true; + public boolean REPORT_UNSOUND_WARNINGS = true; } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/NullabilityProblemKind.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/NullabilityProblemKind.java index a1909490a..58a78ab8f 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/NullabilityProblemKind.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/NullabilityProblemKind.java @@ -223,7 +223,7 @@ public static NullabilityProblem fromContext( } PsiElement parent = context.getParent(); if (parent instanceof PsiReferenceExpression refExpr) { - if (refExpr.resolve() instanceof PsiMember member && member.hasModifierProperty(PsiModifier.STATIC)) { + if (refExpr.resolve() instanceof PsiMember member && member.isStatic()) { return null; } if (parent.getParent() instanceof PsiMethodCallExpression methodCall) { @@ -400,7 +400,7 @@ private static NullabilityProblem getAssignmentProblem( } if (nullability == Nullability.UNKNOWN && lho instanceof PsiReferenceExpression lhoRefExpr) { PsiField field = ObjectUtil.tryCast(lhoRefExpr.resolve(), PsiField.class); - if (field != null && !field.hasModifierProperty(PsiModifier.FINAL)) { + if (field != null && !field.isFinal()) { return assigningToNonAnnotatedField.problem(context, expression); } } @@ -573,17 +573,17 @@ public PsiExpression getDereferencedExpression() { } @Nonnull - public String getMessage(Map expressions) { + public LocalizeValue getMessage(Map expressions) { if (myKind.myAlwaysNullMessage == null || myKind.myNormalMessage == null) { throw new IllegalStateException("This problem kind has no message associated: " + myKind); } PsiExpression expression = PsiUtil.skipParenthesizedExprDown(getDereferencedExpression()); if (expression != null) { if (ExpressionUtils.isNullLiteral(expression) || expressions.get(expression) == DataFlowInspectionBase.ConstantResult.NULL) { - return myKind.myAlwaysNullMessage.get(); + return myKind.myAlwaysNullMessage; } } - return myKind.myNormalMessage.get(); + return myKind.myNormalMessage; } @Nonnull @@ -600,8 +600,8 @@ public boolean equals(Object o) { return false; } NullabilityProblem problem = (NullabilityProblem)o; - return myKind.equals(problem.myKind) && myAnchor.equals(problem.myAnchor) && - Objects.equals(myDereferencedExpression, problem.myDereferencedExpression); + return myKind.equals(problem.myKind) && myAnchor.equals(problem.myAnchor) + && Objects.equals(myDereferencedExpression, problem.myDereferencedExpression); } @Override diff --git a/java-analysis-impl/src/main/java/com/siyeh/ig/InspectionGadgetsFix.java b/java-analysis-impl/src/main/java/com/siyeh/ig/InspectionGadgetsFix.java index 085db37b8..e8b21ac22 100644 --- a/java-analysis-impl/src/main/java/com/siyeh/ig/InspectionGadgetsFix.java +++ b/java-analysis-impl/src/main/java/com/siyeh/ig/InspectionGadgetsFix.java @@ -15,239 +15,210 @@ */ package com.siyeh.ig; -import jakarta.annotation.Nonnull; - -import org.jetbrains.annotations.NonNls; - -import jakarta.annotation.Nullable; +import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; +import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiFile; +import consulo.language.util.IncorrectOperationException; import consulo.logging.Logger; import consulo.project.Project; import consulo.virtualFileSystem.ReadonlyStatusHandler; import consulo.virtualFileSystem.VirtualFile; -import com.intellij.java.language.psi.JavaPsiFacade; -import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiElementFactory; -import com.intellij.java.language.psi.PsiExpression; -import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiMember; -import com.intellij.java.language.psi.PsiReferenceExpression; -import com.intellij.java.language.psi.PsiStatement; -import consulo.language.codeStyle.CodeStyleManager; -import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; -import consulo.language.util.IncorrectOperationException; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; public abstract class InspectionGadgetsFix implements LocalQuickFix { + public static final InspectionGadgetsFix[] EMPTY_ARRAY = {}; - public static final InspectionGadgetsFix[] EMPTY_ARRAY = {}; - private static final Logger LOG = - Logger.getInstance(InspectionGadgetsFix.class); - - private boolean myOnTheFly = false; + private boolean myOnTheFly = false; - @Override - public final void applyFix(@Nonnull Project project, - @Nonnull ProblemDescriptor descriptor) { - final PsiElement problemElement = descriptor.getPsiElement(); - if (problemElement == null || !problemElement.isValid()) { - return; + @Override + @RequiredWriteAction + public final void applyFix(@Nonnull Project project, @Nonnull ProblemDescriptor descriptor) { + PsiElement problemElement = descriptor.getPsiElement(); + if (problemElement == null || !problemElement.isValid()) { + return; + } + if (isQuickFixOnReadOnlyFile(problemElement)) { + return; + } + try { + doFix(project, descriptor); + } + catch (IncorrectOperationException e) { + Class aClass = getClass(); + String className = aClass.getName(); + Logger logger = Logger.getInstance(className); + logger.error(e); + } } - if (isQuickFixOnReadOnlyFile(problemElement)) { - return; + + @RequiredWriteAction + protected abstract void doFix(Project project, ProblemDescriptor descriptor) + throws IncorrectOperationException; + + @RequiredWriteAction + protected static void deleteElement(@Nonnull PsiElement element) + throws IncorrectOperationException { + element.delete(); } - try { - doFix(project, descriptor); + + @RequiredWriteAction + protected static void replaceExpression(@Nonnull PsiExpression expression, @Nonnull String newExpressionText) + throws IncorrectOperationException { + Project project = expression.getProject(); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + PsiElementFactory factory = psiFacade.getElementFactory(); + PsiExpression newExpression = factory.createExpressionFromText(newExpressionText, expression); + PsiElement replacementExpression = expression.replace(newExpression); + CodeStyleManager styleManager = CodeStyleManager.getInstance(project); + styleManager.reformat(replacementExpression); } - catch (IncorrectOperationException e) { - final Class aClass = getClass(); - final String className = aClass.getName(); - final Logger logger = Logger.getInstance(className); - logger.error(e); + + @RequiredWriteAction + protected static void replaceExpressionWithReferenceTo(@Nonnull PsiExpression expression, @Nonnull PsiMember target) + throws IncorrectOperationException { + Project project = expression.getProject(); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + PsiElementFactory factory = psiFacade.getElementFactory(); + PsiReferenceExpression newExpression = (PsiReferenceExpression) factory.createExpressionFromText("xxx", expression); + PsiReferenceExpression replacementExpression = (PsiReferenceExpression) expression.replace(newExpression); + PsiElement element = replacementExpression.bindToElement(target); + JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project); + styleManager.shortenClassReferences(element); } - } - - protected abstract void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException; - - protected static void deleteElement(@Nonnull PsiElement element) - throws IncorrectOperationException { - element.delete(); - } - - protected static void replaceExpression( - @Nonnull PsiExpression expression, - @Nonnull @NonNls String newExpressionText) - throws IncorrectOperationException { - final Project project = expression.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiExpression newExpression = - factory.createExpressionFromText(newExpressionText, expression); - final PsiElement replacementExpression = - expression.replace(newExpression); - final CodeStyleManager styleManager = - CodeStyleManager.getInstance(project); - styleManager.reformat(replacementExpression); - } - - protected static void replaceExpressionWithReferenceTo( - @Nonnull PsiExpression expression, - @Nonnull PsiMember target) - throws IncorrectOperationException { - final Project project = expression.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiReferenceExpression newExpression = (PsiReferenceExpression) - factory.createExpressionFromText("xxx", expression); - final PsiReferenceExpression replacementExpression = - (PsiReferenceExpression)expression.replace(newExpression); - final PsiElement element = replacementExpression.bindToElement(target); - final JavaCodeStyleManager styleManager = - JavaCodeStyleManager.getInstance(project); - styleManager.shortenClassReferences(element); - } - - protected static void replaceExpressionAndShorten( - @Nonnull PsiExpression expression, - @Nonnull @NonNls String newExpressionText) - throws IncorrectOperationException { - final Project project = expression.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiExpression newExpression = - factory.createExpressionFromText(newExpressionText, expression); - final PsiElement replacementExp = expression.replace(newExpression); - final JavaCodeStyleManager javaCodeStyleManager = - JavaCodeStyleManager.getInstance(project); - javaCodeStyleManager.shortenClassReferences(replacementExp); - final CodeStyleManager styleManager = - CodeStyleManager.getInstance(project); - styleManager.reformat(replacementExp); - } - - protected static void replaceStatement( - @Nonnull PsiStatement statement, - @Nonnull @NonNls String newStatementText) - throws IncorrectOperationException { - final Project project = statement.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiStatement newStatement = - factory.createStatementFromText(newStatementText, statement); - final PsiElement replacementExp = statement.replace(newStatement); - final CodeStyleManager styleManager = - CodeStyleManager.getInstance(project); - styleManager.reformat(replacementExp); - } - - protected static void replaceStatementAndShortenClassNames( - @Nonnull PsiStatement statement, - @Nonnull @NonNls String newStatementText) - throws IncorrectOperationException { - final Project project = statement.getProject(); - final CodeStyleManager styleManager = - CodeStyleManager.getInstance(project); - final JavaCodeStyleManager javaStyleManager = - JavaCodeStyleManager.getInstance(project); - /* if (JspPsiUtil.isInJspFile(statement)) { - final PsiDocumentManager documentManager = - PsiDocumentManager.getInstance(project); - final JspFile file = JspPsiUtil.getJspFile(statement); - final Document document = documentManager.getDocument(file); - if (document == null) { - return; - } - documentManager.doPostponedOperationsAndUnblockDocument(document); - final TextRange textRange = statement.getTextRange(); - document.replaceString(textRange.getStartOffset(), - textRange.getEndOffset(), newStatementText); - documentManager.commitDocument(document); - final JspxFileViewProvider viewProvider = file.getViewProvider(); - PsiElement elementAt = - viewProvider.findElementAt(textRange.getStartOffset(), - StdLanguages.JAVA); - if (elementAt == null) { - return; - } - final int endOffset = textRange.getStartOffset() + - newStatementText.length(); - while (elementAt.getTextRange().getEndOffset() < endOffset || - !(elementAt instanceof PsiStatement)) { - elementAt = elementAt.getParent(); - if (elementAt == null) { - LOG.error("Cannot decode statement"); - return; - } - } - final PsiStatement newStatement = (PsiStatement)elementAt; - javaStyleManager.shortenClassReferences(newStatement); - final TextRange newTextRange = newStatement.getTextRange(); - final Language baseLanguage = viewProvider.getBaseLanguage(); - final PsiFile element = viewProvider.getPsi(baseLanguage); - if (element != null) { - styleManager.reformatRange(element, - newTextRange.getStartOffset(), - newTextRange.getEndOffset()); - } + + @RequiredWriteAction + protected static void replaceExpressionAndShorten(@Nonnull PsiExpression expression, @Nonnull String newExpressionText) + throws IncorrectOperationException { + Project project = expression.getProject(); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + PsiElementFactory factory = psiFacade.getElementFactory(); + PsiExpression newExpression = factory.createExpressionFromText(newExpressionText, expression); + PsiElement replacementExp = expression.replace(newExpression); + JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); + javaCodeStyleManager.shortenClassReferences(replacementExp); + CodeStyleManager styleManager = CodeStyleManager.getInstance(project); + styleManager.reformat(replacementExp); } - else */{ - final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = facade.getElementFactory(); - PsiStatement newStatement = factory.createStatementFromText( - newStatementText, statement); - newStatement = (PsiStatement)statement.replace(newStatement); - javaStyleManager.shortenClassReferences(newStatement); - styleManager.reformat(newStatement); + + @RequiredWriteAction + protected static void replaceStatement(@Nonnull PsiStatement statement, @Nonnull String newStatementText) + throws IncorrectOperationException { + Project project = statement.getProject(); + JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + PsiElementFactory factory = psiFacade.getElementFactory(); + PsiStatement newStatement = factory.createStatementFromText(newStatementText, statement); + PsiElement replacementExp = statement.replace(newStatement); + CodeStyleManager styleManager = CodeStyleManager.getInstance(project); + styleManager.reformat(replacementExp); } - } - protected boolean isQuickFixOnReadOnlyFile(PsiElement problemElement) { - final PsiFile containingPsiFile = problemElement.getContainingFile(); - if (containingPsiFile == null) { - return false; + @RequiredWriteAction + protected static void replaceStatementAndShortenClassNames(@Nonnull PsiStatement statement, @Nonnull String newStatementText) + throws IncorrectOperationException { + Project project = statement.getProject(); + CodeStyleManager styleManager = CodeStyleManager.getInstance(project); + JavaCodeStyleManager javaStyleManager = JavaCodeStyleManager.getInstance(project); + /* + if (JspPsiUtil.isInJspFile(statement)) { + PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project); + JspFile file = JspPsiUtil.getJspFile(statement); + Document document = documentManager.getDocument(file); + if (document == null) { + return; + } + documentManager.doPostponedOperationsAndUnblockDocument(document); + TextRange textRange = statement.getTextRange(); + document.replaceString(textRange.getStartOffset(), textRange.getEndOffset(), newStatementText); + documentManager.commitDocument(document); + JspxFileViewProvider viewProvider = file.getViewProvider(); + PsiElement elementAt = viewProvider.findElementAt(textRange.getStartOffset(), StdLanguages.JAVA); + if (elementAt == null) { + return; + } + int endOffset = textRange.getStartOffset() + newStatementText.length(); + while (elementAt.getTextRange().getEndOffset() < endOffset || !(elementAt instanceof PsiStatement)) { + elementAt = elementAt.getParent(); + if (elementAt == null) { + LOG.error("Cannot decode statement"); + return; + } + } + PsiStatement newStatement = (PsiStatement)elementAt; + javaStyleManager.shortenClassReferences(newStatement); + TextRange newTextRange = newStatement.getTextRange(); + Language baseLanguage = viewProvider.getBaseLanguage(); + PsiFile element = viewProvider.getPsi(baseLanguage); + if (element != null) { + styleManager.reformatRange(element, newTextRange.getStartOffset(), newTextRange.getEndOffset()); + } + } + else */ + { + JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + PsiElementFactory factory = facade.getElementFactory(); + PsiStatement newStatement = factory.createStatementFromText(newStatementText, statement); + newStatement = (PsiStatement) statement.replace(newStatement); + javaStyleManager.shortenClassReferences(newStatement); + styleManager.reformat(newStatement); + } } - final VirtualFile virtualFile = containingPsiFile.getVirtualFile(); - final Project project = problemElement.getProject(); - final ReadonlyStatusHandler handler = - ReadonlyStatusHandler.getInstance(project); - final ReadonlyStatusHandler.OperationStatus status = - handler.ensureFilesWritable(virtualFile); - return status.hasReadonlyFiles(); - } - - protected static String getElementText(@Nonnull PsiElement element, - @Nullable PsiElement elementToReplace, - @Nullable String replacement) { - final StringBuilder out = new StringBuilder(); - getElementText(element, elementToReplace, replacement, out); - return out.toString(); - } - - private static void getElementText( - @Nonnull PsiElement element, - @Nullable PsiElement elementToReplace, - @Nullable String replacement, - @Nonnull StringBuilder out) { - if (element.equals(elementToReplace)) { - out.append(replacement); - return; + + protected boolean isQuickFixOnReadOnlyFile(PsiElement problemElement) { + PsiFile containingPsiFile = problemElement.getContainingFile(); + if (containingPsiFile == null) { + return false; + } + VirtualFile virtualFile = containingPsiFile.getVirtualFile(); + Project project = problemElement.getProject(); + ReadonlyStatusHandler handler = ReadonlyStatusHandler.getInstance(project); + ReadonlyStatusHandler.OperationStatus status = handler.ensureFilesWritable(virtualFile); + return status.hasReadonlyFiles(); } - final PsiElement[] children = element.getChildren(); - if (children.length == 0) { - out.append(element.getText()); - return; + + @RequiredReadAction + protected static String getElementText( + @Nonnull PsiElement element, + @Nullable PsiElement elementToReplace, + @Nullable String replacement + ) { + StringBuilder out = new StringBuilder(); + getElementText(element, elementToReplace, replacement, out); + return out.toString(); } - for (PsiElement child : children) { - getElementText(child, elementToReplace, replacement, out); + + @RequiredReadAction + private static void getElementText( + @Nonnull PsiElement element, + @Nullable PsiElement elementToReplace, + @Nullable String replacement, + @Nonnull StringBuilder out + ) { + if (element.equals(elementToReplace)) { + out.append(replacement); + return; + } + PsiElement[] children = element.getChildren(); + if (children.length == 0) { + out.append(element.getText()); + return; + } + for (PsiElement child : children) { + getElementText(child, elementToReplace, replacement, out); + } } - } - public final void setOnTheFly(boolean onTheFly) { - myOnTheFly = onTheFly; - } + public final void setOnTheFly(boolean onTheFly) { + myOnTheFly = onTheFly; + } - public final boolean isOnTheFly() { - return myOnTheFly; - } + public final boolean isOnTheFly() { + return myOnTheFly; + } } \ No newline at end of file diff --git a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml index 122259386..2135c61d0 100644 --- a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml +++ b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml @@ -474,6 +474,18 @@ inspection.data.flow.simplify.to.assignment.quickfix.name: text: Simplify to normal assignment inspection.data.flow.true.asserts.option: text: Don't report assertions with condition statically proven to be always true +inspection.data.flow.ignore.assert.statements: + text: Ignore assert statements +inspection.data.flow.treat.non.annotated.members.and.parameters.as.nullable: + text: Treat non-annotated members and parameters as @Nullable +inspection.data.flow.report.constant.reference.values: + text: Warn when reading a value guaranteed to be constant +inspection.data.flow.report.not.null.required.parameter.with.null.literal.argument.usages: + text: Report non-null required parameter with null-literal argument usages +inspection.data.flow.report.nullable.methods.that.always.return.a.non.null.value: + text: Report nullable methods that always return a non-null value +inspection.data.flow.report.problems.that.happen.only.on.some.code.paths: + text: Report problems that happen only on some code paths inspection.data.flow.use.computeifpresent.quickfix: text: Replace 'compute' with 'computeIfPresent' inspection.dead.code.comment: diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiPolyadicExpression.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiPolyadicExpression.java index 58e7b0bbe..e3862c6be 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiPolyadicExpression.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiPolyadicExpression.java @@ -21,15 +21,15 @@ import jakarta.annotation.Nullable; /** - * User: cdr + * @author cdr */ public interface PsiPolyadicExpression extends PsiExpression { - @Nonnull - PsiExpression[] getOperands(); + @Nonnull + PsiExpression[] getOperands(); - @Nonnull - IElementType getOperationTokenType(); + @Nonnull + IElementType getOperationTokenType(); - @Nullable - PsiJavaToken getTokenBeforeOperand(@Nonnull PsiExpression operand); + @Nullable + PsiJavaToken getTokenBeforeOperand(@Nonnull PsiExpression operand); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspection.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspection.java index 86e822d56..3799d5899 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspection.java @@ -68,7 +68,11 @@ public InspectionToolState createStatePro } @Override - protected LocalQuickFix[] createConditionalAssignmentFixes(boolean evaluatesToTrue, PsiAssignmentExpression assignment, final boolean onTheFly) { + protected LocalQuickFix[] createConditionalAssignmentFixes( + boolean evaluatesToTrue, + PsiAssignmentExpression assignment, + boolean onTheFly + ) { IElementType op = assignment.getOperationTokenType(); boolean toRemove = op == JavaTokenType.ANDEQ && !evaluatesToTrue || op == JavaTokenType.OREQ && evaluatesToTrue; if (toRemove && !onTheFly) { @@ -94,13 +98,18 @@ protected LocalQuickFix createReplaceWithTrivialLambdaFix(Object value) { } @Override + @RequiredReadAction protected LocalQuickFix createMutabilityViolationFix(PsiElement violation, boolean onTheFly) { return WrapWithMutableCollectionFix.createFix(violation, onTheFly); } @Nullable @Override - protected LocalQuickFix createExplainFix(PsiExpression anchor, TrackingRunner.DfaProblemType problemType, DataFlowInspectionStateBase state) { + protected LocalQuickFix createExplainFix( + PsiExpression anchor, + TrackingRunner.DfaProblemType problemType, + DataFlowInspectionStateBase state + ) { return new FindDfaProblemCauseFix(state.TREAT_UNKNOWN_MEMBERS_AS_NULLABLE, state.IGNORE_ASSERT_STATEMENTS, anchor, problemType); } @@ -116,19 +125,19 @@ protected LocalQuickFix createIntroduceVariableFix() { } @Override + @RequiredReadAction protected LocalQuickFixOnPsiElement createSimplifyBooleanFix(PsiElement element, boolean value) { - if (!(element instanceof PsiExpression)) { + if (!(element instanceof PsiExpression expression)) { return null; } if (PsiTreeUtil.findChildOfType(element, PsiAssignmentExpression.class) != null) { return null; } - final PsiExpression expression = (PsiExpression) element; while (element.getParent() instanceof PsiExpression) { element = element.getParent(); } - final SimplifyBooleanExpressionFix fix = new SimplifyBooleanExpressionFix(expression, value); + SimplifyBooleanExpressionFix fix = new SimplifyBooleanExpressionFix(expression, value); // simplify intention already active if (!fix.isAvailable() || SimplifyBooleanExpressionFix.canBeSimplified((PsiExpression) element)) { return null; @@ -138,7 +147,7 @@ protected LocalQuickFixOnPsiElement createSimplifyBooleanFix(PsiElement element, @RequiredReadAction private static boolean isVolatileFieldReference(PsiExpression qualifier) { - PsiElement target = qualifier instanceof PsiReferenceExpression referenceExpression ? referenceExpression.resolve() : null; + PsiElement target = qualifier instanceof PsiReferenceExpression ref ? ref.resolve() : null; return target instanceof PsiField field && field.hasModifierProperty(PsiModifier.VOLATILE); } @@ -155,18 +164,22 @@ protected List createMethodReferenceNPEFixes(PsiMethodReferenceEx @Override protected LocalQuickFix createRemoveAssignmentFix(PsiAssignmentExpression assignment) { - if (assignment == null || assignment.getRExpression() == null || !(assignment.getParent() instanceof PsiExpressionStatement)) { - return null; + if (assignment != null && assignment.getRExpression() != null + && assignment.getParent() instanceof PsiExpressionStatement exprStmt) { + return new DeleteSideEffectsAwareFix(exprStmt, assignment.getRExpression(), true); } - return new DeleteSideEffectsAwareFix((PsiStatement) assignment.getParent(), assignment.getRExpression(), true); + return null; } - @Override @Nonnull - protected List createCastFixes(PsiTypeCastExpression castExpression, - PsiType realType, - boolean onTheFly, - boolean alwaysFails) { + @Override + @RequiredReadAction + protected List createCastFixes( + PsiTypeCastExpression castExpression, + PsiType realType, + boolean onTheFly, + boolean alwaysFails + ) { List fixes = new ArrayList<>(); PsiExpression operand = castExpression.getOperand(); PsiTypeElement typeElement = castExpression.getCastType(); @@ -198,12 +211,18 @@ protected List createCastFixes(PsiTypeCastExpression castExpressi return fixes; } - @Override @Nonnull - protected List createNPEFixes(PsiExpression qualifier, PsiExpression expression, boolean onTheFly, DataFlowInspectionStateBase state) { + @Override + @RequiredReadAction + protected List createNPEFixes( + PsiExpression qualifier, + PsiExpression expression, + boolean onTheFly, + DataFlowInspectionStateBase state + ) { qualifier = PsiUtil.deparenthesizeExpression(qualifier); - final List fixes = new SmartList<>(); + List fixes = new SmartList<>(); if (qualifier == null || expression == null) { return fixes; } @@ -216,8 +235,8 @@ protected List createNPEFixes(PsiExpression qualifier, PsiExpress } else if (!ExpressionUtils.isNullLiteral(qualifier) && !SideEffectChecker.mayHaveSideEffects(qualifier)) { String suffix = " != null"; - if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4) && - RefactoringUtil.getParentStatement(expression, false) != null) { + if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4) + && RefactoringUtil.getParentStatement(expression, false) != null) { String replacement = ParenthesesUtils.getText(qualifier, ParenthesesUtils.EQUALITY_PRECEDENCE) + suffix; fixes.add(new AddAssertStatementFix(replacement)); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspectionState.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspectionState.java index 4fca93afc..db0308561 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspectionState.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/dataFlow/DataFlowInspectionState.java @@ -7,68 +7,79 @@ import consulo.configurable.UnnamedConfigurable; import consulo.java.analysis.impl.localize.JavaInspectionsLocalize; import consulo.language.editor.inspection.InspectionToolState; -import consulo.localize.LocalizeValue; import consulo.util.xml.serializer.XmlSerializerUtil; import jakarta.annotation.Nullable; /** * @author VISTALL - * @since 25/03/2023 + * @since 2023-03-25 */ -public class DataFlowInspectionState extends DataFlowInspectionStateBase implements InspectionToolState -{ - @Nullable - @Override - public UnnamedConfigurable createConfigurable() - { - ConfigurableBuilder builder = ConfigurableBuilder.newBuilder(); - builder.checkBox(JavaInspectionsLocalize.inspectionDataFlowNullableQuickfixOption(), - () -> SUGGEST_NULLABLE_ANNOTATIONS, - b -> SUGGEST_NULLABLE_ANNOTATIONS = b); +public class DataFlowInspectionState extends DataFlowInspectionStateBase implements InspectionToolState { + @Nullable + @Override + public UnnamedConfigurable createConfigurable() { + ConfigurableBuilder builder = ConfigurableBuilder.newBuilder(); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowNullableQuickfixOption(), + () -> SUGGEST_NULLABLE_ANNOTATIONS, + b -> SUGGEST_NULLABLE_ANNOTATIONS = b + ); - builder.checkBox(JavaInspectionsLocalize.inspectionDataFlowTrueAssertsOption(), - () -> DONT_REPORT_TRUE_ASSERT_STATEMENTS, - b -> DONT_REPORT_TRUE_ASSERT_STATEMENTS = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowTrueAssertsOption(), + () -> DONT_REPORT_TRUE_ASSERT_STATEMENTS, + b -> DONT_REPORT_TRUE_ASSERT_STATEMENTS = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Ignore assert statements"), - () -> IGNORE_ASSERT_STATEMENTS, - b -> IGNORE_ASSERT_STATEMENTS = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowIgnoreAssertStatements(), + () -> IGNORE_ASSERT_STATEMENTS, + b -> IGNORE_ASSERT_STATEMENTS = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Warn when reading a value guaranteed to be constant"), - () -> REPORT_CONSTANT_REFERENCE_VALUES, - b -> REPORT_CONSTANT_REFERENCE_VALUES = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowReportConstantReferenceValues(), + () -> REPORT_CONSTANT_REFERENCE_VALUES, + b -> REPORT_CONSTANT_REFERENCE_VALUES = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Treat non-annotated members and parameters as @Nullable"), - () -> TREAT_UNKNOWN_MEMBERS_AS_NULLABLE, - b -> TREAT_UNKNOWN_MEMBERS_AS_NULLABLE = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowTreatNonAnnotatedMembersAndParametersAsNullable(), + () -> TREAT_UNKNOWN_MEMBERS_AS_NULLABLE, + b -> TREAT_UNKNOWN_MEMBERS_AS_NULLABLE = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Report not-null required parameter with null-literal argument usages"), - () -> REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER, - b -> REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowReportNotNullRequiredParameterWithNullLiteralArgumentUsages(), + () -> REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER, + b -> REPORT_NULLS_PASSED_TO_NOT_NULL_PARAMETER = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Report nullable methods that always return a non-null value"), - () -> REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL, - b -> REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowReportNullableMethodsThatAlwaysReturnANonNullValue(), + () -> REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL, + b -> REPORT_NULLABLE_METHODS_RETURNING_NOT_NULL = b + ); - builder.checkBox(LocalizeValue.localizeTODO("Report problems that happen only on some code paths"), - () -> REPORT_UNSOUND_WARNINGS, - b -> REPORT_UNSOUND_WARNINGS = b); + builder.checkBox( + JavaInspectionsLocalize.inspectionDataFlowReportProblemsThatHappenOnlyOnSomeCodePaths(), + () -> REPORT_UNSOUND_WARNINGS, + b -> REPORT_UNSOUND_WARNINGS = b + ); - builder.component(() -> NullableNotNullDialog.createConfigureAnnotationsButton()); - return builder.buildUnnamed(); - } + builder.component(NullableNotNullDialog::createConfigureAnnotationsButton); + return builder.buildUnnamed(); + } - @Nullable - @Override - public DataFlowInspectionState getState() - { - return this; - } + @Nullable + @Override + public DataFlowInspectionState getState() { + return this; + } - @Override - public void loadState(DataFlowInspectionState state) - { - XmlSerializerUtil.copyBean(state, this); - } + @Override + public void loadState(DataFlowInspectionState state) { + XmlSerializerUtil.copyBean(state, this); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/DelegatingFix.java b/plugin/src/main/java/com/intellij/java/impl/ig/DelegatingFix.java index 36c64cb7c..4e5222375 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/DelegatingFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/DelegatingFix.java @@ -15,6 +15,7 @@ */ package com.intellij.java.impl.ig; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.localize.LocalizeValue; @@ -26,28 +27,29 @@ import jakarta.annotation.Nonnull; public class DelegatingFix extends InspectionGadgetsFix { - - private final LocalQuickFix delegate; - - public DelegatingFix(LocalQuickFix delegate) { - this.delegate = delegate; - } - - @Nonnull - public LocalizeValue getName() { - return delegate.getName(); - } - - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - delegate.applyFix(project, descriptor); - } - - /** - * Delegating fix should check for read-only status separately - */ - @Override - protected boolean isQuickFixOnReadOnlyFile(PsiElement problemElement) { - return false; - } + private final LocalQuickFix delegate; + + public DelegatingFix(LocalQuickFix delegate) { + this.delegate = delegate; + } + + @Nonnull + @Override + public LocalizeValue getName() { + return delegate.getName(); + } + + @Override + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + delegate.applyFix(project, descriptor); + } + + /** + * Delegating fix should check for read-only status separately + */ + @Override + protected boolean isQuickFixOnReadOnlyFile(PsiElement problemElement) { + return false; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/DeclareCollectionAsInterfaceInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/DeclareCollectionAsInterfaceInspection.java index a98c624da..1bf7c61e7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/DeclareCollectionAsInterfaceInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/DeclareCollectionAsInterfaceInspection.java @@ -25,6 +25,7 @@ import com.siyeh.ig.psiutils.CollectionUtils; import com.siyeh.ig.psiutils.DeclarationSearchUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; import consulo.language.editor.inspection.ProblemDescriptor; @@ -42,7 +43,6 @@ @ExtensionImpl public class DeclareCollectionAsInterfaceInspection extends BaseInspection { - /** * @noinspection PublicField */ @@ -52,29 +52,29 @@ public class DeclareCollectionAsInterfaceInspection extends BaseInspection { */ public boolean ignorePrivateMethodsAndFields = false; - @Override @Nonnull + @Override public String getID() { return "CollectionDeclaredAsConcreteClass"; } - @Override @Nonnull + @Override public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.collectionDeclaredByClassDisplayName(); } - @Override @Nonnull + @Override public String buildErrorString(Object... infos) { - final String type = (String) infos[0]; + String type = (String) infos[0]; return InspectionGadgetsLocalize.collectionDeclaredByClassProblemDescriptor(type).get(); } @Override @Nullable public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); optionsPanel.addCheckbox( InspectionGadgetsLocalize.collectionDeclaredByClassIgnoreLocalsOption().get(), "ignoreLocalVariables" @@ -106,24 +106,24 @@ public LocalizeValue getName() { } @Override + @RequiredWriteAction protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiJavaCodeReferenceElement)) { + PsiElement element = descriptor.getPsiElement(); + PsiElement parent = element.getParent(); + if (!(parent instanceof PsiJavaCodeReferenceElement referenceElement)) { return; } - final StringBuilder newElementText = new StringBuilder(typeString); - final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) parent; - final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); + StringBuilder newElementText = new StringBuilder(typeString); + PsiReferenceParameterList parameterList = referenceElement.getParameterList(); if (parameterList != null) { newElementText.append(parameterList.getText()); } - final PsiElement grandParent = parent.getParent(); + PsiElement grandParent = parent.getParent(); if (!(grandParent instanceof PsiTypeElement)) { return; } - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - final PsiTypeElement newTypeElement = factory.createTypeElementFromText(newElementText.toString(), element); + PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + PsiTypeElement newTypeElement = factory.createTypeElementFromText(newElementText.toString(), element); JavaCodeStyleManager.getInstance(project).shortenClassReferences(grandParent.replace(newTypeElement)); } } @@ -150,22 +150,17 @@ public void visitVariable(@Nonnull PsiVariable variable) { } } } - if (variable instanceof PsiParameter) { - final PsiParameter parameter = (PsiParameter) variable; - final PsiElement scope = parameter.getDeclarationScope(); - if (scope instanceof PsiMethod) { - if (ignorePrivateMethodsAndFields) { - final PsiMethod method = (PsiMethod) scope; - if (method.hasModifierProperty(PsiModifier.PRIVATE)) { - return; - } + if (variable instanceof PsiParameter parameter) { + if (parameter.getDeclarationScope() instanceof PsiMethod method) { + if (ignorePrivateMethodsAndFields && method.isPrivate()) { + return; } } else if (ignoreLocalVariables) { return; } } - final PsiType type = variable.getType(); + PsiType type = variable.getType(); if (!CollectionUtils.isConcreteCollectionClass(type) || LibraryUtil.isOverrideOfLibraryMethodParameter(variable)) { return; } @@ -176,13 +171,13 @@ else if (ignoreLocalVariables) { @Override public void visitMethod(@Nonnull PsiMethod method) { super.visitMethod(method); - if (ignorePrivateMethodsAndFields && method.hasModifierProperty(PsiModifier.PRIVATE)) { + if (ignorePrivateMethodsAndFields && method.isPrivate()) { return; } if (isOnTheFly() && DeclarationSearchUtils.isTooExpensiveToSearch(method, false)) { return; } - final PsiType type = method.getReturnType(); + PsiType type = method.getReturnType(); if (!CollectionUtils.isConcreteCollectionClass(type) || LibraryUtil.isOverrideOfLibraryMethod(method)) { return; } @@ -194,33 +189,33 @@ private void checkToWeaken(PsiType type, PsiTypeElement typeElement, PsiElement if (typeElement == null) { return; } - final PsiJavaCodeReferenceElement reference = typeElement.getInnermostComponentReferenceElement(); + PsiJavaCodeReferenceElement reference = typeElement.getInnermostComponentReferenceElement(); if (reference == null) { return; } - final PsiElement nameElement = reference.getReferenceNameElement(); + PsiElement nameElement = reference.getReferenceNameElement(); if (nameElement == null) { return; } - final Collection weaklings = WeakestTypeFinder.calculateWeakestClassesNecessary(variable, false, true); + Collection weaklings = WeakestTypeFinder.calculateWeakestClassesNecessary(variable, false, true); if (weaklings.isEmpty()) { return; } - final PsiClassType javaLangObject = PsiType.getJavaLangObject(nameElement.getManager(), nameElement.getResolveScope()); - final List weaklingList = new ArrayList<>(weaklings); - final PsiClass objectClass = javaLangObject.resolve(); + PsiClassType javaLangObject = PsiType.getJavaLangObject(nameElement.getManager(), nameElement.getResolveScope()); + List weaklingList = new ArrayList<>(weaklings); + PsiClass objectClass = javaLangObject.resolve(); weaklingList.remove(objectClass); if (weaklingList.isEmpty()) { - final String typeText = type.getCanonicalText(); - final String interfaceText = CollectionUtils.getInterfaceForClass(typeText); + String typeText = type.getCanonicalText(); + String interfaceText = CollectionUtils.getInterfaceForClass(typeText); if (interfaceText == null) { return; } registerError(nameElement, interfaceText); } else { - final PsiClass weakling = weaklingList.get(0); - final String qualifiedName = weakling.getQualifiedName(); + PsiClass weakling = weaklingList.get(0); + String qualifiedName = weakling.getQualifiedName(); registerError(nameElement, qualifiedName); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/OverlyStrongTypeCastInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/OverlyStrongTypeCastInspection.java index 22d65c6fe..0fe3f079c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/OverlyStrongTypeCastInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/OverlyStrongTypeCastInspection.java @@ -23,6 +23,7 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.psiutils.ExpectedTypeUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; import consulo.language.editor.inspection.ProblemDescriptor; @@ -32,7 +33,6 @@ import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import javax.swing.*; @@ -50,8 +50,8 @@ public LocalizeValue getDisplayName() { @Override @Nonnull protected String buildErrorString(Object... infos) { - final PsiType expectedType = (PsiType) infos[0]; - final String typeText = expectedType.getPresentableText(); + PsiType expectedType = (PsiType) infos[0]; + String typeText = expectedType.getPresentableText(); return InspectionGadgetsLocalize.overlyStrongTypeCastProblemDescriptor(typeText).get(); } @@ -75,26 +75,22 @@ public LocalizeValue getName() { } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement castTypeElement = descriptor.getPsiElement(); - final PsiTypeCastExpression expression = - (PsiTypeCastExpression) castTypeElement.getParent(); + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiElement castTypeElement = descriptor.getPsiElement(); + PsiTypeCastExpression expression = (PsiTypeCastExpression) castTypeElement.getParent(); if (expression == null) { return; } - final PsiType expectedType = - ExpectedTypeUtils.findExpectedType(expression, true); + PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true); if (expectedType == null) { return; } - final PsiExpression operand = expression.getOperand(); + PsiExpression operand = expression.getOperand(); if (operand == null) { return; } - @NonNls final String newExpression = - '(' + expectedType.getCanonicalText() + ')' + - operand.getText(); + String newExpression = '(' + expectedType.getCanonicalText() + ')' + operand.getText(); replaceExpressionAndShorten(expression, newExpression); } } @@ -104,35 +100,30 @@ public BaseInspectionVisitor buildVisitor() { return new OverlyStrongTypeCastVisitor(); } - private class OverlyStrongTypeCastVisitor - extends BaseInspectionVisitor { - + private class OverlyStrongTypeCastVisitor extends BaseInspectionVisitor { @Override - public void visitTypeCastExpression( - @Nonnull PsiTypeCastExpression expression - ) { + public void visitTypeCastExpression(@Nonnull PsiTypeCastExpression expression) { super.visitTypeCastExpression(expression); - final PsiExpression operand = expression.getOperand(); + PsiExpression operand = expression.getOperand(); if (operand == null) { return; } - final PsiType operandType = operand.getType(); + PsiType operandType = operand.getType(); if (operandType == null) { return; } - final PsiType type = expression.getType(); + PsiType type = expression.getType(); if (type == null) { return; } - final PsiType expectedType = - ExpectedTypeUtils.findExpectedType(expression, true); + PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true); if (expectedType == null) { return; } if (expectedType.equals(type)) { return; } - final PsiClass resolved = PsiUtil.resolveClassInType(expectedType); + PsiClass resolved = PsiUtil.resolveClassInType(expectedType); if (resolved != null && !resolved.isPhysical()) { return; } @@ -143,45 +134,35 @@ public void visitTypeCastExpression( if (isTypeParameter(expectedType)) { return; } - if (expectedType instanceof PsiArrayType) { - final PsiArrayType arrayType = (PsiArrayType) expectedType; - final PsiType componentType = arrayType.getDeepComponentType(); + if (expectedType instanceof PsiArrayType arrayType) { + PsiType componentType = arrayType.getDeepComponentType(); if (isTypeParameter(componentType)) { return; } } - if (type instanceof PsiPrimitiveType || - expectedType instanceof PsiPrimitiveType) { + if (type instanceof PsiPrimitiveType || expectedType instanceof PsiPrimitiveType) { return; } if (PsiPrimitiveType.getUnboxedType(type) != null || PsiPrimitiveType.getUnboxedType(expectedType) != null) { return; } - if (expectedType instanceof PsiClassType) { - final PsiClassType expectedClassType = - (PsiClassType) expectedType; - final PsiClassType expectedRawType = - expectedClassType.rawType(); + if (expectedType instanceof PsiClassType expectedClassType) { + PsiClassType expectedRawType = expectedClassType.rawType(); if (type.equals(expectedRawType)) { return; } - if (type instanceof PsiClassType) { - final PsiClassType classType = (PsiClassType) type; - final PsiClassType rawType = classType.rawType(); - if (rawType.equals(expectedRawType)) { - return; - } + if (type instanceof PsiClassType classType && classType.rawType().equals(expectedRawType)) { + return; } if (type instanceof PsiArrayType) { return; } } - if (ignoreInMatchingInstanceof && - InstanceOfUtils.hasAgreeingInstanceof(expression)) { + if (ignoreInMatchingInstanceof && InstanceOfUtils.hasAgreeingInstanceof(expression)) { return; } - final PsiTypeElement castTypeElement = expression.getCastType(); + PsiTypeElement castTypeElement = expression.getCastType(); if (castTypeElement == null) { return; } @@ -189,15 +170,7 @@ public void visitTypeCastExpression( } private boolean isTypeParameter(PsiType type) { - if (!(type instanceof PsiClassType)) { - return false; - } - final PsiClassType classType = (PsiClassType) type; - final PsiClass aClass = classType.resolve(); - if (aClass == null) { - return false; - } - return aClass instanceof PsiTypeParameter; + return type instanceof PsiClassType classType && classType.resolve() instanceof PsiTypeParameter; } } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/TypeMayBeWeakenedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/TypeMayBeWeakenedInspection.java index b195af91c..586d05f9c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/TypeMayBeWeakenedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/TypeMayBeWeakenedInspection.java @@ -23,6 +23,7 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.psiutils.MethodUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.application.util.query.Query; import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; @@ -33,7 +34,6 @@ import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import javax.swing.*; import java.util.*; @@ -49,7 +49,7 @@ public class TypeMayBeWeakenedInspection extends BaseInspection { @SuppressWarnings({"PublicField"}) public boolean doNotWeakenToJavaLangObject = true; - @SuppressWarnings({"PublicField"}) + @SuppressWarnings({"PublicField", "SpellCheckingInspection"}) public boolean onlyWeakentoInterface = true; @Nonnull @@ -58,19 +58,19 @@ public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.typeMayBeWeakenedDisplayName(); } - @Override @Nonnull + @Override protected String buildErrorString(Object... infos) { - final Iterable weakerClasses = (Iterable) infos[1]; - @NonNls final StringBuilder builder = new StringBuilder(); - final Iterator iterator = weakerClasses.iterator(); + Iterable weakerClasses = (Iterable) infos[1]; + StringBuilder builder = new StringBuilder(); + Iterator iterator = weakerClasses.iterator(); if (iterator.hasNext()) { builder.append('\'').append(iterator.next().getQualifiedName()).append('\''); while (iterator.hasNext()) { builder.append(", '").append(iterator.next().getQualifiedName()).append('\''); } } - final Object info = infos[0]; + Object info = infos[0]; if (info instanceof PsiField) { return InspectionGadgetsLocalize.typeMayBeWeakenedFieldProblemDescriptor(builder.toString()).get(); } @@ -86,7 +86,7 @@ else if (info instanceof PsiMethod) { @Override @Nullable public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); optionsPanel.addCheckbox( InspectionGadgetsLocalize.typeMayBeWeakenedIgnoreOption().get(), "useRighthandTypeAsWeakestTypeInAssignments" @@ -106,13 +106,13 @@ public JComponent createOptionsPanel() { return optionsPanel; } - @Override @Nonnull + @Override protected InspectionGadgetsFix[] buildFixes(Object... infos) { - final Iterable weakerClasses = (Iterable) infos[1]; - final Collection fixes = new ArrayList(); + Iterable weakerClasses = (Iterable) infos[1]; + Collection fixes = new ArrayList<>(); for (PsiClass weakestClass : weakerClasses) { - final String qualifiedName = weakestClass.getQualifiedName(); + String qualifiedName = weakestClass.getQualifiedName(); if (qualifiedName == null) { continue; } @@ -135,16 +135,15 @@ public LocalizeValue getName() { } @Override + @RequiredWriteAction protected void doFix(Project project, ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - final PsiTypeElement typeElement; - if (parent instanceof PsiVariable) { - final PsiVariable variable = (PsiVariable) parent; + PsiElement element = descriptor.getPsiElement(); + PsiElement parent = element.getParent(); + PsiTypeElement typeElement; + if (parent instanceof PsiVariable variable) { typeElement = variable.getTypeElement(); } - else if (parent instanceof PsiMethod) { - final PsiMethod method = (PsiMethod) parent; + else if (parent instanceof PsiMethod method) { typeElement = method.getReturnTypeElement(); } else { @@ -153,39 +152,38 @@ else if (parent instanceof PsiMethod) { if (typeElement == null) { return; } - final PsiJavaCodeReferenceElement componentReferenceElement = typeElement.getInnermostComponentReferenceElement(); + PsiJavaCodeReferenceElement componentReferenceElement = typeElement.getInnermostComponentReferenceElement(); if (componentReferenceElement == null) { return; } - final PsiType oldType = typeElement.getType(); - if (!(oldType instanceof PsiClassType)) { + PsiType oldType = typeElement.getType(); + if (!(oldType instanceof PsiClassType classType)) { return; } - final PsiClassType classType = (PsiClassType) oldType; - final PsiType[] parameterTypes = classType.getParameters(); - final GlobalSearchScope scope = element.getResolveScope(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass aClass = facade.findClass(fqClassName, scope); + PsiType[] parameterTypes = classType.getParameters(); + GlobalSearchScope scope = element.getResolveScope(); + JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + PsiClass aClass = facade.findClass(fqClassName, scope); if (aClass == null) { return; } - final PsiTypeParameter[] typeParameters = aClass.getTypeParameters(); - final PsiElementFactory factory = facade.getElementFactory(); - final PsiClassType type; + PsiTypeParameter[] typeParameters = aClass.getTypeParameters(); + PsiElementFactory factory = facade.getElementFactory(); + PsiClassType type; if (typeParameters.length != 0 && typeParameters.length == parameterTypes.length) { - final Map typeParameterMap = new HashMap(); + Map typeParameterMap = new HashMap<>(); for (int i = 0; i < typeParameters.length; i++) { - final PsiTypeParameter typeParameter = typeParameters[i]; - final PsiType parameterType = parameterTypes[i]; + PsiTypeParameter typeParameter = typeParameters[i]; + PsiType parameterType = parameterTypes[i]; typeParameterMap.put(typeParameter, parameterType); } - final PsiSubstitutor substitutor = factory.createSubstitutor(typeParameterMap); + PsiSubstitutor substitutor = factory.createSubstitutor(typeParameterMap); type = factory.createType(aClass, substitutor); } else { type = factory.createTypeByFQClassName(fqClassName, scope); } - final PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType(type); + PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType(type); componentReferenceElement.replace(referenceElement); } } @@ -198,20 +196,17 @@ public BaseInspectionVisitor buildVisitor() { private class TypeMayBeWeakenedVisitor extends BaseInspectionVisitor { @Override - public void visitVariable(PsiVariable variable) { + public void visitVariable(@Nonnull PsiVariable variable) { super.visitVariable(variable); - if (variable instanceof PsiParameter) { - final PsiParameter parameter = (PsiParameter) variable; - final PsiElement declarationScope = parameter.getDeclarationScope(); + if (variable instanceof PsiParameter parameter) { + PsiElement declarationScope = parameter.getDeclarationScope(); if (declarationScope instanceof PsiCatchSection) { // do not weaken catch block parameters return; } - else if (declarationScope instanceof PsiMethod) { - final PsiMethod method = (PsiMethod) declarationScope; - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null || - containingClass.isInterface()) { + else if (declarationScope instanceof PsiMethod method) { + PsiClass containingClass = method.getContainingClass(); + if (containingClass == null || containingClass.isInterface()) { return; } if (MethodUtils.hasSuper(method)) { @@ -219,7 +214,7 @@ else if (declarationScope instanceof PsiMethod) { // super methods return; } - final Query overridingSearch = OverridingMethodsSearch.search(method); + Query overridingSearch = OverridingMethodsSearch.search(method); if (overridingSearch.findFirst() != null) { // do not try to weaken parameters of methods with // overriding methods. @@ -228,7 +223,7 @@ else if (declarationScope instanceof PsiMethod) { } } if (isOnTheFly() && variable instanceof PsiField) { - // checking variables with greater visibiltiy is too expensive + // checking variables with greater visibility is too expensive // for error checking in the editor if (!variable.hasModifierProperty(PsiModifier.PRIVATE)) { return; @@ -236,37 +231,34 @@ else if (declarationScope instanceof PsiMethod) { } if (useRighthandTypeAsWeakestTypeInAssignments) { if (variable instanceof PsiParameter) { - final PsiElement parent = variable.getParent(); - if (parent instanceof PsiForeachStatement) { - final PsiForeachStatement foreachStatement = (PsiForeachStatement) parent; - final PsiExpression iteratedValue = foreachStatement.getIteratedValue(); + if (variable.getParent() instanceof PsiForeachStatement foreachStatement) { + PsiExpression iteratedValue = foreachStatement.getIteratedValue(); if (!(iteratedValue instanceof PsiNewExpression) && !(iteratedValue instanceof PsiTypeCastExpression)) { return; } } } else { - final PsiExpression initializer = variable.getInitializer(); + PsiExpression initializer = variable.getInitializer(); if (!(initializer instanceof PsiNewExpression) && !(initializer instanceof PsiTypeCastExpression)) { return; } } } - final Collection weakestClasses = - WeakestTypeFinder.calculateWeakestClassesNecessary( - variable, - useRighthandTypeAsWeakestTypeInAssignments, - useParameterizedTypeForCollectionMethods - ); + Collection weakestClasses = WeakestTypeFinder.calculateWeakestClassesNecessary( + variable, + useRighthandTypeAsWeakestTypeInAssignments, + useParameterizedTypeForCollectionMethods + ); if (doNotWeakenToJavaLangObject) { - final Project project = variable.getProject(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass javaLangObjectClass = facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, variable.getResolveScope()); + Project project = variable.getProject(); + JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + PsiClass javaLangObjectClass = facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, variable.getResolveScope()); weakestClasses.remove(javaLangObjectClass); } if (onlyWeakentoInterface) { for (Iterator iterator = weakestClasses.iterator(); iterator.hasNext(); ) { - final PsiClass weakestClass = iterator.next(); + PsiClass weakestClass = iterator.next(); if (!weakestClass.isInterface()) { iterator.remove(); } @@ -279,9 +271,9 @@ else if (declarationScope instanceof PsiMethod) { } @Override - public void visitMethod(PsiMethod method) { + public void visitMethod(@Nonnull PsiMethod method) { super.visitMethod(method); - if (isOnTheFly() && !method.hasModifierProperty(PsiModifier.PRIVATE)) { + if (isOnTheFly() && !method.isPrivate()) { // checking methods with greater visibility is too expensive. // for error checking in the editor return; @@ -290,26 +282,25 @@ public void visitMethod(PsiMethod method) { // do not try to weaken methods with super methods return; } - final Query overridingSearch = OverridingMethodsSearch.search(method); + Query overridingSearch = OverridingMethodsSearch.search(method); if (overridingSearch.findFirst() != null) { // do not try to weaken methods with overriding methods. return; } - final Collection weakestClasses = - WeakestTypeFinder.calculateWeakestClassesNecessary( - method, - useRighthandTypeAsWeakestTypeInAssignments, - useParameterizedTypeForCollectionMethods - ); + Collection weakestClasses = WeakestTypeFinder.calculateWeakestClassesNecessary( + method, + useRighthandTypeAsWeakestTypeInAssignments, + useParameterizedTypeForCollectionMethods + ); if (doNotWeakenToJavaLangObject) { - final Project project = method.getProject(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass javaLangObjectClass = facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, method.getResolveScope()); + Project project = method.getProject(); + JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + PsiClass javaLangObjectClass = facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, method.getResolveScope()); weakestClasses.remove(javaLangObjectClass); } if (onlyWeakentoInterface) { for (Iterator iterator = weakestClasses.iterator(); iterator.hasNext(); ) { - final PsiClass weakestClass = iterator.next(); + PsiClass weakestClass = iterator.next(); if (!weakestClass.isInterface()) { iterator.remove(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentUsedAsConditionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentUsedAsConditionInspection.java index 39478fe77..1f673356e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentUsedAsConditionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentUsedAsConditionInspection.java @@ -21,6 +21,7 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; @@ -38,10 +39,12 @@ public LocalizeValue getDisplayName() { } @Nonnull + @Override public String buildErrorString(Object... infos) { return InspectionGadgetsLocalize.assignmentUsedAsConditionProblemDescriptor().get(); } + @Override public InspectionGadgetsFix buildFix(Object... infos) { return new AssignmentUsedAsConditionFix(); } @@ -53,90 +56,68 @@ public LocalizeValue getName() { return InspectionGadgetsLocalize.assignmentUsedAsConditionReplaceQuickfix(); } - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiAssignmentExpression expression = - (PsiAssignmentExpression) descriptor.getPsiElement(); - final PsiExpression leftExpression = expression.getLExpression(); - final PsiExpression rightExpression = expression.getRExpression(); + @Override + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiAssignmentExpression expression = (PsiAssignmentExpression) descriptor.getPsiElement(); + PsiExpression leftExpression = expression.getLExpression(); + PsiExpression rightExpression = expression.getRExpression(); assert rightExpression != null; - final String newExpression = - leftExpression.getText() + "==" + rightExpression.getText(); + String newExpression = leftExpression.getText() + "==" + rightExpression.getText(); replaceExpression(expression, newExpression); } } + @Override public BaseInspectionVisitor buildVisitor() { return new AssignmentUsedAsConditionVisitor(); } - private static class AssignmentUsedAsConditionVisitor - extends BaseInspectionVisitor { - + private static class AssignmentUsedAsConditionVisitor extends BaseInspectionVisitor { @Override - public void visitAssignmentExpression( - @Nonnull PsiAssignmentExpression expression - ) { + public void visitAssignmentExpression(@Nonnull PsiAssignmentExpression expression) { super.visitAssignmentExpression(expression); if (!WellFormednessUtils.isWellFormed(expression)) { return; } - final PsiElement parent = expression.getParent(); + PsiElement parent = expression.getParent(); if (parent == null) { return; } - if (parent instanceof PsiIfStatement) { - checkIfStatementCondition((PsiIfStatement) parent, expression); + if (parent instanceof PsiIfStatement ifStatement) { + checkIfStatementCondition(ifStatement, expression); } - if (parent instanceof PsiWhileStatement) { - checkWhileStatementCondition( - (PsiWhileStatement) parent, - expression - ); + else if (parent instanceof PsiWhileStatement whileStatement) { + checkWhileStatementCondition(whileStatement, expression); } - if (parent instanceof PsiForStatement) { - checkForStatementCondition((PsiForStatement) parent, expression); + else if (parent instanceof PsiForStatement forStatement) { + checkForStatementCondition(forStatement, expression); } - if (parent instanceof PsiDoWhileStatement) { - checkDoWhileStatementCondition( - (PsiDoWhileStatement) parent, - expression - ); + else if (parent instanceof PsiDoWhileStatement doWhileStatement) { + checkDoWhileStatementCondition(doWhileStatement, expression); } } - private void checkIfStatementCondition( - PsiIfStatement ifStatement, PsiAssignmentExpression expression - ) { - final PsiExpression condition = ifStatement.getCondition(); - if (expression.equals(condition)) { + private void checkIfStatementCondition(PsiIfStatement ifStatement, PsiAssignmentExpression expression) { + if (expression.equals(ifStatement.getCondition())) { registerError(expression); } } - private void checkDoWhileStatementCondition( - PsiDoWhileStatement doWhileStatement, PsiAssignmentExpression expression - ) { - final PsiExpression condition = doWhileStatement.getCondition(); - if (expression.equals(condition)) { + private void checkDoWhileStatementCondition(PsiDoWhileStatement doWhileStatement, PsiAssignmentExpression expression) { + if (expression.equals(doWhileStatement.getCondition())) { registerError(expression); } } - private void checkForStatementCondition( - PsiForStatement forStatement, PsiAssignmentExpression expression - ) { - final PsiExpression condition = forStatement.getCondition(); - if (expression.equals(condition)) { + private void checkForStatementCondition(PsiForStatement forStatement, PsiAssignmentExpression expression) { + if (expression.equals(forStatement.getCondition())) { registerError(expression); } } - private void checkWhileStatementCondition( - PsiWhileStatement whileStatement, PsiAssignmentExpression expression - ) { - final PsiExpression condition = whileStatement.getCondition(); - if (expression.equals(condition)) { + private void checkWhileStatementCondition(PsiWhileStatement whileStatement, PsiAssignmentExpression expression) { + if (expression.equals(whileStatement.getCondition())) { registerError(expression); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/IncrementDecrementUsedAsExpressionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/IncrementDecrementUsedAsExpressionInspection.java index b8ecfd8fe..fea51ed9e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/IncrementDecrementUsedAsExpressionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/IncrementDecrementUsedAsExpressionInspection.java @@ -21,6 +21,8 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.content.scope.SearchScope; import consulo.language.ast.IElementType; @@ -50,38 +52,34 @@ public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.incrementDecrementDisplayName(); } - @Override @Nonnull + @Override public String buildErrorString(Object... infos) { - final Object info = infos[0]; - if (info instanceof PsiPostfixExpression) { - final PsiPostfixExpression postfixExpression = - (PsiPostfixExpression) info; - final IElementType tokenType = - postfixExpression.getOperationTokenType(); + Object info = infos[0]; + if (info instanceof PsiPostfixExpression postfixExpression) { + IElementType tokenType = postfixExpression.getOperationTokenType(); return JavaTokenType.PLUSPLUS.equals(tokenType) ? InspectionGadgetsLocalize.valueOfPostIncrementProblemDescriptor().get() : InspectionGadgetsLocalize.valueOfPostDecrementProblemDescriptor().get(); } else { - final PsiPrefixExpression prefixExpression = (PsiPrefixExpression) info; - final IElementType tokenType = prefixExpression.getOperationTokenType(); + PsiPrefixExpression prefixExpression = (PsiPrefixExpression) info; + IElementType tokenType = prefixExpression.getOperationTokenType(); return JavaTokenType.PLUSPLUS.equals(tokenType) ? InspectionGadgetsLocalize.valueOfPreIncrementProblemDescriptor().get() : InspectionGadgetsLocalize.valueOfPreDecrementProblemDescriptor().get(); } } - @Override @Nullable + @Override + @RequiredReadAction protected InspectionGadgetsFix buildFix(Object... infos) { - final PsiExpression expression = (PsiExpression) infos[0]; + PsiExpression expression = (PsiExpression) infos[0]; return new IncrementDecrementUsedAsExpressionFix(expression.getText()); } - private static class IncrementDecrementUsedAsExpressionFix - extends InspectionGadgetsFix { - + private static class IncrementDecrementUsedAsExpressionFix extends InspectionGadgetsFix { private final String elementText; IncrementDecrementUsedAsExpressionFix(String elementText) { @@ -95,97 +93,69 @@ public LocalizeValue getName() { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { // see also the Extract Increment intention of IPP - final PsiElement element = descriptor.getPsiElement(); - final PsiExpression operand; - if (element instanceof PsiPostfixExpression) { - final PsiPostfixExpression postfixExpression = - (PsiPostfixExpression) element; + PsiElement element = descriptor.getPsiElement(); + PsiExpression operand; + if (element instanceof PsiPostfixExpression postfixExpression) { operand = postfixExpression.getOperand(); } else { - final PsiPrefixExpression prefixExpression = - (PsiPrefixExpression) element; + PsiPrefixExpression prefixExpression = (PsiPrefixExpression) element; operand = prefixExpression.getOperand(); } if (operand == null) { return; } - final PsiStatement statement = - PsiTreeUtil.getParentOfType(element, PsiStatement.class); + PsiStatement statement = PsiTreeUtil.getParentOfType(element, PsiStatement.class); if (statement == null) { return; } - final PsiElement parent = statement.getParent(); + PsiElement parent = statement.getParent(); if (parent == null) { return; } - final PsiElementFactory factory = - JavaPsiFacade.getInstance(project).getElementFactory(); - final String newStatementText = element.getText() + ';'; - final String operandText = operand.getText(); - if (parent instanceof PsiIfStatement || - parent instanceof PsiLoopStatement) { + PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + String newStatementText = element.getText() + ';'; + String operandText = operand.getText(); + if (parent instanceof PsiIfStatement || parent instanceof PsiLoopStatement) { // need to add braces because // in/decrement is inside braceless control statement body - final StringBuilder text = new StringBuilder(); + StringBuilder text = new StringBuilder(); text.append('{'); - final String elementText = - getElementText(statement, element, operandText); + String elementText = getElementText(statement, element, operandText); if (element instanceof PsiPostfixExpression) { - text.append(elementText); - text.append(newStatementText); + text.append(elementText).append(newStatementText); } else { - text.append(newStatementText); - text.append(elementText); + text.append(newStatementText).append(elementText); } text.append('}'); - final PsiCodeBlock codeBlock = - factory.createCodeBlockFromText(text.toString(), parent); + PsiCodeBlock codeBlock = factory.createCodeBlockFromText(text.toString(), parent); statement.replace(codeBlock); return; } - final PsiStatement newStatement = - factory.createStatementFromText(newStatementText, element); - if (statement instanceof PsiReturnStatement) { + PsiStatement newStatement = factory.createStatementFromText(newStatementText, element); + if (statement instanceof PsiReturnStatement returnStatement) { if (element instanceof PsiPostfixExpression) { // special handling of postfix expression in return statement - final PsiReturnStatement returnStatement = - (PsiReturnStatement) statement; - final PsiExpression returnValue = - returnStatement.getReturnValue(); + PsiExpression returnValue = returnStatement.getReturnValue(); if (returnValue == null) { return; } - final JavaCodeStyleManager javaCodeStyleManager = - JavaCodeStyleManager.getInstance(project); - final String variableName = - javaCodeStyleManager.suggestUniqueVariableName( - "result", returnValue, true); - final PsiType type = returnValue.getType(); + JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); + String variableName = javaCodeStyleManager.suggestUniqueVariableName("result", returnValue, true); + PsiType type = returnValue.getType(); if (type == null) { return; } - final String newReturnValueText = getElementText( - returnValue, element, operandText); - final String declarationStatementText = - type.getCanonicalText() + ' ' + variableName + - '=' + newReturnValueText + ';'; - final PsiStatement declarationStatement = - factory.createStatementFromText( - declarationStatementText, - returnStatement - ); + String newReturnValueText = getElementText(returnValue, element, operandText); + String declarationStatementText = type.getCanonicalText() + ' ' + variableName + '=' + newReturnValueText + ';'; + PsiStatement declarationStatement = factory.createStatementFromText(declarationStatementText, returnStatement); parent.addBefore(declarationStatement, statement); parent.addBefore(newStatement, statement); - final PsiStatement newReturnStatement = - factory.createStatementFromText( - "return " + variableName + ';', - returnStatement - ); + PsiStatement newReturnStatement = factory.createStatementFromText("return " + variableName + ';', returnStatement); returnStatement.replace(newReturnStatement); return; } @@ -193,43 +163,26 @@ protected void doFix(Project project, ProblemDescriptor descriptor) parent.addBefore(newStatement, statement); } } - else if (statement instanceof PsiThrowStatement) { + else if (statement instanceof PsiThrowStatement throwStatement) { if (element instanceof PsiPostfixExpression) { // special handling of postfix expression in throw statement - final PsiThrowStatement returnStatement = - (PsiThrowStatement) statement; - final PsiExpression exception = - returnStatement.getException(); + PsiExpression exception = throwStatement.getException(); if (exception == null) { return; } - final JavaCodeStyleManager javaCodeStyleManager = - JavaCodeStyleManager.getInstance(project); - final String variableName = - javaCodeStyleManager.suggestUniqueVariableName( - "e", exception, true); - final PsiType type = exception.getType(); + JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); + String variableName = javaCodeStyleManager.suggestUniqueVariableName("e", exception, true); + PsiType type = exception.getType(); if (type == null) { return; } - final String newReturnValueText = getElementText( - exception, element, operandText); - final String declarationStatementText = - type.getCanonicalText() + ' ' + variableName + - '=' + newReturnValueText + ';'; - final PsiStatement declarationStatement = - factory.createStatementFromText( - declarationStatementText, - returnStatement - ); + String newReturnValueText = getElementText(exception, element, operandText); + String declarationStatementText = type.getCanonicalText() + ' ' + variableName + '=' + newReturnValueText + ';'; + PsiStatement declarationStatement = factory.createStatementFromText(declarationStatementText, throwStatement); parent.addBefore(declarationStatement, statement); parent.addBefore(newStatement, statement); - final PsiStatement newReturnStatement = - factory.createStatementFromText( - "throw " + variableName + ';', - returnStatement - ); - returnStatement.replace(newReturnStatement); + PsiStatement newReturnStatement = factory.createStatementFromText("throw " + variableName + ';', throwStatement); + throwStatement.replace(newReturnStatement); return; } else { @@ -244,12 +197,10 @@ else if (!(statement instanceof PsiForStatement)) { parent.addBefore(newStatement, statement); } } - else if (operand instanceof PsiReferenceExpression) { - final PsiReferenceExpression referenceExpression = - (PsiReferenceExpression) operand; - final PsiElement target = referenceExpression.resolve(); + else if (operand instanceof PsiReferenceExpression referenceExpression) { + PsiElement target = referenceExpression.resolve(); if (target != null) { - final SearchScope useScope = target.getUseScope(); + SearchScope useScope = target.getUseScope(); if (!new LocalSearchScope(statement).equals(useScope)) { if (element instanceof PsiPostfixExpression) { parent.addAfter(newStatement, statement); @@ -260,19 +211,13 @@ else if (operand instanceof PsiReferenceExpression) { } } } - if (statement instanceof PsiLoopStatement) { + if (statement instanceof PsiLoopStatement loopStatement) { // in/decrement inside loop statement condition - final PsiLoopStatement loopStatement = - (PsiLoopStatement) statement; - final PsiStatement body = loopStatement.getBody(); - if (body instanceof PsiBlockStatement) { - final PsiBlockStatement blockStatement = - (PsiBlockStatement) body; - final PsiCodeBlock codeBlock = - blockStatement.getCodeBlock(); + PsiStatement body = loopStatement.getBody(); + if (body instanceof PsiBlockStatement blockStatement) { + PsiCodeBlock codeBlock = blockStatement.getCodeBlock(); if (element instanceof PsiPostfixExpression) { - final PsiElement firstElement = - codeBlock.getFirstBodyElement(); + PsiElement firstElement = codeBlock.getFirstBodyElement(); codeBlock.addBefore(newStatement, firstElement); } else { @@ -280,7 +225,7 @@ else if (operand instanceof PsiReferenceExpression) { } } else { - final StringBuilder blockText = new StringBuilder(); + StringBuilder blockText = new StringBuilder(); blockText.append('{'); if (element instanceof PsiPostfixExpression) { blockText.append(newStatementText); @@ -295,9 +240,7 @@ else if (operand instanceof PsiReferenceExpression) { blockText.append(newStatementText); } blockText.append('}'); - final PsiStatement blockStatement = - factory.createStatementFromText( - blockText.toString(), statement); + PsiStatement blockStatement = factory.createStatementFromText(blockText.toString(), statement); if (body == null) { loopStatement.add(blockStatement); } @@ -315,42 +258,31 @@ public BaseInspectionVisitor buildVisitor() { return new IncrementDecrementUsedAsExpressionVisitor(); } - private static class IncrementDecrementUsedAsExpressionVisitor - extends BaseInspectionVisitor { - + private static class IncrementDecrementUsedAsExpressionVisitor extends BaseInspectionVisitor { @Override - public void visitPostfixExpression( - @Nonnull PsiPostfixExpression expression - ) { + public void visitPostfixExpression(@Nonnull PsiPostfixExpression expression) { super.visitPostfixExpression(expression); - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiExpressionStatement || - (parent instanceof PsiExpressionList && - parent.getParent() instanceof - PsiExpressionListStatement)) { + PsiElement parent = expression.getParent(); + if (parent instanceof PsiExpressionStatement + || (parent instanceof PsiExpressionList && parent.getParent() instanceof PsiExpressionListStatement)) { return; } - final IElementType tokenType = expression.getOperationTokenType(); - if (!tokenType.equals(JavaTokenType.PLUSPLUS) && - !tokenType.equals(JavaTokenType.MINUSMINUS)) { + IElementType tokenType = expression.getOperationTokenType(); + if (!tokenType.equals(JavaTokenType.PLUSPLUS) && !tokenType.equals(JavaTokenType.MINUSMINUS)) { return; } registerError(expression, expression); } @Override - public void visitPrefixExpression( - @Nonnull PsiPrefixExpression expression - ) { + public void visitPrefixExpression(@Nonnull PsiPrefixExpression expression) { super.visitPrefixExpression(expression); - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiExpressionStatement || - (parent instanceof PsiExpressionList && - parent.getParent() instanceof - PsiExpressionListStatement)) { + PsiElement parent = expression.getParent(); + if (parent instanceof PsiExpressionStatement + || (parent instanceof PsiExpressionList && parent.getParent() instanceof PsiExpressionListStatement)) { return; } - final IElementType tokenType = expression.getOperationTokenType(); + IElementType tokenType = expression.getOperationTokenType(); if (!tokenType.equals(JavaTokenType.PLUSPLUS) && !tokenType.equals(JavaTokenType.MINUSMINUS)) { return; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/ReplaceAssignmentWithOperatorAssignmentInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/ReplaceAssignmentWithOperatorAssignmentInspection.java index c611d65e8..411f93ae4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/ReplaceAssignmentWithOperatorAssignmentInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/ReplaceAssignmentWithOperatorAssignmentInspection.java @@ -15,18 +15,19 @@ */ package com.intellij.java.impl.ig.assignment; +import com.intellij.java.analysis.codeInspection.ParenthesesUtils; +import com.intellij.java.analysis.impl.codeInspection.EquivalenceChecker; import com.intellij.java.language.psi.*; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; -import com.intellij.java.analysis.impl.codeInspection.EquivalenceChecker; -import com.intellij.java.analysis.codeInspection.ParenthesesUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; import consulo.language.ast.IElementType; import consulo.language.editor.inspection.ProblemDescriptor; -import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; import consulo.localize.LocalizeValue; import consulo.project.Project; @@ -61,11 +62,12 @@ public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.assignmentReplaceableWithOperatorAssignmentDisplayName(); } - @Override @Nonnull + @Override + @RequiredReadAction public String buildErrorString(Object... infos) { - final PsiExpression lhs = (PsiExpression) infos[0]; - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) infos[1]; + PsiExpression lhs = (PsiExpression) infos[0]; + PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) infos[1]; return InspectionGadgetsLocalize.assignmentReplaceableWithOperatorAssignmentProblemDescriptor( calculateReplacementExpression(lhs, polyadicExpression) ).get(); @@ -74,7 +76,7 @@ public String buildErrorString(Object... infos) { @Override @Nullable public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); optionsPanel.addCheckbox( InspectionGadgetsLocalize.assignmentReplaceableWithOperatorAssignmentIgnoreConditionalOperatorsOption().get(), "ignoreLazyOperators" @@ -86,9 +88,10 @@ public JComponent createOptionsPanel() { return optionsPanel; } + @RequiredReadAction static String calculateReplacementExpression(PsiExpression lhs, PsiPolyadicExpression polyadicExpression) { - final PsiExpression[] operands = polyadicExpression.getOperands(); - final PsiJavaToken sign = polyadicExpression.getTokenBeforeOperand(operands[1]); + PsiExpression[] operands = polyadicExpression.getOperands(); + PsiJavaToken sign = polyadicExpression.getTokenBeforeOperand(operands[1]); String signText = sign.getText(); if ("&&".equals(signText)) { signText = "&"; @@ -96,15 +99,12 @@ static String calculateReplacementExpression(PsiExpression lhs, PsiPolyadicExpre else if ("||".equals(signText)) { signText = "|"; } - final StringBuilder text = new StringBuilder(lhs.getText()); - text.append(' '); - text.append(signText); - text.append("= "); + StringBuilder text = new StringBuilder(lhs.getText()).append(' ').append(signText).append("= "); boolean addToken = false; for (int i = 1; i < operands.length; i++) { - final PsiExpression operand = operands[i]; + PsiExpression operand = operands[i]; if (addToken) { - final PsiJavaToken token = polyadicExpression.getTokenBeforeOperand(operand); + PsiJavaToken token = polyadicExpression.getTokenBeforeOperand(operand); text.append(' '); if (token != null) { text.append(token.getText()); @@ -120,6 +120,7 @@ else if ("||".equals(signText)) { } @Override + @RequiredReadAction public InspectionGadgetsFix buildFix(Object... infos) { return new ReplaceAssignmentWithOperatorAssignmentFix((PsiPolyadicExpression) infos[1]); } @@ -128,8 +129,9 @@ private static class ReplaceAssignmentWithOperatorAssignmentFix extends Inspecti @Nonnull private final LocalizeValue myName; + @RequiredReadAction private ReplaceAssignmentWithOperatorAssignmentFix(PsiPolyadicExpression expression) { - final PsiJavaToken sign = expression.getTokenBeforeOperand(expression.getOperands()[1]); + PsiJavaToken sign = expression.getTokenBeforeOperand(expression.getOperands()[1]); String signText = sign.getText(); if ("&&".equals(signText)) { signText = "&"; @@ -147,28 +149,24 @@ public LocalizeValue getName() { } @Override - public void doFix(@Nonnull Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - if (!(element instanceof PsiAssignmentExpression)) { + @RequiredWriteAction + public void doFix(@Nonnull Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + if (!(descriptor.getPsiElement() instanceof PsiAssignmentExpression expression)) { return; } - final PsiAssignmentExpression expression = (PsiAssignmentExpression) element; - final PsiExpression lhs = expression.getLExpression(); + PsiExpression lhs = expression.getLExpression(); PsiExpression rhs = ParenthesesUtils.stripParentheses(expression.getRExpression()); - if (rhs instanceof PsiTypeCastExpression) { - final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression) rhs; - final PsiType castType = typeCastExpression.getType(); + if (rhs instanceof PsiTypeCastExpression typeCastExpression) { + PsiType castType = typeCastExpression.getType(); if (castType == null || !castType.equals(lhs.getType())) { return; } rhs = ParenthesesUtils.stripParentheses(typeCastExpression.getOperand()); } - if (!(rhs instanceof PsiPolyadicExpression)) { + if (!(rhs instanceof PsiPolyadicExpression polyadicExpression)) { return; } - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) rhs; - final String newExpression = calculateReplacementExpression(lhs, polyadicExpression); + String newExpression = calculateReplacementExpression(lhs, polyadicExpression); replaceExpression(expression, newExpression); } } @@ -179,29 +177,26 @@ public BaseInspectionVisitor buildVisitor() { } private class ReplaceAssignmentWithOperatorAssignmentVisitor extends BaseInspectionVisitor { - @Override public void visitAssignmentExpression(@Nonnull PsiAssignmentExpression assignment) { super.visitAssignmentExpression(assignment); - final IElementType assignmentTokenType = assignment.getOperationTokenType(); + IElementType assignmentTokenType = assignment.getOperationTokenType(); if (!assignmentTokenType.equals(JavaTokenType.EQ)) { return; } - final PsiExpression lhs = assignment.getLExpression(); + PsiExpression lhs = assignment.getLExpression(); PsiExpression rhs = ParenthesesUtils.stripParentheses(assignment.getRExpression()); - if (rhs instanceof PsiTypeCastExpression) { - final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression) rhs; - final PsiType castType = typeCastExpression.getType(); + if (rhs instanceof PsiTypeCastExpression typeCastExpression) { + PsiType castType = typeCastExpression.getType(); if (castType == null || !castType.equals(lhs.getType())) { return; } rhs = ParenthesesUtils.stripParentheses(typeCastExpression.getOperand()); } - if (!(rhs instanceof PsiPolyadicExpression)) { + if (!(rhs instanceof PsiPolyadicExpression polyadicExpression)) { return; } - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) rhs; - final PsiExpression[] operands = polyadicExpression.getOperands(); + PsiExpression[] operands = polyadicExpression.getOperands(); if (operands.length < 2) { return; } @@ -213,7 +208,7 @@ public void visitAssignmentExpression(@Nonnull PsiAssignmentExpression assignmen return; } } - final IElementType expressionTokenType = polyadicExpression.getOperationTokenType(); + IElementType expressionTokenType = polyadicExpression.getOperationTokenType(); if (JavaTokenType.EQEQ.equals(expressionTokenType) || JavaTokenType.NE.equals(expressionTokenType)) { return; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/PointlessBitwiseExpressionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/PointlessBitwiseExpressionInspection.java index e3f4845cc..68302a7b6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/PointlessBitwiseExpressionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/PointlessBitwiseExpressionInspection.java @@ -22,6 +22,8 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.psiutils.ExpressionUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; import consulo.language.ast.IElementType; @@ -30,41 +32,40 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; import javax.swing.*; -import java.util.HashSet; import java.util.Set; @ExtensionImpl public class PointlessBitwiseExpressionInspection extends BaseInspection { + static final Set BITWISE_TOKENS = Set.of( + JavaTokenType.AND, + JavaTokenType.OR, + JavaTokenType.XOR, + JavaTokenType.LTLT, + JavaTokenType.GTGT, + JavaTokenType.GTGTGT + ); + static final Set BITWISE_LOGICAL_TOKENS = Set.of(JavaTokenType.AND, JavaTokenType.OR, JavaTokenType.XOR); + static final Set BITWISE_SHIFT_TOKENS = Set.of(JavaTokenType.LTLT, JavaTokenType.GTGT, JavaTokenType.GTGTGT); + /** * @noinspection PublicField */ public boolean m_ignoreExpressionsContainingConstants = false; - static final Set bitwiseTokens = new HashSet(6); - - static { - bitwiseTokens.add(JavaTokenType.AND); - bitwiseTokens.add(JavaTokenType.OR); - bitwiseTokens.add(JavaTokenType.XOR); - bitwiseTokens.add(JavaTokenType.LTLT); - bitwiseTokens.add(JavaTokenType.GTGT); - bitwiseTokens.add(JavaTokenType.GTGTGT); - } - @Nonnull @Override public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.pointlessBitwiseExpressionDisplayName(); } - @Override @Nonnull + @Override + @RequiredReadAction public String buildErrorString(Object... infos) { - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) infos[0]; - final String replacementExpression = calculateReplacementExpression(polyadicExpression); + PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) infos[0]; + String replacementExpression = calculateReplacementExpression(polyadicExpression); return InspectionGadgetsLocalize.expressionCanBeReplacedProblemDescriptor(replacementExpression).get(); } @@ -81,10 +82,10 @@ public JComponent createOptionsPanel() { ); } - @NonNls + @RequiredReadAction String calculateReplacementExpression(PsiPolyadicExpression expression) { - final IElementType tokenType = expression.getOperationTokenType(); - final PsiExpression[] operands = expression.getOperands(); + IElementType tokenType = expression.getOperationTokenType(); + PsiExpression[] operands = expression.getOperands(); if (tokenType.equals(JavaTokenType.AND)) { for (PsiExpression operand : operands) { if (isZero(operand)) { @@ -115,9 +116,7 @@ else if (isZero(operand)) { } } } - else if (tokenType.equals(JavaTokenType.LTLT) || - tokenType.equals(JavaTokenType.GTGT) || - tokenType.equals(JavaTokenType.GTGTGT)) { + else if (BITWISE_SHIFT_TOKENS.contains(tokenType)) { for (PsiExpression operand : operands) { if (isZero(operand)) { return getText(expression, operand); @@ -127,20 +126,17 @@ else if (tokenType.equals(JavaTokenType.LTLT) || return ""; } - private static String getText( - PsiPolyadicExpression expression, - PsiExpression exclude - ) { - final PsiExpression[] operands = expression.getOperands(); + @RequiredReadAction + private static String getText(PsiPolyadicExpression expression, PsiExpression exclude) { + PsiExpression[] operands = expression.getOperands(); boolean addToken = false; - final StringBuilder text = new StringBuilder(); + StringBuilder text = new StringBuilder(); for (PsiExpression operand : operands) { if (operand == exclude) { continue; } if (addToken) { - final PsiJavaToken token = - expression.getTokenBeforeOperand(operand); + PsiJavaToken token = expression.getTokenBeforeOperand(operand); text.append(' '); if (token != null) { text.append(token.getText()); @@ -173,45 +169,38 @@ public LocalizeValue getName() { } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiPolyadicExpression expression = (PsiPolyadicExpression) - descriptor.getPsiElement(); - final String newExpression = - calculateReplacementExpression(expression); + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiPolyadicExpression expression = (PsiPolyadicExpression) descriptor.getPsiElement(); + String newExpression = calculateReplacementExpression(expression); replaceExpression(expression, newExpression); } } private class PointlessBitwiseVisitor extends BaseInspectionVisitor { - @Override - public void visitPolyadicExpression( - @Nonnull PsiPolyadicExpression expression - ) { + @SuppressWarnings("SimplifiableIfStatement") + public void visitPolyadicExpression(@Nonnull PsiPolyadicExpression expression) { super.visitPolyadicExpression(expression); - final IElementType sign = expression.getOperationTokenType(); - if (!bitwiseTokens.contains(sign)) { + IElementType sign = expression.getOperationTokenType(); + if (!BITWISE_TOKENS.contains(sign)) { return; } - final PsiExpression[] operands = expression.getOperands(); + PsiExpression[] operands = expression.getOperands(); for (PsiExpression operand : operands) { if (operand == null) { return; } - final PsiType type = operand.getType(); + PsiType type = operand.getType(); if (type == null || type.equals(PsiType.BOOLEAN) || type.equalsToText(CommonClassNames.JAVA_LANG_BOOLEAN)) { return; } } - final boolean isPointless; - if (sign.equals(JavaTokenType.AND) || sign.equals(JavaTokenType.OR) || - sign.equals(JavaTokenType.XOR)) { + boolean isPointless; + if (BITWISE_LOGICAL_TOKENS.contains(sign)) { isPointless = booleanExpressionIsPointless(operands); } - else if (sign.equals(JavaTokenType.LTLT) || - sign.equals(JavaTokenType.GTGT) || - sign.equals(JavaTokenType.GTGTGT)) { + else if (BITWISE_SHIFT_TOKENS.contains(sign)) { isPointless = shiftExpressionIsPointless(operands); } else { @@ -234,7 +223,7 @@ private boolean booleanExpressionIsPointless(PsiExpression[] operands) { private boolean shiftExpressionIsPointless(PsiExpression[] operands) { for (int i = 1; i < operands.length; i++) { - final PsiExpression operand = operands[i]; + PsiExpression operand = operands[i]; if (isZero(operand)) { return true; } @@ -243,45 +232,28 @@ private boolean shiftExpressionIsPointless(PsiExpression[] operands) { } } + @SuppressWarnings("SimplifiableIfStatement") private boolean isZero(PsiExpression expression) { - if (m_ignoreExpressionsContainingConstants - && !(expression instanceof PsiLiteralExpression)) { + if (m_ignoreExpressionsContainingConstants && !(expression instanceof PsiLiteralExpression)) { return false; } return ExpressionUtils.isZero(expression); } + @SuppressWarnings("SimplifiableIfStatement") private boolean isAllOnes(PsiExpression expression) { - if (m_ignoreExpressionsContainingConstants - && !(expression instanceof PsiLiteralExpression)) { + if (m_ignoreExpressionsContainingConstants && !(expression instanceof PsiLiteralExpression)) { return false; } - final PsiType expressionType = expression.getType(); - final Object value = - ConstantExpressionUtil.computeCastTo( - expression, - expressionType - ); - if (value == null) { - return false; - } - if (value instanceof Integer && - ((Integer) value).intValue() == 0xffffffff) { - return true; - } - if (value instanceof Long && - ((Long) value).longValue() == 0xffffffffffffffffL) { - return true; - } - if (value instanceof Short && - ((Short) value).shortValue() == (short) 0xffff) { - return true; - } - if (value instanceof Character && - ((Character) value).charValue() == (char) 0xffff) { - return true; - } - return value instanceof Byte && - ((Byte) value).byteValue() == (byte) 0xff; + PsiType expressionType = expression.getType(); + return switch (ConstantExpressionUtil.computeCastTo(expression, expressionType)) { + case null -> false; + case Integer intValue -> intValue == 0xFFFFFFFF; + case Long longValue -> longValue == 0xFFFFFFFFFFFFFFFFL; + case Short shortValue -> shortValue == (short) 0xFFFF; + case Character charValue -> charValue == (char) 0xFFFF; + case Byte byteValue -> byteValue == (byte) 0xFF; + default -> false; + }; } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/ShiftOutOfRangeInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/ShiftOutOfRangeInspection.java index daddbb06f..50d1e36f1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/ShiftOutOfRangeInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bitwise/ShiftOutOfRangeInspection.java @@ -22,6 +22,7 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.ast.IElementType; import consulo.language.editor.inspection.ProblemDescriptor; @@ -39,10 +40,10 @@ public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.shiftOperationByInappropriateConstantDisplayName(); } - @Override @Nonnull + @Override public String buildErrorString(Object... infos) { - final Integer value = (Integer) infos[0]; + Integer value = (Integer) infos[0]; return value > 0 ? InspectionGadgetsLocalize.shiftOperationByInappropriateConstantProblemDescriptorTooLarge().get() : InspectionGadgetsLocalize.shiftOperationByInappropriateConstantProblemDescriptorNegative().get(); @@ -59,7 +60,6 @@ protected InspectionGadgetsFix buildFix(Object... infos) { } private static class ShiftOutOfRangeFix extends InspectionGadgetsFix { - private final int value; private final boolean isLong; @@ -76,32 +76,27 @@ public LocalizeValue getName() { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiBinaryExpression)) { + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiElement element = descriptor.getPsiElement(); + PsiElement parent = element.getParent(); + if (!(parent instanceof PsiBinaryExpression binaryExpression)) { return; } - final PsiBinaryExpression binaryExpression = - (PsiBinaryExpression) parent; - final PsiExpression rhs = binaryExpression.getROperand(); + PsiExpression rhs = binaryExpression.getROperand(); if (rhs == null) { return; } - final PsiElementFactory factory = - JavaPsiFacade.getElementFactory(project); - final String text; - final PsiExpression lhs = binaryExpression.getLOperand(); + PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + String text; + PsiExpression lhs = binaryExpression.getLOperand(); if (PsiType.LONG.equals(lhs.getType())) { - text = String.valueOf(value & 63); + text = String.valueOf(value & 0x3F); } else { - text = String.valueOf(value & 31); + text = String.valueOf(value & 0x1F); } - final PsiExpression newExpression = - factory.createExpressionFromText( - text, element); + PsiExpression newExpression = factory.createExpressionFromText(text, element); rhs.replace(newExpression); } } @@ -112,39 +107,32 @@ public BaseInspectionVisitor buildVisitor() { } private static class ShiftOutOfRange extends BaseInspectionVisitor { - @Override - public void visitBinaryExpression( - @Nonnull PsiBinaryExpression expression - ) { + public void visitBinaryExpression(@Nonnull PsiBinaryExpression expression) { super.visitBinaryExpression(expression); - final PsiJavaToken sign = expression.getOperationSign(); - final IElementType tokenType = sign.getTokenType(); + PsiJavaToken sign = expression.getOperationSign(); + IElementType tokenType = sign.getTokenType(); if (!tokenType.equals(JavaTokenType.LTLT) && !tokenType.equals(JavaTokenType.GTGT) && !tokenType.equals(JavaTokenType.GTGTGT)) { return; } - final PsiType expressionType = expression.getType(); + PsiType expressionType = expression.getType(); if (expressionType == null) { return; } - final PsiExpression rhs = expression.getROperand(); + PsiExpression rhs = expression.getROperand(); if (rhs == null) { return; } if (!PsiUtil.isConstantExpression(rhs)) { return; } - final Integer valueObject = - (Integer) ConstantExpressionUtil.computeCastTo( - rhs, - PsiType.INT - ); + Integer valueObject = (Integer) ConstantExpressionUtil.computeCastTo(rhs, PsiType.INT); if (valueObject == null) { return; } - final int value = valueObject.intValue(); + int value = valueObject; if (expressionType.equals(PsiType.LONG)) { if (value < 0 || value > 63) { registerError(sign, valueObject, Boolean.TRUE); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java index 0ecbdc2e2..516f55889 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java @@ -21,6 +21,7 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; @@ -28,28 +29,25 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class ArchaicSystemPropertyAccessInspection extends BaseInspection { - - @Override @Nonnull + @Override public String getID() { return "UseOfArchaicSystemPropertyAccessors"; } - @Override @Nonnull + @Override public LocalizeValue getDisplayName() { return InspectionGadgetsLocalize.archaicSystemPropertyAccessorsDisplayName(); } - @Override @Nonnull + @Override public String buildErrorString(Object... infos) { - final PsiMethodCallExpression call = - (PsiMethodCallExpression) infos[0]; + PsiMethodCallExpression call = (PsiMethodCallExpression) infos[0]; if (isIntegerGetInteger(call)) { return InspectionGadgetsLocalize.archaicSystemPropertyAccessorsProblemDescriptorInteger().get(); } @@ -69,26 +67,24 @@ protected InspectionGadgetsFix[] buildFixes(Object... infos) { } private static class ReplaceWithParseMethodFix extends InspectionGadgetsFix { - @Nonnull + @Override public LocalizeValue getName() { return InspectionGadgetsLocalize.archaicSystemPropertyAccessorsReplaceParseQuickfix(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiIdentifier location = - (PsiIdentifier) descriptor.getPsiElement(); - final PsiElement parent = location.getParent(); + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiIdentifier location = (PsiIdentifier) descriptor.getPsiElement(); + PsiElement parent = location.getParent(); assert parent != null; - final PsiMethodCallExpression call = - (PsiMethodCallExpression) parent.getParent(); + PsiMethodCallExpression call = (PsiMethodCallExpression) parent.getParent(); assert call != null; - final PsiExpressionList argList = call.getArgumentList(); - final PsiExpression[] args = argList.getExpressions(); - final String argText = args[0].getText(); - @NonNls final String parseMethodCall; + PsiExpressionList argList = call.getArgumentList(); + PsiExpression[] args = argList.getExpressions(); + String argText = args[0].getText(); + String parseMethodCall; if (isIntegerGetInteger(call)) { parseMethodCall = "Integer.valueOf(" + argText + ')'; } @@ -102,45 +98,36 @@ else if (isLongGetLong(call)) { } } - private static class ReplaceWithStandardPropertyAccessFix - extends InspectionGadgetsFix { - + private static class ReplaceWithStandardPropertyAccessFix extends InspectionGadgetsFix { @Nonnull + @Override public LocalizeValue getName() { return InspectionGadgetsLocalize.archaicSystemPropertyAccessorsReplaceStandardQuickfix(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiIdentifier location = - (PsiIdentifier) descriptor.getPsiElement(); - final PsiElement parent = location.getParent(); + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiIdentifier location = (PsiIdentifier) descriptor.getPsiElement(); + PsiElement parent = location.getParent(); assert parent != null; - final PsiMethodCallExpression call = - (PsiMethodCallExpression) parent.getParent(); + PsiMethodCallExpression call = (PsiMethodCallExpression) parent.getParent(); assert call != null; - final PsiExpressionList argList = call.getArgumentList(); - final PsiExpression[] args = argList.getExpressions(); - final String argText = args[0].getText(); - @NonNls final String parseMethodCall; + PsiExpressionList argList = call.getArgumentList(); + PsiExpression[] args = argList.getExpressions(); + String argText = args[0].getText(); + String parseMethodCall; if (isIntegerGetInteger(call)) { - parseMethodCall = "Integer.parseInt(System.getProperty(" - + argText + "))"; + parseMethodCall = "Integer.parseInt(System.getProperty(" + argText + "))"; } else if (isLongGetLong(call)) { - parseMethodCall = "Long.parseLong(System.getProperty(" - + argText + "))"; + parseMethodCall = "Long.parseLong(System.getProperty(" + argText + "))"; + } + else if (!PsiUtil.isLanguageLevel5OrHigher(call)) { + parseMethodCall = "Boolean.valueOf(System.getProperty(" + argText + ")).booleanValue()"; } else { - if (!PsiUtil.isLanguageLevel5OrHigher(call)) { - parseMethodCall = "Boolean.valueOf(System.getProperty(" - + argText + ")).booleanValue()"; - } - else { - parseMethodCall = "Boolean.parseBoolean(System.getProperty(" - + argText + "))"; - } + parseMethodCall = "Boolean.parseBoolean(System.getProperty(" + argText + "))"; } replaceExpression(call, parseMethodCall); } @@ -151,9 +138,7 @@ public BaseInspectionVisitor buildVisitor() { return new ArchaicSystemPropertyAccessVisitor(); } - private static class ArchaicSystemPropertyAccessVisitor - extends BaseInspectionVisitor { - + private static class ArchaicSystemPropertyAccessVisitor extends BaseInspectionVisitor { @Override public void visitMethodCallExpression( @Nonnull PsiMethodCallExpression expression) { @@ -178,27 +163,21 @@ static boolean isBooleanGetBoolean(PsiMethodCallExpression expression) { return isCallTo(expression, CommonClassNames.JAVA_LANG_BOOLEAN, "getBoolean"); } - private static boolean isCallTo(PsiMethodCallExpression expression, - String className, @NonNls String methodName) { - final PsiReferenceExpression methodExpression = - expression.getMethodExpression(); - @NonNls final String expressionMethodName = - methodExpression.getReferenceName(); + private static boolean isCallTo(PsiMethodCallExpression expression, String className, String methodName) { + PsiReferenceExpression methodExpression = expression.getMethodExpression(); + String expressionMethodName = methodExpression.getReferenceName(); if (!methodName.equals(expressionMethodName)) { return false; } - final PsiMethod method = expression.resolveMethod(); + PsiMethod method = expression.resolveMethod(); if (method == null) { return false; } - final PsiClass aClass = method.getContainingClass(); + PsiClass aClass = method.getContainingClass(); if (aClass == null) { return false; } - final String expressionClassName = aClass.getQualifiedName(); - if (expressionClassName == null) { - return false; - } - return className.equals(expressionClassName); + String expressionClassName = aClass.getQualifiedName(); + return expressionClassName != null && className.equals(expressionClassName); } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualityInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualityInspection.java index 9633cd3a3..892653415 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualityInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualityInspection.java @@ -21,6 +21,8 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.psiutils.ComparisonUtils; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.ast.IElementType; import consulo.language.editor.inspection.ProblemDescriptor; @@ -29,7 +31,6 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class ArrayEqualityInspection extends BaseInspection { @@ -47,12 +48,8 @@ public String buildErrorString(Object... infos) { @Override public InspectionGadgetsFix buildFix(Object... infos) { - final PsiArrayType type = (PsiArrayType) infos[0]; - final PsiType componentType = type.getComponentType(); - if (componentType instanceof PsiArrayType) { - return new ArrayEqualityFix(true); - } - return new ArrayEqualityFix(false); + PsiArrayType type = (PsiArrayType) infos[0]; + return new ArrayEqualityFix(type.getComponentType() instanceof PsiArrayType); } private static class ArrayEqualityFix extends InspectionGadgetsFix { @@ -71,18 +68,15 @@ public LocalizeValue getName() { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiBinaryExpression)) { + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiElement element = descriptor.getPsiElement(); + PsiElement parent = element.getParent(); + if (!(parent instanceof PsiBinaryExpression binaryExpression)) { return; } - final PsiBinaryExpression binaryExpression = - (PsiBinaryExpression) parent; - final IElementType tokenType = - binaryExpression.getOperationTokenType(); - @NonNls final StringBuilder newExpressionText = new StringBuilder(); + IElementType tokenType = binaryExpression.getOperationTokenType(); + StringBuilder newExpressionText = new StringBuilder(); if (JavaTokenType.NE.equals(tokenType)) { newExpressionText.append('!'); } @@ -97,16 +91,13 @@ else if (!JavaTokenType.EQEQ.equals(tokenType)) { } newExpressionText.append(binaryExpression.getLOperand().getText()); newExpressionText.append(','); - final PsiExpression rhs = binaryExpression.getROperand(); + PsiExpression rhs = binaryExpression.getROperand(); if (rhs == null) { return; } newExpressionText.append(rhs.getText()); newExpressionText.append(')'); - replaceExpressionAndShorten( - binaryExpression, - newExpressionText.toString() - ); + replaceExpressionAndShorten(binaryExpression, newExpressionText.toString()); } } @@ -116,36 +107,34 @@ public BaseInspectionVisitor buildVisitor() { } private static class ArrayEqualityVisitor extends BaseInspectionVisitor { - @Override - public void visitBinaryExpression( - @Nonnull PsiBinaryExpression expression - ) { + @RequiredReadAction + public void visitBinaryExpression(@Nonnull PsiBinaryExpression expression) { super.visitBinaryExpression(expression); - final PsiExpression rhs = expression.getROperand(); + PsiExpression rhs = expression.getROperand(); if (rhs == null) { return; } if (!ComparisonUtils.isEqualityComparison(expression)) { return; } - final PsiExpression lhs = expression.getLOperand(); - final PsiType lhsType = lhs.getType(); + PsiExpression lhs = expression.getLOperand(); + PsiType lhsType = lhs.getType(); if (!(lhsType instanceof PsiArrayType)) { return; } if (!(rhs.getType() instanceof PsiArrayType)) { return; } - final String lhsText = lhs.getText(); + String lhsText = lhs.getText(); if (PsiKeyword.NULL.equals(lhsText)) { return; } - final String rhsText = rhs.getText(); + String rhsText = rhs.getText(); if (PsiKeyword.NULL.equals(rhsText)) { return; } - final PsiJavaToken sign = expression.getOperationSign(); + PsiJavaToken sign = expression.getOperationSign(); registerError(sign, lhsType); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualsInspection.java index fc319069f..b4ef4a5a5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayEqualsInspection.java @@ -21,13 +21,13 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.util.IncorrectOperationException; import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class ArrayEqualsInspection extends BaseInspection { @@ -50,12 +50,9 @@ public boolean isEnabledByDefault() { @Override public InspectionGadgetsFix buildFix(Object... infos) { - final PsiArrayType type = (PsiArrayType) infos[0]; - if (type != null) { - final PsiType componentType = type.getComponentType(); - if (componentType instanceof PsiArrayType) { - return new ArrayEqualsFix(true); - } + PsiArrayType type = (PsiArrayType) infos[0]; + if (type != null && type.getComponentType() instanceof PsiArrayType) { + return new ArrayEqualsFix(true); } return new ArrayEqualsFix(false); } @@ -68,6 +65,7 @@ public ArrayEqualsFix(boolean deepEquals) { } @Nonnull + @Override public LocalizeValue getName() { return deepEquals ? InspectionGadgetsLocalize.replaceWithArraysDeepEquals() @@ -75,20 +73,20 @@ public LocalizeValue getName() { } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiIdentifier name = (PsiIdentifier) descriptor.getPsiElement(); - final PsiReferenceExpression expression = (PsiReferenceExpression) name.getParent(); + @RequiredWriteAction + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiIdentifier name = (PsiIdentifier) descriptor.getPsiElement(); + PsiReferenceExpression expression = (PsiReferenceExpression) name.getParent(); assert expression != null; - final PsiMethodCallExpression call = (PsiMethodCallExpression) expression.getParent(); - final PsiExpression qualifier = expression.getQualifierExpression(); + PsiMethodCallExpression call = (PsiMethodCallExpression) expression.getParent(); + PsiExpression qualifier = expression.getQualifierExpression(); assert qualifier != null; - final String qualifierText = qualifier.getText(); + String qualifierText = qualifier.getText(); assert call != null; - final PsiExpressionList argumentList = call.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final String argumentText = arguments[0].getText(); - @NonNls final StringBuilder newExpressionText = new StringBuilder(); + PsiExpressionList argumentList = call.getArgumentList(); + PsiExpression[] arguments = argumentList.getExpressions(); + String argumentText = arguments[0].getText(); + StringBuilder newExpressionText = new StringBuilder(); if (deepEquals) { newExpressionText.append("java.util.Arrays.deepEquals("); } @@ -110,39 +108,26 @@ public BaseInspectionVisitor buildVisitor() { private static class ArrayEqualsVisitor extends BaseInspectionVisitor { @Override - public void visitMethodCallExpression( - @Nonnull PsiMethodCallExpression expression - ) { + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = - expression.getMethodExpression(); - final String methodName = methodExpression.getReferenceName(); + PsiReferenceExpression methodExpression = expression.getMethodExpression(); + String methodName = methodExpression.getReferenceName(); if (!HardcodedMethodConstants.EQUALS.equals(methodName)) { return; } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); + PsiExpressionList argumentList = expression.getArgumentList(); + PsiExpression[] arguments = argumentList.getExpressions(); if (arguments.length != 1) { return; } - final PsiExpression argument = arguments[0]; - if (argument == null) { - return; - } - final PsiType argumentType = argument.getType(); - if (!(argumentType instanceof PsiArrayType)) { + PsiExpression argument = arguments[0]; + if (argument == null || !(argument.getType() instanceof PsiArrayType)) { return; } - final PsiExpression qualifier = - methodExpression.getQualifierExpression(); - if (qualifier == null) { - return; - } - final PsiType qualifierType = qualifier.getType(); - if (!(qualifierType instanceof PsiArrayType)) { - return; + PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null && qualifier.getType() instanceof PsiArrayType arrayType) { + registerMethodCallError(expression, arrayType); } - registerMethodCallError(expression, qualifierType); } } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayHashCodeInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayHashCodeInspection.java index e170401af..fdd2d05ae 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayHashCodeInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArrayHashCodeInspection.java @@ -21,6 +21,7 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredWriteAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; @@ -28,7 +29,6 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class ArrayHashCodeInspection extends BaseInspection { @@ -51,7 +51,7 @@ public boolean isEnabledByDefault() { @Override protected InspectionGadgetsFix buildFix(Object... infos) { - final PsiArrayType type = (PsiArrayType) infos[0]; + PsiArrayType type = (PsiArrayType) infos[0]; if (type.getComponentType() instanceof PsiArrayType) { return new ArrayHashCodeFix(true); } @@ -59,7 +59,6 @@ protected InspectionGadgetsFix buildFix(Object... infos) { } private static class ArrayHashCodeFix extends InspectionGadgetsFix { - private final boolean deepHashCode; public ArrayHashCodeFix(boolean deepHashCode) { @@ -75,24 +74,20 @@ public LocalizeValue getName() { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - final PsiElement grandParent = parent.getParent(); - if (!(grandParent instanceof PsiMethodCallExpression)) { + @RequiredWriteAction + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiElement element = descriptor.getPsiElement(); + PsiElement parent = element.getParent(); + PsiElement grandParent = parent.getParent(); + if (!(grandParent instanceof PsiMethodCallExpression methodCallExpression)) { return; } - final PsiMethodCallExpression methodCallExpression = - (PsiMethodCallExpression) grandParent; - final PsiReferenceExpression methodExpression = - methodCallExpression.getMethodExpression(); - final PsiExpression qualifier = - methodExpression.getQualifierExpression(); + PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + PsiExpression qualifier = methodExpression.getQualifierExpression(); if (qualifier == null) { return; } - @NonNls final StringBuilder newExpressionText = new StringBuilder(); + StringBuilder newExpressionText = new StringBuilder(); if (deepHashCode) { newExpressionText.append("java.util.Arrays.deepHashCode("); } @@ -101,10 +96,7 @@ protected void doFix(Project project, ProblemDescriptor descriptor) } newExpressionText.append(qualifier.getText()); newExpressionText.append(')'); - replaceExpressionAndShorten( - methodCallExpression, - newExpressionText.toString() - ); + replaceExpressionAndShorten(methodCallExpression, newExpressionText.toString()); } } @@ -114,33 +106,23 @@ public BaseInspectionVisitor buildVisitor() { } private static class ArrayHashCodeVisitor extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression( - PsiMethodCallExpression expression - ) { + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = - expression.getMethodExpression(); - final String methodName = methodExpression.getReferenceName(); + PsiReferenceExpression methodExpression = expression.getMethodExpression(); + String methodName = methodExpression.getReferenceName(); if (!HardcodedMethodConstants.HASH_CODE.equals(methodName)) { return; } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); + PsiExpressionList argumentList = expression.getArgumentList(); + PsiExpression[] arguments = argumentList.getExpressions(); if (arguments.length != 0) { return; } - final PsiExpression qualifier = - methodExpression.getQualifierExpression(); - if (qualifier == null) { - return; - } - final PsiType type = qualifier.getType(); - if (!(type instanceof PsiArrayType)) { - return; + PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null && qualifier.getType() instanceof PsiArrayType arrayType) { + registerMethodCallError(expression, arrayType); } - registerMethodCallError(expression, type); } } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/AbsoluteAlignmentInUserInterfaceInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/AbsoluteAlignmentInUserInterfaceInspection.java index 653590aea..7c64fff15 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/AbsoluteAlignmentInUserInterfaceInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/AbsoluteAlignmentInUserInterfaceInspection.java @@ -23,6 +23,8 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; @@ -30,50 +32,39 @@ import consulo.project.Project; import jakarta.annotation.Nonnull; -import java.util.HashMap; import java.util.Map; public abstract class AbsoluteAlignmentInUserInterfaceInspection extends BaseInspection { - private static final Map gridbagConstants = new HashMap(); - - static { - gridbagConstants.put("NORTHWEST", "FIRST_LINE_START"); - gridbagConstants.put("NORTHEAST", "FIRST_LINE_END"); - gridbagConstants.put("SOUTHWEST", "LAST_LINE_START"); - gridbagConstants.put("SOUTHEAST", "LAST_LINE_END"); - } - - private static final Map borderLayoutConstants = new HashMap(); - - static { - borderLayoutConstants.put("NORTH", "PAGE_START"); - borderLayoutConstants.put("SOUTH", "PAGE_END"); - borderLayoutConstants.put("EAST", "LINE_END"); - borderLayoutConstants.put("WEST", "LINE_START"); - } - - private static final Map flowLayoutConstants = new HashMap(); - - static { - flowLayoutConstants.put("LEFT", "LEADING"); - flowLayoutConstants.put("RIGHT", "TRAILING"); - } - - private static final Map scrollPaneConstants = new HashMap(); - - static { - scrollPaneConstants.put("LOWER_LEFT_CORNER", "LOWER_LEADING_CORNER"); - scrollPaneConstants.put("LOWER_RIGHT_CORNER", "LOWER_TRAILING_CORNER"); - scrollPaneConstants.put("UPPER_LEFT_CORNER", "UPPER_LEADING_CORNER"); - scrollPaneConstants.put("UPPER_RIGHT_CORNER", "UPPER_TRAILING_CORNER"); - } - - private static final Map boxLayoutConstants = new HashMap(); - - static { - boxLayoutConstants.put("X_AXIS", "LINE_AXIS"); - boxLayoutConstants.put("Y_AXIS", "PAGE_AXIS"); - } + private static final Map GRID_BAG_CONSTANTS = Map.of( + "NORTHWEST", "FIRST_LINE_START", + "NORTHEAST", "FIRST_LINE_END", + "SOUTHWEST", "LAST_LINE_START", + "SOUTHEAST", "LAST_LINE_END" + ); + + private static final Map BORDER_LAYOUT_CONSTANTS = Map.of( + "NORTH", "PAGE_START", + "SOUTH", "PAGE_END", + "EAST", "LINE_END", + "WEST", "LINE_START" + ); + + private static final Map FLOW_LAYOUT_CONSTANTS = Map.of( + "LEFT", "LEADING", + "RIGHT", "TRAILING" + ); + + private static final Map SCROLL_PANE_CONSTANTS = Map.of( + "LOWER_LEFT_CORNER", "LOWER_LEADING_CORNER", + "LOWER_RIGHT_CORNER", "LOWER_TRAILING_CORNER", + "UPPER_LEFT_CORNER", "UPPER_LEADING_CORNER", + "UPPER_RIGHT_CORNER", "UPPER_TRAILING_CORNER" + ); + + private static final Map BOX_LAYOUT_CONSTANTS = Map.of( + "X_AXIS", "LINE_AXIS", + "Y_AXIS", "PAGE_AXIS" + ); @Nonnull @Override @@ -84,8 +75,8 @@ public LocalizeValue getDisplayName() { @Nonnull @Override protected String buildErrorString(Object... infos) { - final String className = (String) infos[0]; - final String shortClassName = className.substring(className.lastIndexOf('.') + 1); + String className = (String) infos[0]; + String shortClassName = className.substring(className.lastIndexOf('.') + 1); return InspectionGadgetsLocalize.absoluteAlignmentInUserInterfaceProblemDescriptor(shortClassName).get(); } @@ -111,13 +102,12 @@ public LocalizeValue getName() { } @Override + @RequiredWriteAction protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiReferenceExpression)) { + PsiElement element = descriptor.getPsiElement(); + if (!(element.getParent() instanceof PsiReferenceExpression referenceExpression)) { return; } - final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) parent; replaceExpression(referenceExpression, myClassName + '.' + myReplacement); } } @@ -128,30 +118,33 @@ public BaseInspectionVisitor buildVisitor() { } private static class AbsoluteAlignmentInUserInterfaceVisitor extends BaseInspectionVisitor { - @Override + @RequiredReadAction public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); - final PsiElement referenceNameElement = expression.getReferenceNameElement(); + PsiElement referenceNameElement = expression.getReferenceNameElement(); if (referenceNameElement == null) { return; } - final String referenceName = expression.getReferenceName(); - final String className; + String referenceName = expression.getReferenceName(); + String className; String value; - if ((value = gridbagConstants.get(referenceName)) != null) { + if (referenceName == null) { + return; + } + else if ((value = GRID_BAG_CONSTANTS.get(referenceName)) != null) { className = checkExpression(expression, "java.awt.GridBagConstraints"); } - else if ((value = borderLayoutConstants.get(referenceName)) != null) { + else if ((value = BORDER_LAYOUT_CONSTANTS.get(referenceName)) != null) { className = checkExpression(expression, "java.awt.BorderLayout", "java.awt.GridBagConstraints"); } - else if ((value = flowLayoutConstants.get(referenceName)) != null) { + else if ((value = FLOW_LAYOUT_CONSTANTS.get(referenceName)) != null) { className = checkExpression(expression, "java.awt.FlowLayout"); } - else if ((value = scrollPaneConstants.get(referenceName)) != null) { + else if ((value = SCROLL_PANE_CONSTANTS.get(referenceName)) != null) { className = checkExpression(expression, "javax.swing.ScrollPaneConstants"); } - else if ((value = boxLayoutConstants.get(referenceName)) != null) { + else if ((value = BOX_LAYOUT_CONSTANTS.get(referenceName)) != null) { className = checkExpression(expression, "javax.swing.BoxLayout"); } else { @@ -163,13 +156,12 @@ else if ((value = boxLayoutConstants.get(referenceName)) != null) { registerError(referenceNameElement, className, value); } + @RequiredReadAction private static String checkExpression(PsiReferenceExpression expression, String... classNames) { - final PsiElement target = expression.resolve(); - if (!(target instanceof PsiField)) { + if (!(expression.resolve() instanceof PsiField field)) { return null; } - final PsiField field = (PsiField) target; - final PsiClass containingClass = field.getContainingClass(); + PsiClass containingClass = field.getContainingClass(); for (String className : classNames) { if (InheritanceUtil.isInheritor(containingClass, className)) { return className;