diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/InstanceofCatchParameterInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/InstanceofCatchParameterInspection.java index 033f21c531..18d3611931 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/InstanceofCatchParameterInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/InstanceofCatchParameterInspection.java @@ -22,49 +22,47 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class InstanceofCatchParameterInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.instanceofCatchParameterDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.instanceofCatchParameterDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.instanceofCatchParameterProblemDescriptor().get(); - } - - public BaseInspectionVisitor buildVisitor() { - return new InstanceofCatchParameterVisitor(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.instanceofCatchParameterProblemDescriptor().get(); + } - private static class InstanceofCatchParameterVisitor - extends BaseInspectionVisitor { + public BaseInspectionVisitor buildVisitor() { + return new InstanceofCatchParameterVisitor(); + } - @Override - public void visitInstanceOfExpression( - @Nonnull PsiInstanceOfExpression exp) { - super.visitInstanceOfExpression(exp); - if (!ControlFlowUtils.isInCatchBlock(exp)) { - return; - } - final PsiExpression operand = exp.getOperand(); - if (!(operand instanceof PsiReferenceExpression)) { - return; - } - final PsiReferenceExpression ref = (PsiReferenceExpression)operand; - final PsiElement referent = ref.resolve(); - if (!(referent instanceof PsiParameter)) { - return; - } - final PsiParameter parameter = (PsiParameter)referent; - if (!(parameter.getDeclarationScope() instanceof PsiCatchSection)) { - return; - } - registerError(exp); + private static class InstanceofCatchParameterVisitor extends BaseInspectionVisitor { + @Override + public void visitInstanceOfExpression(@Nonnull PsiInstanceOfExpression exp) { + super.visitInstanceOfExpression(exp); + if (!ControlFlowUtils.isInCatchBlock(exp)) { + return; + } + final PsiExpression operand = exp.getOperand(); + if (!(operand instanceof PsiReferenceExpression)) { + return; + } + final PsiReferenceExpression ref = (PsiReferenceExpression) operand; + final PsiElement referent = ref.resolve(); + if (!(referent instanceof PsiParameter)) { + return; + } + final PsiParameter parameter = (PsiParameter) referent; + if (!(parameter.getDeclarationScope() instanceof PsiCatchSection)) { + return; + } + registerError(exp); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NestedTryStatementInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NestedTryStatementInspection.java index 7e26854481..74d8c990e7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NestedTryStatementInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NestedTryStatementInspection.java @@ -15,64 +15,65 @@ */ package com.intellij.java.impl.ig.errorhandling; -import com.siyeh.localize.InspectionGadgetsLocalize; -import jakarta.annotation.Nonnull; - import com.intellij.java.language.psi.PsiCodeBlock; import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.PsiTryStatement; -import consulo.annotation.component.ExtensionImpl; -import consulo.language.psi.util.PsiTreeUtil; -import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.component.ExtensionImpl; +import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; +import jakarta.annotation.Nonnull; @ExtensionImpl public class NestedTryStatementInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nestedTryStatementDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.nestedTryStatementDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nestedTryStatementProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nestedTryStatementProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new NestedTryStatementVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new NestedTryStatementVisitor(); + } - private static class NestedTryStatementVisitor - extends BaseInspectionVisitor { + private static class NestedTryStatementVisitor + extends BaseInspectionVisitor { - @Override - public void visitTryStatement(@Nonnull PsiTryStatement statement) { - super.visitTryStatement(statement); - final PsiTryStatement parentTry = - PsiTreeUtil.getParentOfType(statement, - PsiTryStatement.class); - if (parentTry == null) { - return; - } - final PsiCodeBlock tryBlock = parentTry.getTryBlock(); - if (tryBlock == null) { - return; - } - if (!PsiTreeUtil.isAncestor(tryBlock, statement, true)) { - return; - } - final PsiMethod containingMethod = - PsiTreeUtil.getParentOfType(statement, PsiMethod.class); - final PsiMethod containingContainingMethod = - PsiTreeUtil.getParentOfType(parentTry, PsiMethod.class); - if (containingMethod == null || - containingContainingMethod == null || - !containingMethod.equals(containingContainingMethod)) { - return; - } - registerStatementError(statement); + @Override + public void visitTryStatement(@Nonnull PsiTryStatement statement) { + super.visitTryStatement(statement); + final PsiTryStatement parentTry = + PsiTreeUtil.getParentOfType( + statement, + PsiTryStatement.class + ); + if (parentTry == null) { + return; + } + final PsiCodeBlock tryBlock = parentTry.getTryBlock(); + if (tryBlock == null) { + return; + } + if (!PsiTreeUtil.isAncestor(tryBlock, statement, true)) { + return; + } + final PsiMethod containingMethod = + PsiTreeUtil.getParentOfType(statement, PsiMethod.class); + final PsiMethod containingContainingMethod = + PsiTreeUtil.getParentOfType(parentTry, PsiMethod.class); + if (containingMethod == null || + containingContainingMethod == null || + !containingMethod.equals(containingContainingMethod)) { + return; + } + registerStatementError(statement); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NewExceptionWithoutArgumentsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NewExceptionWithoutArgumentsInspection.java index f9b7ba1ded..5cf688e717 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NewExceptionWithoutArgumentsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NewExceptionWithoutArgumentsInspection.java @@ -25,85 +25,84 @@ import consulo.language.psi.PsiElement; import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.Nls; import javax.swing.*; @ExtensionImpl public class NewExceptionWithoutArgumentsInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean ignoreWithoutParameters = false; - @SuppressWarnings("PublicField") - public boolean ignoreWithoutParameters = false; - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.newExceptionWithoutArgumentsDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.newExceptionWithoutArgumentsProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.newExceptionWithoutArgumentsIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreWithoutParameters"); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.newExceptionWithoutArgumentsDisplayName(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new NewExceptionWithoutArgumentsVisitor(); - } + @Nonnull + @Override + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.newExceptionWithoutArgumentsProblemDescriptor().get(); + } - private class NewExceptionWithoutArgumentsVisitor extends BaseInspectionVisitor { + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.newExceptionWithoutArgumentsIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreWithoutParameters"); + } @Override - public void visitNewExpression(PsiNewExpression expression) { - super.visitNewExpression(expression); - final PsiExpressionList argumentList = expression.getArgumentList(); - if (argumentList == null) { - return; - } - final PsiExpression[] expressions = argumentList.getExpressions(); - if (expressions.length != 0) { - return; - } - final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); - if (classReference == null) { - return; - } - final PsiElement target = classReference.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_EXCEPTION)) { - return; - } - if (ignoreWithoutParameters) { - if (!hasAccessibleConstructorWithParameters(aClass, expression)) return; - } - registerNewExpressionError(expression); + public BaseInspectionVisitor buildVisitor() { + return new NewExceptionWithoutArgumentsVisitor(); } - private boolean hasAccessibleConstructorWithParameters(PsiClass aClass, PsiElement context) { - final PsiMethod[] constructors = aClass.getConstructors(); - for (PsiMethod constructor : constructors) { - final PsiParameterList parameterList = constructor.getParameterList(); - final int count = parameterList.getParametersCount(); - if (count <= 0) { - continue; + private class NewExceptionWithoutArgumentsVisitor extends BaseInspectionVisitor { + + @Override + public void visitNewExpression(PsiNewExpression expression) { + super.visitNewExpression(expression); + final PsiExpressionList argumentList = expression.getArgumentList(); + if (argumentList == null) { + return; + } + final PsiExpression[] expressions = argumentList.getExpressions(); + if (expressions.length != 0) { + return; + } + final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); + if (classReference == null) { + return; + } + final PsiElement target = classReference.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_EXCEPTION)) { + return; + } + if (ignoreWithoutParameters) { + if (!hasAccessibleConstructorWithParameters(aClass, expression)) { + return; + } + } + registerNewExpressionError(expression); } - final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(context.getProject()).getResolveHelper(); - if (resolveHelper.isAccessible(constructor, context, aClass)) { - return true; + + private boolean hasAccessibleConstructorWithParameters(PsiClass aClass, PsiElement context) { + final PsiMethod[] constructors = aClass.getConstructors(); + for (PsiMethod constructor : constructors) { + final PsiParameterList parameterList = constructor.getParameterList(); + final int count = parameterList.getParametersCount(); + if (count <= 0) { + continue; + } + final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(context.getProject()).getResolveHelper(); + if (resolveHelper.isAccessible(constructor, context, aClass)) { + return true; + } + } + return false; } - } - return false; } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NonFinalFieldOfExceptionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NonFinalFieldOfExceptionInspection.java index 620d84e2cd..4c7df60726 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NonFinalFieldOfExceptionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NonFinalFieldOfExceptionInspection.java @@ -26,52 +26,53 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @ExtensionImpl public class NonFinalFieldOfExceptionInspection extends BaseInspection { - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.nonFinalFieldOfExceptionDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nonFinalFieldOfExceptionDisplayName(); + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nonFinalFieldOfExceptionProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nonFinalFieldOfExceptionProblemDescriptor().get(); + } - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - final PsiField field = (PsiField)infos[0]; - return MakeFieldFinalFix.buildFix(field); - } + @Override + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + final PsiField field = (PsiField) infos[0]; + return MakeFieldFinalFix.buildFix(field); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new NonFinalFieldOfExceptionVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new NonFinalFieldOfExceptionVisitor(); + } - private static class NonFinalFieldOfExceptionVisitor - extends BaseInspectionVisitor { + private static class NonFinalFieldOfExceptionVisitor + extends BaseInspectionVisitor { - @Override - public void visitField(PsiField field) { - super.visitField(field); - if (field.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiClass containingClass = field.getContainingClass(); - if (containingClass == null) { - return; - } - if (!InheritanceUtil.isInheritor(containingClass, CommonClassNames.JAVA_LANG_EXCEPTION)) { - return; - } - registerFieldError(field, field); + @Override + public void visitField(PsiField field) { + super.visitField(field); + if (field.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiClass containingClass = field.getContainingClass(); + if (containingClass == null) { + return; + } + if (!InheritanceUtil.isInheritor(containingClass, CommonClassNames.JAVA_LANG_EXCEPTION)) { + return; + } + registerFieldError(field, field); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NullThrownInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NullThrownInspection.java index 9324ee06a6..a3a55086c8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NullThrownInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/NullThrownInspection.java @@ -25,72 +25,64 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class NullThrownInspection extends BaseInspection { - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.nullThrownDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nullThrownProblemDescriptor().get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new ThrowNullFix(); - } - - private static class ThrowNullFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nullThrownDisplayName(); + } @Nonnull @Override - public String getName() { - return InspectionGadgetsLocalize.nullThrownQuickfix().get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nullThrownProblemDescriptor().get(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElementFactory factory = - JavaPsiFacade.getElementFactory(project); - final PsiExpression newExpression = - factory.createExpressionFromText( - "new java.lang.NullPointerException()", element); - element.replace(newExpression); + protected InspectionGadgetsFix buildFix(Object... infos) { + return new ThrowNullFix(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new ThrowNullVisitor(); - } + private static class ThrowNullFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.nullThrownQuickfix(); + } - private static class ThrowNullVisitor extends BaseInspectionVisitor { + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + final PsiExpression newExpression = factory.createExpressionFromText("new java.lang.NullPointerException()", element); + element.replace(newExpression); + } + } @Override - public void visitThrowStatement(PsiThrowStatement statement) { - super.visitThrowStatement(statement); - final PsiExpression exception = - ParenthesesUtils.stripParentheses(statement.getException()); - if (!(exception instanceof PsiLiteralExpression)) { - return; - } - final PsiType type = exception.getType(); - if (!PsiType.NULL.equals(type)) { - return; - } - registerError(exception); + public BaseInspectionVisitor buildVisitor() { + return new ThrowNullVisitor(); + } + + private static class ThrowNullVisitor extends BaseInspectionVisitor { + + @Override + public void visitThrowStatement(PsiThrowStatement statement) { + super.visitThrowStatement(statement); + final PsiExpression exception = ParenthesesUtils.stripParentheses(statement.getException()); + if (!(exception instanceof PsiLiteralExpression)) { + return; + } + final PsiType type = exception.getType(); + if (!PsiType.NULL.equals(type)) { + return; + } + registerError(exception); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ReturnFromFinallyBlockInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ReturnFromFinallyBlockInspection.java index d6f6e871be..2de4329e89 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ReturnFromFinallyBlockInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ReturnFromFinallyBlockInspection.java @@ -21,43 +21,47 @@ import com.siyeh.ig.psiutils.ControlFlowUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class ReturnFromFinallyBlockInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "ReturnInsideFinallyBlock"; + } - @Nonnull - public String getID() { - return "ReturnInsideFinallyBlock"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.returnFromFinallyBlockDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.returnFromFinallyBlockDisplayName(); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.returnFromFinallyBlockProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.returnFromFinallyBlockProblemDescriptor().get(); + } - public boolean isEnabledByDefault() { - return true; - } + public boolean isEnabledByDefault() { + return true; + } - public BaseInspectionVisitor buildVisitor() { - return new ReturnFromFinallyBlockVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new ReturnFromFinallyBlockVisitor(); + } - private static class ReturnFromFinallyBlockVisitor extends BaseInspectionVisitor { + private static class ReturnFromFinallyBlockVisitor extends BaseInspectionVisitor { - @Override - public void visitReturnStatement(@Nonnull PsiReturnStatement statement) { - super.visitReturnStatement(statement); - if (!ControlFlowUtils.isInFinallyBlock(statement)) { - return; - } - registerStatementError(statement); + @Override + public void visitReturnStatement(@Nonnull PsiReturnStatement statement) { + super.visitReturnStatement(statement); + if (!ControlFlowUtils.isInFinallyBlock(statement)) { + return; + } + registerStatementError(statement); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThreadDeathRethrownInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThreadDeathRethrownInspection.java index d7e8a4525c..a0b8c211e7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThreadDeathRethrownInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThreadDeathRethrownInspection.java @@ -23,77 +23,83 @@ import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class ThreadDeathRethrownInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "ThreadDeathNotRethrown"; + } - @Nonnull - public String getID() { - return "ThreadDeathNotRethrown"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.threadDeathRethrownDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.threadDeathRethrownDisplayName(); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.threadDeathRethrownProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.threadDeathRethrownProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new ThreadDeathRethrownVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new ThreadDeathRethrownVisitor(); + } - private static class ThreadDeathRethrownVisitor - extends BaseInspectionVisitor { + private static class ThreadDeathRethrownVisitor + extends BaseInspectionVisitor { - @Override - public void visitTryStatement(@Nonnull PsiTryStatement statement) { - super.visitTryStatement(statement); - final PsiCatchSection[] catchSections = statement.getCatchSections(); - for (PsiCatchSection catchSection : catchSections) { - final PsiParameter parameter = catchSection.getParameter(); - final PsiCodeBlock catchBlock = - catchSection.getCatchBlock(); - if (parameter != null && catchBlock != null) { - checkCatchBlock(parameter, catchBlock); + @Override + public void visitTryStatement(@Nonnull PsiTryStatement statement) { + super.visitTryStatement(statement); + final PsiCatchSection[] catchSections = statement.getCatchSections(); + for (PsiCatchSection catchSection : catchSections) { + final PsiParameter parameter = catchSection.getParameter(); + final PsiCodeBlock catchBlock = + catchSection.getCatchBlock(); + if (parameter != null && catchBlock != null) { + checkCatchBlock(parameter, catchBlock); + } + } } - } - } - private void checkCatchBlock(PsiParameter parameter, - PsiCodeBlock catchBlock) { - final PsiType type = parameter.getType(); - if (!TypeUtils.typeEquals("java.lang.ThreadDeath", type)) { - return; - } - final PsiTypeElement typeElement = parameter.getTypeElement(); - final PsiStatement[] statements = catchBlock.getStatements(); - if (statements.length == 0) { - registerError(typeElement); - return; - } - final PsiStatement lastStatement = - statements[statements.length - 1]; - if (!(lastStatement instanceof PsiThrowStatement)) { - registerError(typeElement); - return; - } - final PsiThrowStatement throwStatement = - (PsiThrowStatement)lastStatement; - final PsiExpression exception = throwStatement.getException(); - if (!(exception instanceof PsiReferenceExpression)) { - registerError(typeElement); - return; - } - final PsiElement element = ((PsiReference)exception).resolve(); - if (parameter.equals(element)) { - return; - } - registerError(typeElement); + private void checkCatchBlock( + PsiParameter parameter, + PsiCodeBlock catchBlock + ) { + final PsiType type = parameter.getType(); + if (!TypeUtils.typeEquals("java.lang.ThreadDeath", type)) { + return; + } + final PsiTypeElement typeElement = parameter.getTypeElement(); + final PsiStatement[] statements = catchBlock.getStatements(); + if (statements.length == 0) { + registerError(typeElement); + return; + } + final PsiStatement lastStatement = + statements[statements.length - 1]; + if (!(lastStatement instanceof PsiThrowStatement)) { + registerError(typeElement); + return; + } + final PsiThrowStatement throwStatement = + (PsiThrowStatement) lastStatement; + final PsiExpression exception = throwStatement.getException(); + if (!(exception instanceof PsiReferenceExpression)) { + registerError(typeElement); + return; + } + final PsiElement element = ((PsiReference) exception).resolve(); + if (parameter.equals(element)) { + return; + } + registerError(typeElement); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowCaughtLocallyInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowCaughtLocallyInspection.java index 8710b10355..fd08d8d318 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowCaughtLocallyInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowCaughtLocallyInspection.java @@ -16,15 +16,14 @@ package com.intellij.java.impl.ig.errorhandling; import com.intellij.java.language.psi.*; -import com.siyeh.localize.InspectionGadgetsLocalize; -import consulo.annotation.component.ExtensionImpl; -import consulo.language.psi.*; -import consulo.language.psi.util.PsiTreeUtil; -import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.psiutils.ClassUtils; +import com.siyeh.localize.InspectionGadgetsLocalize; +import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; +import consulo.language.psi.PsiElement; +import consulo.language.psi.util.PsiTreeUtil; import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -33,108 +32,115 @@ @ExtensionImpl public class ThrowCaughtLocallyInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean ignoreRethrownExceptions = false; - /** - * @noinspection PublicField - */ - public boolean ignoreRethrownExceptions = false; - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.throwCaughtLocallyDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.throwCaughtLocallyDisplayName(); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.throwCaughtLocallyProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.throwCaughtLocallyProblemDescriptor().get(); + } - @Nullable - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.throwCaughtLocallyIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreRethrownExceptions"); - } + @Nullable + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.throwCaughtLocallyIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreRethrownExceptions"); + } - public BaseInspectionVisitor buildVisitor() { - return new ThrowCaughtLocallyVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new ThrowCaughtLocallyVisitor(); + } - private class ThrowCaughtLocallyVisitor - extends BaseInspectionVisitor { + private class ThrowCaughtLocallyVisitor + extends BaseInspectionVisitor { - @Override - public void visitThrowStatement(PsiThrowStatement statement) { - super.visitThrowStatement(statement); - final PsiExpression exception = statement.getException(); - if (exception == null) { - return; - } - final PsiType exceptionType = exception.getType(); - if (exceptionType == null) { - return; - } - PsiTryStatement containingTryStatement = - PsiTreeUtil.getParentOfType(statement, - PsiTryStatement.class); - while (containingTryStatement != null) { - final PsiCodeBlock tryBlock = - containingTryStatement.getTryBlock(); - if (tryBlock == null) { - return; - } - if (PsiTreeUtil.isAncestor(tryBlock, statement, true)) { - final PsiParameter[] catchBlockParameters = - containingTryStatement.getCatchBlockParameters(); - for (PsiParameter parameter : catchBlockParameters) { - final PsiType parameterType = parameter.getType(); - if (!parameterType.isAssignableFrom(exceptionType)) { - continue; + @Override + public void visitThrowStatement(PsiThrowStatement statement) { + super.visitThrowStatement(statement); + final PsiExpression exception = statement.getException(); + if (exception == null) { + return; } - if (ignoreRethrownExceptions) { - final PsiCatchSection section = - (PsiCatchSection)parameter.getParent(); - final PsiCodeBlock catchBlock = - section.getCatchBlock(); - if (isExceptionRethrown(parameter, catchBlock)) { + final PsiType exceptionType = exception.getType(); + if (exceptionType == null) { return; - } } - final PsiClass containingClass = - ClassUtils.getContainingClass(statement); - if (PsiTreeUtil.isAncestor(containingClass, - containingTryStatement, true)) { - registerStatementError(statement); - return; + PsiTryStatement containingTryStatement = + PsiTreeUtil.getParentOfType( + statement, + PsiTryStatement.class + ); + while (containingTryStatement != null) { + final PsiCodeBlock tryBlock = + containingTryStatement.getTryBlock(); + if (tryBlock == null) { + return; + } + if (PsiTreeUtil.isAncestor(tryBlock, statement, true)) { + final PsiParameter[] catchBlockParameters = + containingTryStatement.getCatchBlockParameters(); + for (PsiParameter parameter : catchBlockParameters) { + final PsiType parameterType = parameter.getType(); + if (!parameterType.isAssignableFrom(exceptionType)) { + continue; + } + if (ignoreRethrownExceptions) { + final PsiCatchSection section = + (PsiCatchSection) parameter.getParent(); + final PsiCodeBlock catchBlock = + section.getCatchBlock(); + if (isExceptionRethrown(parameter, catchBlock)) { + return; + } + } + final PsiClass containingClass = + ClassUtils.getContainingClass(statement); + if (PsiTreeUtil.isAncestor(containingClass, + containingTryStatement, true + )) { + registerStatementError(statement); + return; + } + } + } + containingTryStatement = + PsiTreeUtil.getParentOfType( + containingTryStatement, + PsiTryStatement.class + ); } - } } - containingTryStatement = - PsiTreeUtil.getParentOfType(containingTryStatement, - PsiTryStatement.class); - } - } - private boolean isExceptionRethrown(PsiParameter parameter, - PsiCodeBlock catchBlock) { - final PsiStatement[] statements = catchBlock.getStatements(); - if (statements.length <= 0) { - return false; - } - final PsiStatement lastStatement = - statements[statements.length - 1]; - if (!(lastStatement instanceof PsiThrowStatement)) { - return false; - } - final PsiThrowStatement throwStatement = - (PsiThrowStatement)lastStatement; - final PsiExpression expression = throwStatement.getException(); - if (!(expression instanceof PsiReferenceExpression)) { - return false; - } - final PsiReferenceExpression referenceExpression = - (PsiReferenceExpression)expression; - final PsiElement element = referenceExpression.resolve(); - return parameter.equals(element); + private boolean isExceptionRethrown( + PsiParameter parameter, + PsiCodeBlock catchBlock + ) { + final PsiStatement[] statements = catchBlock.getStatements(); + if (statements.length <= 0) { + return false; + } + final PsiStatement lastStatement = + statements[statements.length - 1]; + if (!(lastStatement instanceof PsiThrowStatement)) { + return false; + } + final PsiThrowStatement throwStatement = + (PsiThrowStatement) lastStatement; + final PsiExpression expression = throwStatement.getException(); + if (!(expression instanceof PsiReferenceExpression)) { + return false; + } + final PsiReferenceExpression referenceExpression = + (PsiReferenceExpression) expression; + final PsiElement element = referenceExpression.resolve(); + return parameter.equals(element); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowFromFinallyBlockInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowFromFinallyBlockInspection.java index c6abcab4fc..372138f133 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowFromFinallyBlockInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowFromFinallyBlockInspection.java @@ -21,39 +21,40 @@ import com.siyeh.ig.psiutils.ControlFlowUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class ThrowFromFinallyBlockInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.throwFromFinallyBlockDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.throwFromFinallyBlockDisplayName().get(); - } - - public boolean isEnabledByDefault() { - return true; - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.throwFromFinallyBlockProblemDescriptor().get(); - } + public boolean isEnabledByDefault() { + return true; + } - public BaseInspectionVisitor buildVisitor() { - return new ThrowFromFinallyBlockVisitor(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.throwFromFinallyBlockProblemDescriptor().get(); + } - private static class ThrowFromFinallyBlockVisitor - extends BaseInspectionVisitor { + public BaseInspectionVisitor buildVisitor() { + return new ThrowFromFinallyBlockVisitor(); + } - @Override - public void visitThrowStatement(PsiThrowStatement statement) { - super.visitThrowStatement(statement); - if (!ControlFlowUtils.isInFinallyBlock(statement)) { - return; - } - registerStatementError(statement); + private static class ThrowFromFinallyBlockVisitor + extends BaseInspectionVisitor { + + @Override + public void visitThrowStatement(PsiThrowStatement statement) { + super.visitThrowStatement(statement); + if (!ControlFlowUtils.isInFinallyBlock(statement)) { + return; + } + registerStatementError(statement); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowsRuntimeExceptionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowsRuntimeExceptionInspection.java index eaa6d09069..cdafb26aa6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowsRuntimeExceptionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/ThrowsRuntimeExceptionInspection.java @@ -33,173 +33,176 @@ import consulo.language.psi.PsiComment; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class ThrowsRuntimeExceptionInspection extends BaseInspection { - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.throwsRuntimeExceptionDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.throwsRuntimeExceptionProblemDescriptor().get(); - } - - @Nonnull - @Override - protected InspectionGadgetsFix[] buildFixes(Object... infos) { - final String exceptionName = (String)infos[0]; - if (MoveExceptionToJavadocFix.isApplicable((PsiJavaCodeReferenceElement)infos[1])) { - return new InspectionGadgetsFix[] { - new ThrowsRuntimeExceptionFix(exceptionName), - new MoveExceptionToJavadocFix(exceptionName) - }; - } - return new InspectionGadgetsFix[] {new ThrowsRuntimeExceptionFix(exceptionName)}; - } - - private static class MoveExceptionToJavadocFix extends InspectionGadgetsFix { - - private final String myExceptionName; - - private MoveExceptionToJavadocFix(String exceptionName) { - myExceptionName = exceptionName; + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.throwsRuntimeExceptionDisplayName(); } @Nonnull @Override - public String getName() { - return InspectionGadgetsLocalize.throwsRuntimeExceptionMoveQuickfix(myExceptionName).get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.throwsRuntimeExceptionProblemDescriptor().get(); } + @Nonnull @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 PsiMethod)) { - return; - } - final PsiMethod method = (PsiMethod)grandParent; - final PsiDocComment comment = method.getDocComment(); - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - if (comment != null) { - final PsiDocTag docTag = factory.createDocTagFromText("@throws " + element.getText()); - comment.add(docTag); - } - else { - final PsiDocComment docComment = factory.createDocCommentFromText("/** */"); - final PsiComment resultComment = (PsiComment)method.addBefore(docComment, method.getModifierList()); - final DocumentationProvider documentationProvider = LanguageDocumentationProvider.forLanguageComposite(method.getLanguage()); - final CodeDocumentationProvider codeDocumentationProvider; - if (documentationProvider instanceof CodeDocumentationProvider) { - codeDocumentationProvider = (CodeDocumentationProvider)documentationProvider; - } else if (documentationProvider instanceof CompositeDocumentationProvider) { - final CompositeDocumentationProvider compositeDocumentationProvider = (CompositeDocumentationProvider)documentationProvider; - codeDocumentationProvider = compositeDocumentationProvider.getFirstCodeDocumentationProvider(); - if (codeDocumentationProvider == null) { - return; - } - } else { - return; + protected InspectionGadgetsFix[] buildFixes(Object... infos) { + final String exceptionName = (String) infos[0]; + if (MoveExceptionToJavadocFix.isApplicable((PsiJavaCodeReferenceElement) infos[1])) { + return new InspectionGadgetsFix[]{ + new ThrowsRuntimeExceptionFix(exceptionName), + new MoveExceptionToJavadocFix(exceptionName) + }; } - final String commentStub = codeDocumentationProvider.generateDocumentationContentStub(resultComment); - final PsiDocComment newComment = factory.createDocCommentFromText("/**\n" + commentStub + "*/"); - resultComment.replace(newComment); - } - element.delete(); + return new InspectionGadgetsFix[]{new ThrowsRuntimeExceptionFix(exceptionName)}; } - public static boolean isApplicable(@Nonnull PsiJavaCodeReferenceElement reference) { - final PsiElement parent = reference.getParent(); - final PsiElement grandParent = parent.getParent(); - if (!(grandParent instanceof PsiMethod)) { - return false; - } - final PsiMethod method = (PsiMethod)grandParent; - final PsiDocComment docComment = method.getDocComment(); - if (docComment == null) { - return true; - } - final PsiElement throwsTarget = reference.resolve(); - if (throwsTarget == null) { - return true; - } - final PsiDocTag[] tags = docComment.findTagsByName("throws"); - for (PsiDocTag tag : tags) { - final PsiDocTagValue valueElement = tag.getValueElement(); - if (valueElement == null) { - continue; + private static class MoveExceptionToJavadocFix extends InspectionGadgetsFix { + + private final String myExceptionName; + + private MoveExceptionToJavadocFix(String exceptionName) { + myExceptionName = exceptionName; } - final PsiElement child = valueElement.getFirstChild(); - if (child == null) { - continue; + + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.throwsRuntimeExceptionMoveQuickfix(myExceptionName); } - final PsiElement grandChild = child.getFirstChild(); - if (!(grandChild instanceof PsiJavaCodeReferenceElement)) { - continue; + + @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 PsiMethod)) { + return; + } + final PsiMethod method = (PsiMethod) grandParent; + final PsiDocComment comment = method.getDocComment(); + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + if (comment != null) { + final PsiDocTag docTag = factory.createDocTagFromText("@throws " + element.getText()); + comment.add(docTag); + } + else { + final PsiDocComment docComment = factory.createDocCommentFromText("/** */"); + final PsiComment resultComment = (PsiComment) method.addBefore(docComment, method.getModifierList()); + final DocumentationProvider documentationProvider = + LanguageDocumentationProvider.forLanguageComposite(method.getLanguage()); + final CodeDocumentationProvider codeDocumentationProvider; + if (documentationProvider instanceof CodeDocumentationProvider) { + codeDocumentationProvider = (CodeDocumentationProvider) documentationProvider; + } + else if (documentationProvider instanceof CompositeDocumentationProvider) { + final CompositeDocumentationProvider compositeDocumentationProvider = + (CompositeDocumentationProvider) documentationProvider; + codeDocumentationProvider = compositeDocumentationProvider.getFirstCodeDocumentationProvider(); + if (codeDocumentationProvider == null) { + return; + } + } + else { + return; + } + final String commentStub = codeDocumentationProvider.generateDocumentationContentStub(resultComment); + final PsiDocComment newComment = factory.createDocCommentFromText("/**\n" + commentStub + "*/"); + resultComment.replace(newComment); + } + element.delete(); } - final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)grandChild; - final PsiElement target = referenceElement.resolve(); - if (throwsTarget.equals(target)) { - return false; + + public static boolean isApplicable(@Nonnull PsiJavaCodeReferenceElement reference) { + final PsiElement parent = reference.getParent(); + final PsiElement grandParent = parent.getParent(); + if (!(grandParent instanceof PsiMethod)) { + return false; + } + final PsiMethod method = (PsiMethod) grandParent; + final PsiDocComment docComment = method.getDocComment(); + if (docComment == null) { + return true; + } + final PsiElement throwsTarget = reference.resolve(); + if (throwsTarget == null) { + return true; + } + final PsiDocTag[] tags = docComment.findTagsByName("throws"); + for (PsiDocTag tag : tags) { + final PsiDocTagValue valueElement = tag.getValueElement(); + if (valueElement == null) { + continue; + } + final PsiElement child = valueElement.getFirstChild(); + if (child == null) { + continue; + } + final PsiElement grandChild = child.getFirstChild(); + if (!(grandChild instanceof PsiJavaCodeReferenceElement)) { + continue; + } + final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) grandChild; + final PsiElement target = referenceElement.resolve(); + if (throwsTarget.equals(target)) { + return false; + } + } + return true; } - } - return true; } - } - private static class ThrowsRuntimeExceptionFix extends InspectionGadgetsFix { + private static class ThrowsRuntimeExceptionFix extends InspectionGadgetsFix { - private final String myClassName; + private final String myClassName; - public ThrowsRuntimeExceptionFix(String className) { - myClassName = className; - } + public ThrowsRuntimeExceptionFix(String className) { + myClassName = className; + } - @Nonnull - @Override - public String getName() { - return InspectionGadgetsLocalize.throwsRuntimeExceptionQuickfix(myClassName).get(); + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.throwsRuntimeExceptionQuickfix(myClassName); + } + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + descriptor.getPsiElement().delete(); + } } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - descriptor.getPsiElement().delete(); + public BaseInspectionVisitor buildVisitor() { + return new ThrowsRuntimeExceptionVisitor(); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new ThrowsRuntimeExceptionVisitor(); - } - - private static class ThrowsRuntimeExceptionVisitor extends BaseInspectionVisitor { - @Override - public void visitMethod(PsiMethod method) { - super.visitMethod(method); - final PsiReferenceList throwsList = method.getThrowsList(); - final PsiJavaCodeReferenceElement[] referenceElements = throwsList.getReferenceElements(); - for (PsiJavaCodeReferenceElement referenceElement : referenceElements) { - final PsiElement target = referenceElement.resolve(); - if (!(target instanceof PsiClass)) { - continue; - } - final PsiClass aClass = (PsiClass)target; - if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION)) { - continue; + private static class ThrowsRuntimeExceptionVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + final PsiReferenceList throwsList = method.getThrowsList(); + final PsiJavaCodeReferenceElement[] referenceElements = throwsList.getReferenceElements(); + for (PsiJavaCodeReferenceElement referenceElement : referenceElements) { + final PsiElement target = referenceElement.resolve(); + if (!(target instanceof PsiClass)) { + continue; + } + final PsiClass aClass = (PsiClass) target; + if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION)) { + continue; + } + final String className = aClass.getName(); + registerError(referenceElement, className, referenceElement); + } } - final String className = aClass.getName(); - registerError(referenceElement, className, referenceElement); - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadCatchInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadCatchInspection.java index f779ec9491..ba5eed0f65 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadCatchInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadCatchInspection.java @@ -35,236 +35,238 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.*; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; import javax.swing.*; import java.util.*; @ExtensionImpl public class TooBroadCatchInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean onlyWarnOnRootExceptions = false; - @SuppressWarnings({"PublicField"}) - public boolean onlyWarnOnRootExceptions = false; + @SuppressWarnings("PublicField") + public boolean ignoreInTestCode = false; - @SuppressWarnings("PublicField") - public boolean ignoreInTestCode = false; + @SuppressWarnings("PublicField") + public boolean ignoreThrown = false; - @SuppressWarnings("PublicField") - public boolean ignoreThrown = false; - - @Override - @Nonnull - public String getID() { - return "OverlyBroadCatchBlock"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.tooBroadCatchDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final List typesMasked = (List)infos[0]; - String typesMaskedString = typesMasked.get(0).getName(); - if (typesMasked.size() == 1) { - return InspectionGadgetsLocalize.tooBroadCatchProblemDescriptor(typesMaskedString).get(); - } - else { - //Collections.sort(typesMasked); - final int lastTypeIndex = typesMasked.size() - 1; - for (int i = 1; i < lastTypeIndex; i++) { - typesMaskedString += ", "; - typesMaskedString += typesMasked.get(i).getName(); - } - final String lastTypeString = typesMasked.get(lastTypeIndex).getName(); - return InspectionGadgetsLocalize.tooBroadCatchProblemDescriptor1(typesMaskedString, lastTypeString).get(); - } - } - - @Nonnull - @Override - protected InspectionGadgetsFix[] buildFixes(Object... infos) { - final List maskedTypes = (List)infos[0]; - final List fixes = new ArrayList(); - for (PsiClass thrown : maskedTypes) { - fixes.add(new AddCatchSectionFix(thrown)); + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "OverlyBroadCatchBlock"; } - return fixes.toArray(new InspectionGadgetsFix[fixes.size()]); - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); - panel.addCheckbox(InspectionGadgetsLocalize.tooBroadCatchOption().get(), "onlyWarnOnRootExceptions"); - panel.addCheckbox(InspectionGadgetsBundle.message("ignore.in.test.code"), "ignoreInTestCode"); - panel.addCheckbox(InspectionGadgetsLocalize.overlyBroadThrowsClauseIgnoreThrownOption().get(), "ignoreThrown"); - return panel; - } - - private static class AddCatchSectionFix extends InspectionGadgetsFix { - private final SmartPsiElementPointer myThrown; - private final String myText; - - AddCatchSectionFix(PsiClass thrown) { - myThrown = SmartPointerManager.getInstance(thrown.getProject()).createSmartPsiElementPointer(thrown); - myText = thrown.getName(); + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.tooBroadCatchDisplayName(); } @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.tooBroadCatchQuickfix(myText).get(); + protected String buildErrorString(Object... infos) { + final List typesMasked = (List) infos[0]; + String typesMaskedString = typesMasked.get(0).getName(); + if (typesMasked.size() == 1) { + return InspectionGadgetsLocalize.tooBroadCatchProblemDescriptor(typesMaskedString).get(); + } + else { + //Collections.sort(typesMasked); + final int lastTypeIndex = typesMasked.size() - 1; + for (int i = 1; i < lastTypeIndex; i++) { + typesMaskedString += ", "; + typesMaskedString += typesMasked.get(i).getName(); + } + final String lastTypeString = typesMasked.get(lastTypeIndex).getName(); + return InspectionGadgetsLocalize.tooBroadCatchProblemDescriptor1(typesMaskedString, lastTypeString).get(); + } } + @Nonnull @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement typeElement = descriptor.getPsiElement(); - if (typeElement == null) { - return; - } - final PsiElement catchParameter = typeElement.getParent(); - if (!(catchParameter instanceof PsiParameter)) { - return; - } - final PsiElement catchBlock = ((PsiParameter)catchParameter).getDeclarationScope(); - if (!(catchBlock instanceof PsiCatchSection)) { - return; - } - final PsiCatchSection myBeforeCatchSection = (PsiCatchSection)catchBlock; - final PsiTryStatement myTryStatement = myBeforeCatchSection.getTryStatement(); - final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project); - final String name = codeStyleManager.suggestUniqueVariableName("e", myTryStatement.getTryBlock(), false); - final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - final PsiClass aClass = myThrown.getElement(); - if (aClass == null) { - return; - } - final PsiCatchSection section = factory.createCatchSection(factory.createType(aClass), name, myTryStatement); - final PsiCatchSection element = (PsiCatchSection)myTryStatement.addBefore(section, myBeforeCatchSection); - codeStyleManager.shortenClassReferences(element); - - if (isOnTheFly()) { - final TextRange range = getRangeToSelect(element.getCatchBlock()); - final PsiFile file = element.getContainingFile(); - final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); - if (editor == null) { - return; + protected InspectionGadgetsFix[] buildFixes(Object... infos) { + final List maskedTypes = (List) infos[0]; + final List fixes = new ArrayList(); + for (PsiClass thrown : maskedTypes) { + fixes.add(new AddCatchSectionFix(thrown)); } - final Document document = PsiDocumentManager.getInstance(project).getDocument(file); - if (editor.getDocument() != document) { - return; - } - editor.getCaretModel().moveToOffset(range.getStartOffset()); - editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); - editor.getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset()); - } + return fixes.toArray(new InspectionGadgetsFix[fixes.size()]); } - } - private static TextRange getRangeToSelect(PsiCodeBlock block) { - PsiElement first = block.getFirstBodyElement(); - if (first instanceof PsiWhiteSpace) { - first = first.getNextSibling(); - } - if (first == null) { - final int offset = block.getTextRange().getStartOffset() + 1; - return new TextRange(offset, offset); - } - PsiElement last = block.getLastBodyElement(); - if (last instanceof PsiWhiteSpace) { - last = last.getPrevSibling(); - } - final TextRange textRange; - if (last == null) { - textRange = first.getTextRange(); - } - else { - textRange = last.getTextRange(); + @Override + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); + panel.addCheckbox(InspectionGadgetsLocalize.tooBroadCatchOption().get(), "onlyWarnOnRootExceptions"); + panel.addCheckbox(InspectionGadgetsBundle.message("ignore.in.test.code"), "ignoreInTestCode"); + panel.addCheckbox(InspectionGadgetsLocalize.overlyBroadThrowsClauseIgnoreThrownOption().get(), "ignoreThrown"); + return panel; } - return new TextRange(first.getTextRange().getStartOffset(), textRange.getEndOffset()); - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new TooBroadCatchVisitor(); - } + private static class AddCatchSectionFix extends InspectionGadgetsFix { - private class TooBroadCatchVisitor extends BaseInspectionVisitor { + private final SmartPsiElementPointer myThrown; + private final String myText; - @Override - public void visitTryStatement(@Nonnull PsiTryStatement statement) { - super.visitTryStatement(statement); - final PsiCodeBlock tryBlock = statement.getTryBlock(); - if (tryBlock == null) { - return; - } - if (ignoreInTestCode && TestUtils.isInTestCode(statement)) { - return; - } - final Set exceptionsThrown = ExceptionUtils.calculateExceptionsThrown(tryBlock); - final int numExceptionsThrown = exceptionsThrown.size(); - final Set exceptionsCaught = new HashSet(numExceptionsThrown); - final PsiCatchSection[] catchSections = statement.getCatchSections(); - for (final PsiCatchSection catchSection : catchSections) { - final PsiParameter parameter = catchSection.getParameter(); - if (parameter == null) { - continue; + AddCatchSectionFix(PsiClass thrown) { + myThrown = SmartPointerManager.getInstance(thrown.getProject()).createSmartPsiElementPointer(thrown); + myText = thrown.getName(); } - final PsiType typeCaught = parameter.getType(); - if (typeCaught instanceof PsiDisjunctionType) { - final PsiDisjunctionType disjunctionType = (PsiDisjunctionType)typeCaught; - final List types = disjunctionType.getDisjunctions(); - for (PsiType type : types) { - check(exceptionsThrown, exceptionsCaught, parameter, type); - } + + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.tooBroadCatchQuickfix(myText); + } + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement typeElement = descriptor.getPsiElement(); + if (typeElement == null) { + return; + } + final PsiElement catchParameter = typeElement.getParent(); + if (!(catchParameter instanceof PsiParameter)) { + return; + } + final PsiElement catchBlock = ((PsiParameter) catchParameter).getDeclarationScope(); + if (!(catchBlock instanceof PsiCatchSection)) { + return; + } + final PsiCatchSection myBeforeCatchSection = (PsiCatchSection) catchBlock; + final PsiTryStatement myTryStatement = myBeforeCatchSection.getTryStatement(); + final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project); + final String name = codeStyleManager.suggestUniqueVariableName("e", myTryStatement.getTryBlock(), false); + final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + final PsiClass aClass = myThrown.getElement(); + if (aClass == null) { + return; + } + final PsiCatchSection section = factory.createCatchSection(factory.createType(aClass), name, myTryStatement); + final PsiCatchSection element = (PsiCatchSection) myTryStatement.addBefore(section, myBeforeCatchSection); + codeStyleManager.shortenClassReferences(element); + + if (isOnTheFly()) { + final TextRange range = getRangeToSelect(element.getCatchBlock()); + final PsiFile file = element.getContainingFile(); + final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor(); + if (editor == null) { + return; + } + final Document document = PsiDocumentManager.getInstance(project).getDocument(file); + if (editor.getDocument() != document) { + return; + } + editor.getCaretModel().moveToOffset(range.getStartOffset()); + editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); + editor.getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset()); + } + } + } + + private static TextRange getRangeToSelect(PsiCodeBlock block) { + PsiElement first = block.getFirstBodyElement(); + if (first instanceof PsiWhiteSpace) { + first = first.getNextSibling(); + } + if (first == null) { + final int offset = block.getTextRange().getStartOffset() + 1; + return new TextRange(offset, offset); + } + PsiElement last = block.getLastBodyElement(); + if (last instanceof PsiWhiteSpace) { + last = last.getPrevSibling(); + } + final TextRange textRange; + if (last == null) { + textRange = first.getTextRange(); } else { - check(exceptionsThrown, exceptionsCaught, parameter, typeCaught); + textRange = last.getTextRange(); } - } + return new TextRange(first.getTextRange().getStartOffset(), textRange.getEndOffset()); } - private void check(Set exceptionsThrown, Set exceptionsCaught, PsiParameter parameter, PsiType type) { - final List maskedExceptions = findMaskedExceptions(exceptionsThrown, exceptionsCaught, type); - if (maskedExceptions.isEmpty()) { - return; - } - final PsiTypeElement typeElement = parameter.getTypeElement(); - if (typeElement == null) { - return; - } - registerError(typeElement, maskedExceptions); + @Override + public BaseInspectionVisitor buildVisitor() { + return new TooBroadCatchVisitor(); } - private List findMaskedExceptions(Set exceptionsThrown, Set exceptionsCaught, PsiType typeCaught) { - if (exceptionsThrown.contains(typeCaught)) { - if (ignoreThrown) { - return Collections.emptyList(); + private class TooBroadCatchVisitor extends BaseInspectionVisitor { + + @Override + public void visitTryStatement(@Nonnull PsiTryStatement statement) { + super.visitTryStatement(statement); + final PsiCodeBlock tryBlock = statement.getTryBlock(); + if (tryBlock == null) { + return; + } + if (ignoreInTestCode && TestUtils.isInTestCode(statement)) { + return; + } + final Set exceptionsThrown = ExceptionUtils.calculateExceptionsThrown(tryBlock); + final int numExceptionsThrown = exceptionsThrown.size(); + final Set exceptionsCaught = new HashSet(numExceptionsThrown); + final PsiCatchSection[] catchSections = statement.getCatchSections(); + for (final PsiCatchSection catchSection : catchSections) { + final PsiParameter parameter = catchSection.getParameter(); + if (parameter == null) { + continue; + } + final PsiType typeCaught = parameter.getType(); + if (typeCaught instanceof PsiDisjunctionType) { + final PsiDisjunctionType disjunctionType = (PsiDisjunctionType) typeCaught; + final List types = disjunctionType.getDisjunctions(); + for (PsiType type : types) { + check(exceptionsThrown, exceptionsCaught, parameter, type); + } + } + else { + check(exceptionsThrown, exceptionsCaught, parameter, typeCaught); + } + } } - exceptionsCaught.add(typeCaught); - exceptionsThrown.remove(typeCaught); - } - if (onlyWarnOnRootExceptions) { - if (!ExceptionUtils.isGenericExceptionClass(typeCaught)) { - return Collections.emptyList(); + + private void check(Set exceptionsThrown, Set exceptionsCaught, PsiParameter parameter, PsiType type) { + final List maskedExceptions = findMaskedExceptions(exceptionsThrown, exceptionsCaught, type); + if (maskedExceptions.isEmpty()) { + return; + } + final PsiTypeElement typeElement = parameter.getTypeElement(); + if (typeElement == null) { + return; + } + registerError(typeElement, maskedExceptions); } - } - final List typesMasked = new ArrayList(); - for (PsiClassType typeThrown : exceptionsThrown) { - if (!exceptionsCaught.contains(typeThrown) && typeCaught.isAssignableFrom(typeThrown)) { - exceptionsCaught.add(typeThrown); - final PsiClass aClass = typeThrown.resolve(); - if (aClass != null) { - typesMasked.add(aClass); - } + + private List findMaskedExceptions(Set exceptionsThrown, Set exceptionsCaught, PsiType typeCaught) { + if (exceptionsThrown.contains(typeCaught)) { + if (ignoreThrown) { + return Collections.emptyList(); + } + exceptionsCaught.add(typeCaught); + exceptionsThrown.remove(typeCaught); + } + if (onlyWarnOnRootExceptions) { + if (!ExceptionUtils.isGenericExceptionClass(typeCaught)) { + return Collections.emptyList(); + } + } + final List typesMasked = new ArrayList(); + for (PsiClassType typeThrown : exceptionsThrown) { + if (!exceptionsCaught.contains(typeThrown) && typeCaught.isAssignableFrom(typeThrown)) { + exceptionsCaught.add(typeThrown); + final PsiClass aClass = typeThrown.resolve(); + if (aClass != null) { + typesMasked.add(aClass); + } + } + } + return typesMasked; } - } - return typesMasked; } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadThrowsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadThrowsInspection.java index f51c0fbecd..c813d66305 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadThrowsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/TooBroadThrowsInspection.java @@ -28,6 +28,7 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; @@ -36,170 +37,169 @@ import java.util.*; public abstract class TooBroadThrowsInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean onlyWarnOnRootExceptions = false; - @SuppressWarnings({"PublicField"}) - public boolean onlyWarnOnRootExceptions = false; - - @SuppressWarnings("PublicField") - public boolean ignoreInTestCode = false; - - @SuppressWarnings("PublicField") - public boolean ignoreLibraryOverrides = false; - - @SuppressWarnings("PublicField") - public boolean ignoreThrown = false; - - @Override - @Nonnull - public String getID() { - return "OverlyBroadThrowsClause"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.overlyBroadThrowsClauseDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final List typesMasked = (List)infos[0]; - final PsiType type = typesMasked.get(0).getType(); - String typesMaskedString = type != null ? type.getPresentableText() : ""; - if (typesMasked.size() == 1) { - return InspectionGadgetsLocalize.overlyBroadThrowsClauseProblemDescriptor1(typesMaskedString).get(); - } - else { - final int lastTypeIndex = typesMasked.size() - 1; - for (int i = 1; i < lastTypeIndex; i++) { - final PsiType psiType = typesMasked.get(i).getType(); - if (psiType != null) { - typesMaskedString += ", "; - typesMaskedString += psiType.getPresentableText(); - } - } - final PsiType psiType = typesMasked.get(lastTypeIndex).getType(); - final String lastTypeString = psiType != null ? psiType.getPresentableText() : ""; - return InspectionGadgetsLocalize.overlyBroadThrowsClauseProblemDescriptor2(typesMaskedString, lastTypeString).get(); + @SuppressWarnings("PublicField") + public boolean ignoreInTestCode = false; + + @SuppressWarnings("PublicField") + public boolean ignoreLibraryOverrides = false; + + @SuppressWarnings("PublicField") + public boolean ignoreThrown = false; + + @Override + @Nonnull + public String getID() { + return "OverlyBroadThrowsClause"; } - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); - panel.addCheckbox(InspectionGadgetsLocalize.tooBroadCatchOption().get(), "onlyWarnOnRootExceptions"); - panel.addCheckbox(InspectionGadgetsBundle.message("ignore.exceptions.declared.in.tests.option"), "ignoreInTestCode"); - panel.addCheckbox(InspectionGadgetsLocalize.ignoreExceptionsDeclaredOnLibraryOverrideOption().get(), "ignoreLibraryOverrides"); - panel.addCheckbox(InspectionGadgetsLocalize.overlyBroadThrowsClauseIgnoreThrownOption().get(), "ignoreThrown"); - return panel; - } - - @Nonnull - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - final Collection maskedExceptions = (Collection)infos[0]; - final Boolean originalNeeded = (Boolean)infos[1]; - return new AddThrowsClauseFix(maskedExceptions, originalNeeded.booleanValue()); - } - - private static class AddThrowsClauseFix extends InspectionGadgetsFix { - - private final Collection types; - private final boolean originalNeeded; - - AddThrowsClauseFix(Collection types, boolean originalNeeded) { - this.types = types; - this.originalNeeded = originalNeeded; + + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.overlyBroadThrowsClauseDisplayName(); } @Override @Nonnull - public String getName() { - return originalNeeded - ? InspectionGadgetsLocalize.overlyBroadThrowsClauseQuickfix1().get() - : InspectionGadgetsLocalize.overlyBroadThrowsClauseQuickfix2().get(); + protected String buildErrorString(Object... infos) { + final List typesMasked = (List) infos[0]; + final PsiType type = typesMasked.get(0).getType(); + String typesMaskedString = type != null ? type.getPresentableText() : ""; + if (typesMasked.size() == 1) { + return InspectionGadgetsLocalize.overlyBroadThrowsClauseProblemDescriptor1(typesMaskedString).get(); + } + else { + final int lastTypeIndex = typesMasked.size() - 1; + for (int i = 1; i < lastTypeIndex; i++) { + final PsiType psiType = typesMasked.get(i).getType(); + if (psiType != null) { + typesMaskedString += ", "; + typesMaskedString += psiType.getPresentableText(); + } + } + final PsiType psiType = typesMasked.get(lastTypeIndex).getType(); + final String lastTypeString = psiType != null ? psiType.getPresentableText() : ""; + return InspectionGadgetsLocalize.overlyBroadThrowsClauseProblemDescriptor2(typesMaskedString, lastTypeString).get(); + } } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiReferenceList)) { - return; - } - final PsiReferenceList referenceList = (PsiReferenceList)parent; - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - if (!originalNeeded) { - element.delete(); - } - for (SmartTypePointer type : types) { - final PsiType psiType = type.getType(); - if (psiType instanceof PsiClassType) { - final PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType((PsiClassType)psiType); - referenceList.add(referenceElement); - } - } + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); + panel.addCheckbox(InspectionGadgetsLocalize.tooBroadCatchOption().get(), "onlyWarnOnRootExceptions"); + panel.addCheckbox(InspectionGadgetsBundle.message("ignore.exceptions.declared.in.tests.option"), "ignoreInTestCode"); + panel.addCheckbox(InspectionGadgetsLocalize.ignoreExceptionsDeclaredOnLibraryOverrideOption().get(), "ignoreLibraryOverrides"); + panel.addCheckbox(InspectionGadgetsLocalize.overlyBroadThrowsClauseIgnoreThrownOption().get(), "ignoreThrown"); + return panel; } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new TooBroadThrowsVisitor(); - } + @Nonnull + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + final Collection maskedExceptions = (Collection) infos[0]; + final Boolean originalNeeded = (Boolean) infos[1]; + return new AddThrowsClauseFix(maskedExceptions, originalNeeded.booleanValue()); + } - private class TooBroadThrowsVisitor extends BaseInspectionVisitor { + private static class AddThrowsClauseFix extends InspectionGadgetsFix { - @Override - public void visitMethod(PsiMethod method) { - super.visitMethod(method); - final PsiReferenceList throwsList = method.getThrowsList(); - if (!throwsList.isPhysical()) { - return; - } - final PsiJavaCodeReferenceElement[] throwsReferences = throwsList.getReferenceElements(); - if (throwsReferences.length == 0) { - return; - } - final PsiCodeBlock body = method.getBody(); - if (body == null) { - return; - } - if (ignoreInTestCode && TestUtils.isInTestCode(method)) { - return; - } - if (ignoreLibraryOverrides && LibraryUtil.isOverrideOfLibraryMethod(method)) { - return; - } - final Set exceptionsThrown = ExceptionUtils.calculateExceptionsThrown(body); - final PsiClassType[] referencedExceptions = throwsList.getReferencedTypes(); - final Set exceptionsDeclared = new HashSet(referencedExceptions.length); - ContainerUtil.addAll(exceptionsDeclared, referencedExceptions); - final int referencedExceptionsLength = referencedExceptions.length; - for (int i = 0; i < referencedExceptionsLength; i++) { - final PsiClassType referencedException = referencedExceptions[i]; - if (onlyWarnOnRootExceptions) { - if (!ExceptionUtils.isGenericExceptionClass( - referencedException)) { - continue; - } + private final Collection types; + private final boolean originalNeeded; + + AddThrowsClauseFix(Collection types, boolean originalNeeded) { + this.types = types; + this.originalNeeded = originalNeeded; } - final List exceptionsMasked = new ArrayList(); - final SmartTypePointerManager pointerManager = SmartTypePointerManager.getInstance(body.getProject()); - for (PsiClassType exceptionThrown : exceptionsThrown) { - if (referencedException.isAssignableFrom(exceptionThrown) && !exceptionsDeclared.contains(exceptionThrown)) { - exceptionsMasked.add(pointerManager.createSmartTypePointer(exceptionThrown)); - } + + @Nonnull + @Override + public LocalizeValue getName() { + return originalNeeded + ? InspectionGadgetsLocalize.overlyBroadThrowsClauseQuickfix1() + : InspectionGadgetsLocalize.overlyBroadThrowsClauseQuickfix2(); } - if (!exceptionsMasked.isEmpty()) { - final PsiJavaCodeReferenceElement throwsReference = throwsReferences[i]; - final boolean originalNeeded = exceptionsThrown.contains(referencedException); - if (ignoreThrown && originalNeeded) { - continue; - } - registerError(throwsReference, exceptionsMasked, Boolean.valueOf(originalNeeded)); + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (!(parent instanceof PsiReferenceList)) { + return; + } + final PsiReferenceList referenceList = (PsiReferenceList) parent; + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + if (!originalNeeded) { + element.delete(); + } + for (SmartTypePointer type : types) { + final PsiType psiType = type.getType(); + if (psiType instanceof PsiClassType) { + final PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType((PsiClassType) psiType); + referenceList.add(referenceElement); + } + } + } + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new TooBroadThrowsVisitor(); + } + + private class TooBroadThrowsVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + final PsiReferenceList throwsList = method.getThrowsList(); + if (!throwsList.isPhysical()) { + return; + } + final PsiJavaCodeReferenceElement[] throwsReferences = throwsList.getReferenceElements(); + if (throwsReferences.length == 0) { + return; + } + final PsiCodeBlock body = method.getBody(); + if (body == null) { + return; + } + if (ignoreInTestCode && TestUtils.isInTestCode(method)) { + return; + } + if (ignoreLibraryOverrides && LibraryUtil.isOverrideOfLibraryMethod(method)) { + return; + } + final Set exceptionsThrown = ExceptionUtils.calculateExceptionsThrown(body); + final PsiClassType[] referencedExceptions = throwsList.getReferencedTypes(); + final Set exceptionsDeclared = new HashSet(referencedExceptions.length); + ContainerUtil.addAll(exceptionsDeclared, referencedExceptions); + final int referencedExceptionsLength = referencedExceptions.length; + for (int i = 0; i < referencedExceptionsLength; i++) { + final PsiClassType referencedException = referencedExceptions[i]; + if (onlyWarnOnRootExceptions) { + if (!ExceptionUtils.isGenericExceptionClass( + referencedException)) { + continue; + } + } + final List exceptionsMasked = new ArrayList(); + final SmartTypePointerManager pointerManager = SmartTypePointerManager.getInstance(body.getProject()); + for (PsiClassType exceptionThrown : exceptionsThrown) { + if (referencedException.isAssignableFrom(exceptionThrown) && !exceptionsDeclared.contains(exceptionThrown)) { + exceptionsMasked.add(pointerManager.createSmartTypePointer(exceptionThrown)); + } + } + if (!exceptionsMasked.isEmpty()) { + final PsiJavaCodeReferenceElement throwsReference = throwsReferences[i]; + final boolean originalNeeded = exceptionsThrown.contains(referencedException); + if (ignoreThrown && originalNeeded) { + continue; + } + registerError(throwsReference, exceptionsMasked, Boolean.valueOf(originalNeeded)); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UncheckedExceptionClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UncheckedExceptionClassInspection.java index 7500941a04..c9509a9039 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UncheckedExceptionClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UncheckedExceptionClassInspection.java @@ -22,41 +22,41 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class UncheckedExceptionClassInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.uncheckedExceptionClassDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.uncheckedExceptionClassDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.uncheckedExceptionClassProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.uncheckedExceptionClassProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UncheckedExceptionClassVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new UncheckedExceptionClassVisitor(); + } - private static class UncheckedExceptionClassVisitor - extends BaseInspectionVisitor { + private static class UncheckedExceptionClassVisitor + extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_THROWABLE)) { - return; - } - if (InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_EXCEPTION) && - !InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION)) { - return; - } - registerClassError(aClass); + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (!InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_THROWABLE)) { + return; + } + if (InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_EXCEPTION) && + !InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION)) { + return; + } + registerClassError(aClass); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UnusedCatchParameterInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UnusedCatchParameterInspection.java index 1aa4d9b1ff..20860bf35c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UnusedCatchParameterInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/errorhandling/UnusedCatchParameterInspection.java @@ -30,6 +30,7 @@ import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; import consulo.language.psi.PsiComment; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; import org.jetbrains.annotations.NonNls; @@ -38,106 +39,105 @@ @ExtensionImpl public class UnusedCatchParameterInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignoreCatchBlocksWithComments = false; + /** + * @noinspection PublicField + */ + public boolean m_ignoreTestCases = false; - /** - * @noinspection PublicField - */ - public boolean m_ignoreCatchBlocksWithComments = false; - /** - * @noinspection PublicField - */ - public boolean m_ignoreTestCases = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unusedCatchParameterDisplayName().get(); - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.unusedCatchParameterIgnoreCatchOption().get(), - "m_ignoreCatchBlocksWithComments" - ); - optionsPanel.addCheckbox( - InspectionGadgetsBundle.message("unused.catch.parameter.ignore.empty.option"), - "m_ignoreTestCases" - ); - return optionsPanel; - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final boolean namedIgnoreButUsed = (Boolean)infos[0]; - return namedIgnoreButUsed - ? InspectionGadgetsLocalize.usedCatchParameterNamedIgnoreProblemDescriptor().get() - : InspectionGadgetsLocalize.unusedCatchParameterProblemDescriptor().get(); + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unusedCatchParameterDisplayName(); } - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - final boolean namedIgnoreButUsed = (Boolean)infos[0]; - if (namedIgnoreButUsed) { - return null; + @Override + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.unusedCatchParameterIgnoreCatchOption().get(), + "m_ignoreCatchBlocksWithComments" + ); + optionsPanel.addCheckbox( + InspectionGadgetsBundle.message("unused.catch.parameter.ignore.empty.option"), + "m_ignoreTestCases" + ); + return optionsPanel; } - return new RenameFix("ignored", false, false); - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnusedCatchParameterVisitor(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + final boolean namedIgnoreButUsed = (Boolean) infos[0]; + return namedIgnoreButUsed + ? InspectionGadgetsLocalize.usedCatchParameterNamedIgnoreProblemDescriptor().get() + : InspectionGadgetsLocalize.unusedCatchParameterProblemDescriptor().get(); + } - private class UnusedCatchParameterVisitor extends BaseInspectionVisitor { + @Override + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + final boolean namedIgnoreButUsed = (Boolean) infos[0]; + if (namedIgnoreButUsed) { + return null; + } + return new RenameFix("ignored", false, false); + } @Override - public void visitTryStatement(@Nonnull PsiTryStatement statement) { - super.visitTryStatement(statement); - if (m_ignoreTestCases && TestUtils.isInTestCode(statement)) { - return; - } - final PsiCatchSection[] catchSections = statement.getCatchSections(); - for (PsiCatchSection catchSection : catchSections) { - checkCatchSection(catchSection); - } + public BaseInspectionVisitor buildVisitor() { + return new UnusedCatchParameterVisitor(); } - private void checkCatchSection(PsiCatchSection section) { - final PsiParameter parameter = section.getParameter(); - if (parameter == null) { - return; - } - @NonNls final String parameterName = parameter.getName(); - final boolean namedIgnore = parameterName.contains("ignore"); - final PsiCodeBlock block = section.getCatchBlock(); - if (block == null) { - return; - } - if (m_ignoreCatchBlocksWithComments) { - final PsiElement[] children = block.getChildren(); - for (final PsiElement child : children) { - if (child instanceof PsiComment) { - return; - } + private class UnusedCatchParameterVisitor extends BaseInspectionVisitor { + + @Override + public void visitTryStatement(@Nonnull PsiTryStatement statement) { + super.visitTryStatement(statement); + if (m_ignoreTestCases && TestUtils.isInTestCode(statement)) { + return; + } + final PsiCatchSection[] catchSections = statement.getCatchSections(); + for (PsiCatchSection catchSection : catchSections) { + checkCatchSection(catchSection); + } } - } - final CatchParameterUsedVisitor visitor = - new CatchParameterUsedVisitor(parameter); - block.accept(visitor); - if (visitor.isUsed()) { - if (namedIgnore) { - registerVariableError(parameter, Boolean.valueOf(true)); + + private void checkCatchSection(PsiCatchSection section) { + final PsiParameter parameter = section.getParameter(); + if (parameter == null) { + return; + } + @NonNls final String parameterName = parameter.getName(); + final boolean namedIgnore = parameterName.contains("ignore"); + final PsiCodeBlock block = section.getCatchBlock(); + if (block == null) { + return; + } + if (m_ignoreCatchBlocksWithComments) { + final PsiElement[] children = block.getChildren(); + for (final PsiElement child : children) { + if (child instanceof PsiComment) { + return; + } + } + } + final CatchParameterUsedVisitor visitor = + new CatchParameterUsedVisitor(parameter); + block.accept(visitor); + if (visitor.isUsed()) { + if (namedIgnore) { + registerVariableError(parameter, Boolean.valueOf(true)); + } + return; + } + else if (namedIgnore) { + return; + } + registerVariableError(parameter, Boolean.valueOf(false)); } - return; - } - else if (namedIgnore) { - return; - } - registerVariableError(parameter, Boolean.valueOf(false)); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeInspection.java index 35de80703c..8d89f40d5a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeInspection.java @@ -25,87 +25,90 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; import javax.swing.*; @ExtensionImpl public class FinalizeInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean ignoreTrivialFinalizers = true; - @SuppressWarnings("PublicField") - public boolean ignoreTrivialFinalizers = true; - - @Nonnull - public String getID() { - return "FinalizeDeclaration"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.finalizeDeclarationDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.finalizeDeclarationProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.ignoreTrivialFinalizersOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreTrivialFinalizers"); - } + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "FinalizeDeclaration"; + } - public BaseInspectionVisitor buildVisitor() { - return new FinalizeDeclaredVisitor(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.finalizeDeclarationDisplayName(); + } - private class FinalizeDeclaredVisitor extends BaseInspectionVisitor { + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.finalizeDeclarationProblemDescriptor().get(); + } @Override - public void visitMethod(@Nonnull PsiMethod method) { - //note: no call to super; - final String methodName = method.getName(); - if (!HardcodedMethodConstants.FINALIZE.equals(methodName)) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() != 0) { - return; - } - if (ignoreTrivialFinalizers && isTrivial(method)) { - return; - } - registerMethodError(method); + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.ignoreTrivialFinalizersOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreTrivialFinalizers"); + } + + public BaseInspectionVisitor buildVisitor() { + return new FinalizeDeclaredVisitor(); } - private boolean isTrivial(PsiMethod method) { - final PsiCodeBlock body = method.getBody(); - if (body == null) { - return true; - } - final PsiStatement[] statements = body.getStatements(); - if (statements.length == 0) { - return true; - } - final Project project = method.getProject(); - final JavaPsiFacade psiFacade = - JavaPsiFacade.getInstance(project); - final PsiConstantEvaluationHelper evaluationHelper = - psiFacade.getConstantEvaluationHelper(); - for (PsiStatement statement : statements) { - if (!(statement instanceof PsiIfStatement)) { - return false; + private class FinalizeDeclaredVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + //note: no call to super; + final String methodName = method.getName(); + if (!HardcodedMethodConstants.FINALIZE.equals(methodName)) { + return; + } + final PsiParameterList parameterList = method.getParameterList(); + if (parameterList.getParametersCount() != 0) { + return; + } + if (ignoreTrivialFinalizers && isTrivial(method)) { + return; + } + registerMethodError(method); } - final PsiIfStatement ifStatement = - (PsiIfStatement)statement; - final PsiExpression condition = ifStatement.getCondition(); - final Object result = - evaluationHelper.computeConstantExpression(condition); - if (result == null || !result.equals(Boolean.FALSE)) { - return false; + + private boolean isTrivial(PsiMethod method) { + final PsiCodeBlock body = method.getBody(); + if (body == null) { + return true; + } + final PsiStatement[] statements = body.getStatements(); + if (statements.length == 0) { + return true; + } + final Project project = method.getProject(); + final JavaPsiFacade psiFacade = + JavaPsiFacade.getInstance(project); + final PsiConstantEvaluationHelper evaluationHelper = + psiFacade.getConstantEvaluationHelper(); + for (PsiStatement statement : statements) { + if (!(statement instanceof PsiIfStatement)) { + return false; + } + final PsiIfStatement ifStatement = + (PsiIfStatement) statement; + final PsiExpression condition = ifStatement.getCondition(); + final Object result = + evaluationHelper.computeConstantExpression(condition); + if (result == null || !result.equals(Boolean.FALSE)) { + return false; + } + } + return true; } - } - return true; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeNotProtectedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeNotProtectedInspection.java index d4077c7cf2..616452e4e0 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeNotProtectedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/FinalizeNotProtectedInspection.java @@ -28,67 +28,68 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; @ExtensionImpl public class FinalizeNotProtectedInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.finalizeNotDeclaredProtectedDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.finalizeNotDeclaredProtectedDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.finalizeNotDeclaredProtectedProblemDescriptor().get(); - } - - public BaseInspectionVisitor buildVisitor() { - return new FinalizeDeclaredProtectedVisitor(); - } - - public InspectionGadgetsFix buildFix(Object... infos) { - return new ProtectedFinalizeFix(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.finalizeNotDeclaredProtectedProblemDescriptor().get(); + } - private static class ProtectedFinalizeFix extends InspectionGadgetsFix { + public BaseInspectionVisitor buildVisitor() { + return new FinalizeDeclaredProtectedVisitor(); + } - @Nonnull - public String getName() { - return InspectionGadgetsLocalize.makeProtectedQuickfix().get(); + public InspectionGadgetsFix buildFix(Object... infos) { + return new ProtectedFinalizeFix(); } - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement methodName = descriptor.getPsiElement(); - final PsiMethod method = (PsiMethod)methodName.getParent(); - assert method != null; - final PsiModifierList modifiers = method.getModifierList(); - modifiers.setModifierProperty(PsiModifier.PUBLIC, false); - modifiers.setModifierProperty(PsiModifier.PRIVATE, false); - modifiers.setModifierProperty(PsiModifier.PROTECTED, true); + private static class ProtectedFinalizeFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.makeProtectedQuickfix(); + } + + public void doFix(Project project, ProblemDescriptor descriptor) + throws IncorrectOperationException { + final PsiElement methodName = descriptor.getPsiElement(); + final PsiMethod method = (PsiMethod) methodName.getParent(); + assert method != null; + final PsiModifierList modifiers = method.getModifierList(); + modifiers.setModifierProperty(PsiModifier.PUBLIC, false); + modifiers.setModifierProperty(PsiModifier.PRIVATE, false); + modifiers.setModifierProperty(PsiModifier.PROTECTED, true); + } } - } - private static class FinalizeDeclaredProtectedVisitor - extends BaseInspectionVisitor { + private static class FinalizeDeclaredProtectedVisitor + extends BaseInspectionVisitor { - @Override - public void visitMethod(@Nonnull PsiMethod method) { - //note: no call to super; - final String methodName = method.getName(); - if (!HardcodedMethodConstants.FINALIZE.equals(methodName)) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() != 0) { - return; - } - if (method.hasModifierProperty(PsiModifier.PROTECTED)) { - return; - } - registerMethodError(method); + @Override + public void visitMethod(@Nonnull PsiMethod method) { + //note: no call to super; + final String methodName = method.getName(); + if (!HardcodedMethodConstants.FINALIZE.equals(methodName)) { + return; + } + final PsiParameterList parameterList = method.getParameterList(); + if (parameterList.getParametersCount() != 0) { + return; + } + if (method.hasModifierProperty(PsiModifier.PROTECTED)) { + return; + } + registerMethodError(method); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/NoExplicitFinalizeCallsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/NoExplicitFinalizeCallsInspection.java index e26724cae8..765fb4a5d1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/finalization/NoExplicitFinalizeCallsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/finalization/NoExplicitFinalizeCallsInspection.java @@ -26,55 +26,62 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class NoExplicitFinalizeCallsInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "FinalizeCalledExplicitly"; + } - @Nonnull - public String getID() { - return "FinalizeCalledExplicitly"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.finalizeCalledExplicitlyDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.finalizeCalledExplicitlyDisplayName(); + } - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.finalizeCalledExplicitlyProblemDescriptor().get(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.finalizeCalledExplicitlyProblemDescriptor().get(); + } - public boolean isEnabledByDefault() { - return true; - } + public boolean isEnabledByDefault() { + return true; + } - public BaseInspectionVisitor buildVisitor() { - return new NoExplicitFinalizeCallsVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new NoExplicitFinalizeCallsVisitor(); + } - private static class NoExplicitFinalizeCallsVisitor - extends BaseInspectionVisitor { + private static class NoExplicitFinalizeCallsVisitor + extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression( - @Nonnull PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - if (!MethodCallUtils.isCallToMethod(expression, null, PsiType.VOID, - HardcodedMethodConstants.FINALIZE)) { - return; - } - final PsiMethod containingMethod = - PsiTreeUtil.getParentOfType(expression, PsiMethod.class); - if (containingMethod == null) { - return; - } - if (MethodUtils.methodMatches(containingMethod, null, PsiType.VOID, - HardcodedMethodConstants.FINALIZE)) { - return; - } - registerMethodCallError(expression); + @Override + public void visitMethodCallExpression( + @Nonnull PsiMethodCallExpression expression + ) { + super.visitMethodCallExpression(expression); + if (!MethodCallUtils.isCallToMethod(expression, null, PsiType.VOID, + HardcodedMethodConstants.FINALIZE + )) { + return; + } + final PsiMethod containingMethod = + PsiTreeUtil.getParentOfType(expression, PsiMethod.class); + if (containingMethod == null) { + return; + } + if (MethodUtils.methodMatches(containingMethod, null, PsiType.VOID, + HardcodedMethodConstants.FINALIZE + )) { + return; + } + registerMethodCallError(expression); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/JavaLangImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/JavaLangImportInspection.java index d4aa8eee6b..b8d8fb715c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/JavaLangImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/JavaLangImportInspection.java @@ -24,90 +24,92 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class JavaLangImportInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.javaLangImportDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.javaLangImportDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.javaLangImportProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.javaLangImportProblemDescriptor().get(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new DeleteImportFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new DeleteImportFix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new JavaLangImportVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new JavaLangImportVisitor(); + } - private static class JavaLangImportVisitor extends BaseInspectionVisitor { + private static class JavaLangImportVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - if (!(aClass.getParent() instanceof PsiJavaFile)) { - return; - } + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + if (!(aClass.getParent() instanceof PsiJavaFile)) { + return; + } /* if (JspPsiUtil.isInJspFile(aClass.getContainingFile())) { return; } */ - final PsiJavaFile file = (PsiJavaFile)aClass.getContainingFile(); - if (!file.getClasses()[0].equals(aClass)) { - return; - } - final PsiImportList importList = file.getImportList(); - if (importList == null) { - return; - } - final PsiImportStatement[] importStatements = - importList.getImportStatements(); - for (PsiImportStatement importStatement : importStatements) { - checkImportStatement(importStatement, file); - } - } - - private void checkImportStatement(PsiImportStatement importStatement, - PsiJavaFile file) { - final PsiJavaCodeReferenceElement reference = - importStatement.getImportReference(); - if (reference == null) { - return; - } - final String text = importStatement.getQualifiedName(); - if (text == null) { - return; - } - if (importStatement.isOnDemand()) { - if (HardcodedMethodConstants.JAVA_LANG.equals(text)) { - registerError(importStatement); - } - } - else { - final int classNameIndex = text.lastIndexOf((int)'.'); - if (classNameIndex < 0) { - return; + final PsiJavaFile file = (PsiJavaFile) aClass.getContainingFile(); + if (!file.getClasses()[0].equals(aClass)) { + return; + } + final PsiImportList importList = file.getImportList(); + if (importList == null) { + return; + } + final PsiImportStatement[] importStatements = + importList.getImportStatements(); + for (PsiImportStatement importStatement : importStatements) { + checkImportStatement(importStatement, file); + } } - final String parentName = - text.substring(0, classNameIndex); - if (!HardcodedMethodConstants.JAVA_LANG.equals(parentName)) { - return; - } - if (ImportUtils.hasOnDemandImportConflict(text, file)) { - return; + + private void checkImportStatement( + PsiImportStatement importStatement, + PsiJavaFile file + ) { + final PsiJavaCodeReferenceElement reference = + importStatement.getImportReference(); + if (reference == null) { + return; + } + final String text = importStatement.getQualifiedName(); + if (text == null) { + return; + } + if (importStatement.isOnDemand()) { + if (HardcodedMethodConstants.JAVA_LANG.equals(text)) { + registerError(importStatement); + } + } + else { + final int classNameIndex = text.lastIndexOf((int) '.'); + if (classNameIndex < 0) { + return; + } + final String parentName = + text.substring(0, classNameIndex); + if (!HardcodedMethodConstants.JAVA_LANG.equals(parentName)) { + return; + } + if (ImportUtils.hasOnDemandImportConflict(text, file)) { + return; + } + registerError(importStatement); + } } - registerError(importStatement); - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/OnDemandImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/OnDemandImportInspection.java index 140b91df81..228ee19fc2 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/OnDemandImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/OnDemandImportInspection.java @@ -24,51 +24,52 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class OnDemandImportInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.importDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.importDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.importProblemDescriptor().get(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.importProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new PackageImportVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new PackageImportVisitor(); + } - private static class PackageImportVisitor extends BaseInspectionVisitor { + private static class PackageImportVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - final PsiElement parent = aClass.getParent(); - if (!(parent instanceof PsiJavaFile)) { - return; - } - final PsiJavaFile file = (PsiJavaFile)parent; + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + final PsiElement parent = aClass.getParent(); + if (!(parent instanceof PsiJavaFile)) { + return; + } + final PsiJavaFile file = (PsiJavaFile) parent; /* if (JspPsiUtil.isInJspFile(aClass.getContainingFile())) { return; } */ - if (!file.getClasses()[0].equals(aClass)) { - return; - } - final PsiImportList importList = file.getImportList(); - if (importList != null) { - final PsiImportStatement[] importStatements = - importList.getImportStatements(); - for (PsiImportStatement importStatement : importStatements) { - if (importStatement.isOnDemand()) { - registerError(importStatement); - } + if (!file.getClasses()[0].equals(aClass)) { + return; + } + final PsiImportList importList = file.getImportList(); + if (importList != null) { + final PsiImportStatement[] importStatements = + importList.getImportStatements(); + for (PsiImportStatement importStatement : importStatements) { + if (importStatement.isOnDemand()) { + registerError(importStatement); + } + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/RedundantImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/RedundantImportInspection.java index b7b306ce45..ab7f8d5001 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/RedundantImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/RedundantImportInspection.java @@ -25,6 +25,7 @@ import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import java.util.HashSet; @@ -32,131 +33,130 @@ @ExtensionImpl public class RedundantImportInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.redundantImportDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.redundantImportDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.redundantImportProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.redundantImportProblemDescriptor().get(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new DeleteImportFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new DeleteImportFix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new RedundantImportVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new RedundantImportVisitor(); + } - private static class RedundantImportVisitor extends BaseInspectionVisitor { + private static class RedundantImportVisitor extends BaseInspectionVisitor { - @Override - public void visitFile(PsiFile file) { - super.visitFile(file); - if (!(file instanceof PsiJavaFile)) { - return; - } - final PsiJavaFile javaFile = (PsiJavaFile)file; + @Override + public void visitFile(PsiFile file) { + super.visitFile(file); + if (!(file instanceof PsiJavaFile)) { + return; + } + final PsiJavaFile javaFile = (PsiJavaFile) file; /* if (JspPsiUtil.isInJspFile(file)) { return; }*/ - final PsiImportList importList = javaFile.getImportList(); - if (importList == null) { - return; - } - checkNonStaticImports(importList, javaFile); - checkStaticImports(importList, javaFile); - } - - private void checkStaticImports(PsiImportList importList, PsiJavaFile javaFile) { - final PsiImportStaticStatement[] importStaticStatements = importList.getImportStaticStatements(); - final Set onDemandStaticImports = new HashSet(); - final Set singleMemberStaticImports = new HashSet(); - for (PsiImportStaticStatement importStaticStatement : importStaticStatements) { - final PsiClass targetClass = importStaticStatement.resolveTargetClass(); - if (targetClass == null) { - continue; - } - final String qualifiedName = targetClass.getQualifiedName(); - final String referenceName = importStaticStatement.getReferenceName(); - if (referenceName == null) { - if (onDemandStaticImports.contains(qualifiedName)) { - registerError(importStaticStatement); - continue; - } - onDemandStaticImports.add(qualifiedName); - } - else { - final String qualifiedReferenceName = qualifiedName + '.' + referenceName; - if (singleMemberStaticImports.contains(qualifiedReferenceName)) { - registerError(importStaticStatement); - continue; - } - if (onDemandStaticImports.contains(qualifiedName)) { - if (!ImportUtils.hasOnDemandImportConflict(qualifiedReferenceName, javaFile)) { - registerError(importStaticStatement); + final PsiImportList importList = javaFile.getImportList(); + if (importList == null) { + return; } - } - singleMemberStaticImports.add(qualifiedReferenceName); + checkNonStaticImports(importList, javaFile); + checkStaticImports(importList, javaFile); } - } - } - private void checkNonStaticImports(PsiImportList importList, PsiJavaFile javaFile) { - final PsiImportStatement[] importStatements = importList.getImportStatements(); - final Set onDemandImports = new HashSet(); - final Set singleClassImports = new HashSet(); - for (final PsiImportStatement importStatement : importStatements) { - final String qualifiedName = importStatement.getQualifiedName(); - if (qualifiedName == null) { - continue; - } - if (importStatement.isOnDemand()) { - if (onDemandImports.contains(qualifiedName)) { - registerError(importStatement); - } - onDemandImports.add(qualifiedName); + private void checkStaticImports(PsiImportList importList, PsiJavaFile javaFile) { + final PsiImportStaticStatement[] importStaticStatements = importList.getImportStaticStatements(); + final Set onDemandStaticImports = new HashSet(); + final Set singleMemberStaticImports = new HashSet(); + for (PsiImportStaticStatement importStaticStatement : importStaticStatements) { + final PsiClass targetClass = importStaticStatement.resolveTargetClass(); + if (targetClass == null) { + continue; + } + final String qualifiedName = targetClass.getQualifiedName(); + final String referenceName = importStaticStatement.getReferenceName(); + if (referenceName == null) { + if (onDemandStaticImports.contains(qualifiedName)) { + registerError(importStaticStatement); + continue; + } + onDemandStaticImports.add(qualifiedName); + } + else { + final String qualifiedReferenceName = qualifiedName + '.' + referenceName; + if (singleMemberStaticImports.contains(qualifiedReferenceName)) { + registerError(importStaticStatement); + continue; + } + if (onDemandStaticImports.contains(qualifiedName)) { + if (!ImportUtils.hasOnDemandImportConflict(qualifiedReferenceName, javaFile)) { + registerError(importStaticStatement); + } + } + singleMemberStaticImports.add(qualifiedReferenceName); + } + } } - else { - if (singleClassImports.contains(qualifiedName)) { - registerError(importStatement); - continue; - } - final PsiElement element = importStatement.resolve(); - if (!(element instanceof PsiClass)) { - continue; - } - final PsiElement context = element.getContext(); - if (context == null) { - continue; - } - final String contextName; - if (context instanceof PsiJavaFile) { - final PsiJavaFile file = (PsiJavaFile)context; - contextName = file.getPackageName(); - } - else if (context instanceof PsiClass) { - final PsiClass aClass = (PsiClass)context; - contextName = aClass.getQualifiedName(); - } - else { - continue; - } - if (onDemandImports.contains(contextName) && - !ImportUtils.hasOnDemandImportConflict(qualifiedName, javaFile) && - !ImportUtils.hasDefaultImportConflict(qualifiedName, javaFile)) { - registerError(importStatement); - } - singleClassImports.add(qualifiedName); + + private void checkNonStaticImports(PsiImportList importList, PsiJavaFile javaFile) { + final PsiImportStatement[] importStatements = importList.getImportStatements(); + final Set onDemandImports = new HashSet(); + final Set singleClassImports = new HashSet(); + for (final PsiImportStatement importStatement : importStatements) { + final String qualifiedName = importStatement.getQualifiedName(); + if (qualifiedName == null) { + continue; + } + if (importStatement.isOnDemand()) { + if (onDemandImports.contains(qualifiedName)) { + registerError(importStatement); + } + onDemandImports.add(qualifiedName); + } + else { + if (singleClassImports.contains(qualifiedName)) { + registerError(importStatement); + continue; + } + final PsiElement element = importStatement.resolve(); + if (!(element instanceof PsiClass)) { + continue; + } + final PsiElement context = element.getContext(); + if (context == null) { + continue; + } + final String contextName; + if (context instanceof PsiJavaFile) { + final PsiJavaFile file = (PsiJavaFile) context; + contextName = file.getPackageName(); + } + else if (context instanceof PsiClass) { + final PsiClass aClass = (PsiClass) context; + contextName = aClass.getQualifiedName(); + } + else { + continue; + } + if (onDemandImports.contains(contextName) && + !ImportUtils.hasOnDemandImportConflict(qualifiedName, javaFile) && + !ImportUtils.hasDefaultImportConflict(qualifiedName, javaFile)) { + registerError(importStatement); + } + singleClassImports.add(qualifiedName); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/SamePackageImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/SamePackageImportInspection.java index 22e7769ed3..4874363b52 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/SamePackageImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/SamePackageImportInspection.java @@ -26,78 +26,78 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class SamePackageImportInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.importFromSamePackageDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.importFromSamePackageDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.importFromSamePackageProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.importFromSamePackageProblemDescriptor().get(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new DeleteImportFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new DeleteImportFix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new SamePackageImportVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new SamePackageImportVisitor(); + } - private static class SamePackageImportVisitor - extends BaseInspectionVisitor { + private static class SamePackageImportVisitor + extends BaseInspectionVisitor { - @Override - public void visitImportList(PsiImportList importList) { - final PsiElement parent = importList.getParent(); - if (!(parent instanceof PsiJavaFile)) { - return; - } + @Override + public void visitImportList(PsiImportList importList) { + final PsiElement parent = importList.getParent(); + if (!(parent instanceof PsiJavaFile)) { + return; + } /* if (JspPsiUtil.isInJspFile(importList)) { return; } */ - final PsiJavaFile javaFile = (PsiJavaFile)parent; - final String packageName = javaFile.getPackageName(); - final PsiImportStatement[] importStatements = - importList.getImportStatements(); - for (final PsiImportStatement importStatement : importStatements) { - final PsiJavaCodeReferenceElement reference = - importStatement.getImportReference(); - if (reference == null) { - continue; - } - final String text = importStatement.getQualifiedName(); - if (importStatement.isOnDemand()) { - if (packageName.equals(text)) { - registerError(importStatement); - } - } - else { - if (text == null) { - return; - } - final int classNameIndex = text.lastIndexOf((int)'.'); - final String parentName; - if (classNameIndex < 0) { - parentName = ""; - } - else { - parentName = text.substring(0, classNameIndex); - } - if (packageName.equals(parentName)) { - registerError(importStatement); - } + final PsiJavaFile javaFile = (PsiJavaFile) parent; + final String packageName = javaFile.getPackageName(); + final PsiImportStatement[] importStatements = + importList.getImportStatements(); + for (final PsiImportStatement importStatement : importStatements) { + final PsiJavaCodeReferenceElement reference = + importStatement.getImportReference(); + if (reference == null) { + continue; + } + final String text = importStatement.getQualifiedName(); + if (importStatement.isOnDemand()) { + if (packageName.equals(text)) { + registerError(importStatement); + } + } + else { + if (text == null) { + return; + } + final int classNameIndex = text.lastIndexOf((int) '.'); + final String parentName; + if (classNameIndex < 0) { + parentName = ""; + } + else { + parentName = text.substring(0, classNameIndex); + } + if (packageName.equals(parentName)) { + registerError(importStatement); + } + } + } } - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/SingleClassImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/SingleClassImportInspection.java index 5414f4cf9f..d39388eff8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/SingleClassImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/SingleClassImportInspection.java @@ -23,54 +23,55 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class SingleClassImportInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.singleClassImportDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.singleClassImportDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.singleClassImportProblemDescriptor().get(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.singleClassImportProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new PackageImportVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new PackageImportVisitor(); + } - private static class PackageImportVisitor extends BaseInspectionVisitor { + private static class PackageImportVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - if (!(aClass.getParent() instanceof PsiJavaFile)) { - return; - } + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + if (!(aClass.getParent() instanceof PsiJavaFile)) { + return; + } /* if (JspPsiUtil.isInJspFile(aClass.getContainingFile())) { return; } */ - final PsiJavaFile file = (PsiJavaFile)aClass.getParent(); - if (file == null) { - return; - } - if (!file.getClasses()[0].equals(aClass)) { - return; - } - final PsiImportList importList = file.getImportList(); - if (importList == null) { - return; - } - final PsiImportStatement[] importStatements = - importList.getImportStatements(); - for (final PsiImportStatement importStatement : importStatements) { - if (!importStatement.isOnDemand()) { - registerError(importStatement); + final PsiJavaFile file = (PsiJavaFile) aClass.getParent(); + if (file == null) { + return; + } + if (!file.getClasses()[0].equals(aClass)) { + return; + } + final PsiImportList importList = file.getImportList(); + if (importList == null) { + return; + } + final PsiImportStatement[] importStatements = + importList.getImportStatements(); + for (final PsiImportStatement importStatement : importStatements) { + if (!importStatement.isOnDemand()) { + registerError(importStatement); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/imports/UnusedImportInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/imports/UnusedImportInspection.java index dd7fe48854..7fcc497476 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/imports/UnusedImportInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/imports/UnusedImportInspection.java @@ -22,77 +22,78 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @ExtensionImpl public class UnusedImportInspection extends BaseInspection { - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unusedImportDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unusedImportDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unusedImportProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unusedImportProblemDescriptor().get(); + } - @Override - public boolean runForWholeFile() { - return true; - } + @Override + public boolean runForWholeFile() { + return true; + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new DeleteImportFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new DeleteImportFix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnusedImportVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnusedImportVisitor(); + } - private static class UnusedImportVisitor extends BaseInspectionVisitor { + private static class UnusedImportVisitor extends BaseInspectionVisitor { - @Override - public void visitJavaFile(PsiJavaFile file) { + @Override + public void visitJavaFile(PsiJavaFile file) { /* if (JspPsiUtil.isInJspFile(file)) { return; } */ - final PsiImportList importList = file.getImportList(); - if (importList == null) { - return; - } - final PsiClass[] classes = file.getClasses(); - final PsiPackageStatement packageStatement = file.getPackageStatement(); - final PsiModifierList annotationList; - if (packageStatement != null) { - annotationList = packageStatement.getAnnotationList(); - } - else { - annotationList = null; - } - final PsiImportStatementBase[] importStatements = importList.getAllImportStatements(); - checkImports(importStatements, classes, annotationList); - } + final PsiImportList importList = file.getImportList(); + if (importList == null) { + return; + } + final PsiClass[] classes = file.getClasses(); + final PsiPackageStatement packageStatement = file.getPackageStatement(); + final PsiModifierList annotationList; + if (packageStatement != null) { + annotationList = packageStatement.getAnnotationList(); + } + else { + annotationList = null; + } + final PsiImportStatementBase[] importStatements = importList.getAllImportStatements(); + checkImports(importStatements, classes, annotationList); + } - private void checkImports(PsiImportStatementBase[] importStatements, PsiClass[] classes, @Nullable PsiModifierList annotationList) { - if (importStatements.length == 0) { - return; - } - final ImportsAreUsedVisitor visitor = new ImportsAreUsedVisitor(importStatements); - for (PsiClass aClass : classes) { - aClass.accept(visitor); - } - if (annotationList != null) { - annotationList.accept(visitor); - } - final PsiImportStatementBase[] unusedImportStatements = visitor.getUnusedImportStatements(); - for (PsiImportStatementBase unusedImportStatement : unusedImportStatements) { - registerError(unusedImportStatement); - } + private void checkImports(PsiImportStatementBase[] importStatements, PsiClass[] classes, @Nullable PsiModifierList annotationList) { + if (importStatements.length == 0) { + return; + } + final ImportsAreUsedVisitor visitor = new ImportsAreUsedVisitor(importStatements); + for (PsiClass aClass : classes) { + aClass.accept(visitor); + } + if (annotationList != null) { + annotationList.accept(visitor); + } + final PsiImportStatementBase[] unusedImportStatements = visitor.getUnusedImportStatements(); + for (PsiImportStatementBase unusedImportStatement : unusedImportStatements) { + registerError(unusedImportStatement); + } + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java index 9e21576bfc..0509e8c7af 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java @@ -22,53 +22,52 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl -public class AbstractClassExtendsConcreteClassInspection - extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractClassExtendsConcreteClassDisplayName().get(); - } +public class AbstractClassExtendsConcreteClassInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractClassExtendsConcreteClassDisplayName(); + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractClassExtendsConcreteClassProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractClassExtendsConcreteClassProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new AbstractClassExtendsConcreteClassVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new AbstractClassExtendsConcreteClassVisitor(); + } - private static class AbstractClassExtendsConcreteClassVisitor - extends BaseInspectionVisitor { + private static class AbstractClassExtendsConcreteClassVisitor + extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so that it doesn't drill down to inner classes - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - final PsiClass superClass = aClass.getSuperClass(); - if (superClass == null) { - return; - } - if (superClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - final String superclassName = superClass.getQualifiedName(); - if (CommonClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { - return; - } - registerClassError(aClass); + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so that it doesn't drill down to inner classes + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + final PsiClass superClass = aClass.getSuperClass(); + if (superClass == null) { + return; + } + if (superClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + final String superclassName = superClass.getQualifiedName(); + if (CommonClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { + return; + } + registerClassError(aClass); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassNeverImplementedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassNeverImplementedInspection.java index eca3cde22c..243515f81b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassNeverImplementedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassNeverImplementedInspection.java @@ -22,40 +22,41 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class AbstractClassNeverImplementedInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractClassNeverImplementedDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractClassNeverImplementedDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractClassNeverImplementedProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractClassNeverImplementedProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new AbstractClassNeverImplementedVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new AbstractClassNeverImplementedVisitor(); + } - private static class AbstractClassNeverImplementedVisitor - extends BaseInspectionVisitor { + private static class AbstractClassNeverImplementedVisitor + extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - if (InheritanceUtil.hasImplementation(aClass)) { - return; - } - registerClassError(aClass); + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + if (InheritanceUtil.hasImplementation(aClass)) { + return; + } + registerClassError(aClass); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassWithoutAbstractMethodsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassWithoutAbstractMethodsInspection.java index c9b10fbe90..050564b181 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassWithoutAbstractMethodsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassWithoutAbstractMethodsInspection.java @@ -22,77 +22,79 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import java.util.HashSet; import java.util.Set; @ExtensionImpl -public class AbstractClassWithoutAbstractMethodsInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractClassWithoutAbstractMethodsDisplayName().get(); - } +public class AbstractClassWithoutAbstractMethodsInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractClassWithoutAbstractMethodsDisplayName(); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractClassWithoutAbstractMethodsProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractClassWithoutAbstractMethodsProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new AbstractClassWithoutAbstractMethodsVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new AbstractClassWithoutAbstractMethodsVisitor(); + } - private static class AbstractClassWithoutAbstractMethodsVisitor - extends BaseInspectionVisitor { + private static class AbstractClassWithoutAbstractMethodsVisitor + extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so that it doesn't drill down to inner classes - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - if (hasAbstractMethods(aClass)) { - return; - } - registerClassError(aClass); - } + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so that it doesn't drill down to inner classes + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + if (hasAbstractMethods(aClass)) { + return; + } + registerClassError(aClass); + } - private static boolean hasAbstractMethods(PsiClass aClass) { - final PsiMethod[] methods = aClass.getMethods(); - final Set overriddenMethods = - calculateOverriddenMethods(methods); - final PsiMethod[] allMethods = aClass.getAllMethods(); - for (final PsiMethod method : allMethods) { - if (method.hasModifierProperty(PsiModifier.ABSTRACT) && - !overriddenMethods.contains(method)) { - return true; + private static boolean hasAbstractMethods(PsiClass aClass) { + final PsiMethod[] methods = aClass.getMethods(); + final Set overriddenMethods = + calculateOverriddenMethods(methods); + final PsiMethod[] allMethods = aClass.getAllMethods(); + for (final PsiMethod method : allMethods) { + if (method.hasModifierProperty(PsiModifier.ABSTRACT) && + !overriddenMethods.contains(method)) { + return true; + } + } + return false; } - } - return false; - } - private static Set calculateOverriddenMethods( - PsiMethod[] methods) { - final Set overriddenMethods = - new HashSet(methods.length); - for (final PsiMethod method : methods) { - calculateOverriddenMethods(method, overriddenMethods); - } - return overriddenMethods; - } + private static Set calculateOverriddenMethods( + PsiMethod[] methods + ) { + final Set overriddenMethods = + new HashSet(methods.length); + for (final PsiMethod method : methods) { + calculateOverriddenMethods(method, overriddenMethods); + } + return overriddenMethods; + } - private static void calculateOverriddenMethods( - PsiMethod method, Set overriddenMethods) { - final PsiMethod[] superMethods = method.findSuperMethods(); - for (final PsiMethod superMethod : superMethods) { - overriddenMethods.add(superMethod); - } + private static void calculateOverriddenMethods( + PsiMethod method, Set overriddenMethods + ) { + final PsiMethod[] superMethods = method.findSuperMethods(); + for (final PsiMethod superMethod : superMethods) { + overriddenMethods.add(superMethod); + } + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java index 91c47f3f37..2091fa5262 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java @@ -26,6 +26,7 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.lang.Comparing; import jakarta.annotation.Nonnull; @@ -36,195 +37,197 @@ import java.util.Set; public abstract class AbstractMethodOverridesAbstractMethodInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean ignoreJavaDoc = false; - @SuppressWarnings("PublicField") - public boolean ignoreJavaDoc = false; - - @SuppressWarnings("PublicField") - public boolean ignoreAnnotations = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodDisplayName().get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new AbstractMethodOverridesAbstractMethodFix(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); - panel.addCheckbox( - InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodIgnoreDifferentJavadocOption().get(), - "ignoreJavaDoc" - ); - panel.addCheckbox( - InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodIgnoreDifferentAnnotationsOption().get(), - "ignoreAnnotations" - ); - return panel; - } - - private static class AbstractMethodOverridesAbstractMethodFix extends InspectionGadgetsFix { + @SuppressWarnings("PublicField") + public boolean ignoreAnnotations = false; - @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodRemoveQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodDisplayName(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement methodNameIdentifier = descriptor.getPsiElement(); - final PsiElement method = methodNameIdentifier.getParent(); - assert method != null; - deleteElement(method); + protected InspectionGadgetsFix buildFix(Object... infos) { + return new AbstractMethodOverridesAbstractMethodFix(); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new AbstractMethodOverridesAbstractMethodVisitor(); - } - private class AbstractMethodOverridesAbstractMethodVisitor extends BaseInspectionVisitor { + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodProblemDescriptor().get(); + } @Override - public void visitMethod(@Nonnull PsiMethod method) { - //no call to super, so we don't drill into anonymous classes - if (method.isConstructor()) { - return; - } - if (!isAbstract(method)) { - return; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return; - } - if (!method.hasModifierProperty(PsiModifier.ABSTRACT) && !containingClass.isInterface()) { - return; - } - final PsiMethod[] superMethods = method.findSuperMethods(); - for (final PsiMethod superMethod : superMethods) { - if (!isAbstract(superMethod)) { - continue; - } - if (!methodsHaveSameReturnTypes(method, superMethod) || !haveSameExceptionSignatures(method, superMethod)) { - continue; - } - if (ignoreJavaDoc && !haveSameJavaDoc(method, superMethod)) { - return; + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); + panel.addCheckbox( + InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodIgnoreDifferentJavadocOption().get(), + "ignoreJavaDoc" + ); + panel.addCheckbox( + InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodIgnoreDifferentAnnotationsOption().get(), + "ignoreAnnotations" + ); + return panel; + } + + private static class AbstractMethodOverridesAbstractMethodFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.abstractMethodOverridesAbstractMethodRemoveQuickfix(); } - if (ignoreAnnotations && !methodsHaveSameAnnotations(method, superMethod)) { - return; + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement methodNameIdentifier = descriptor.getPsiElement(); + final PsiElement method = methodNameIdentifier.getParent(); + assert method != null; + deleteElement(method); } - registerMethodError(method); - return; - } } - private boolean methodsHaveSameAnnotations(PsiMethod method, PsiMethod superMethod) { - if (!haveSameAnnotations(method, superMethod)) { - return false; - } - final PsiParameterList superParameterList = superMethod.getParameterList(); - final PsiParameter[] superParameters = superParameterList.getParameters(); - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - for (int i = 0, length = superParameters.length; i < length; i++) { - final PsiParameter superParameter = superParameters[i]; - final PsiParameter parameter = parameters[i]; - if (!haveSameAnnotations(parameter, superParameter)) { - return false; - } - } - return true; + @Override + public BaseInspectionVisitor buildVisitor() { + return new AbstractMethodOverridesAbstractMethodVisitor(); } - private boolean haveSameAnnotations(PsiModifierListOwner owner1, PsiModifierListOwner owner2) { - final PsiModifierList modifierList = owner1.getModifierList(); - final PsiModifierList superModifierList = owner2.getModifierList(); - if (superModifierList == null) { - return modifierList == null; - } else if (modifierList == null) { - return false; - } - final PsiAnnotation[] superAnnotations = superModifierList.getAnnotations(); - final PsiAnnotation[] annotations = modifierList.getAnnotations(); - final Set annotationsSet = new HashSet(Arrays.asList(superAnnotations)); - for (PsiAnnotation annotation : annotations) { - final String qualifiedName = annotation.getQualifiedName(); - if (CommonClassNames.JAVA_LANG_OVERRIDE.equals(qualifiedName)) { - continue; + private class AbstractMethodOverridesAbstractMethodVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + //no call to super, so we don't drill into anonymous classes + if (method.isConstructor()) { + return; + } + if (!isAbstract(method)) { + return; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return; + } + if (!method.hasModifierProperty(PsiModifier.ABSTRACT) && !containingClass.isInterface()) { + return; + } + final PsiMethod[] superMethods = method.findSuperMethods(); + for (final PsiMethod superMethod : superMethods) { + if (!isAbstract(superMethod)) { + continue; + } + if (!methodsHaveSameReturnTypes(method, superMethod) || !haveSameExceptionSignatures(method, superMethod)) { + continue; + } + if (ignoreJavaDoc && !haveSameJavaDoc(method, superMethod)) { + return; + } + if (ignoreAnnotations && !methodsHaveSameAnnotations(method, superMethod)) { + return; + } + registerMethodError(method); + return; + } } - if (!annotationsSet.contains(annotation)) { - return false; + + private boolean methodsHaveSameAnnotations(PsiMethod method, PsiMethod superMethod) { + if (!haveSameAnnotations(method, superMethod)) { + return false; + } + final PsiParameterList superParameterList = superMethod.getParameterList(); + final PsiParameter[] superParameters = superParameterList.getParameters(); + final PsiParameterList parameterList = method.getParameterList(); + final PsiParameter[] parameters = parameterList.getParameters(); + for (int i = 0, length = superParameters.length; i < length; i++) { + final PsiParameter superParameter = superParameters[i]; + final PsiParameter parameter = parameters[i]; + if (!haveSameAnnotations(parameter, superParameter)) { + return false; + } + } + return true; } - } - return true; - } - private boolean haveSameJavaDoc(PsiMethod method, PsiMethod superMethod) { - final PsiDocComment superDocComment = superMethod.getDocComment(); - final PsiDocComment docComment = method.getDocComment(); - if (superDocComment == null) { - if (docComment != null) { - return false; + private boolean haveSameAnnotations(PsiModifierListOwner owner1, PsiModifierListOwner owner2) { + final PsiModifierList modifierList = owner1.getModifierList(); + final PsiModifierList superModifierList = owner2.getModifierList(); + if (superModifierList == null) { + return modifierList == null; + } + else if (modifierList == null) { + return false; + } + final PsiAnnotation[] superAnnotations = superModifierList.getAnnotations(); + final PsiAnnotation[] annotations = modifierList.getAnnotations(); + final Set annotationsSet = new HashSet(Arrays.asList(superAnnotations)); + for (PsiAnnotation annotation : annotations) { + final String qualifiedName = annotation.getQualifiedName(); + if (CommonClassNames.JAVA_LANG_OVERRIDE.equals(qualifiedName)) { + continue; + } + if (!annotationsSet.contains(annotation)) { + return false; + } + } + return true; } - } else if (docComment != null) { - if (!superDocComment.getText().equals(docComment.getText())) { - return false; + + private boolean haveSameJavaDoc(PsiMethod method, PsiMethod superMethod) { + final PsiDocComment superDocComment = superMethod.getDocComment(); + final PsiDocComment docComment = method.getDocComment(); + if (superDocComment == null) { + if (docComment != null) { + return false; + } + } + else if (docComment != null) { + if (!superDocComment.getText().equals(docComment.getText())) { + return false; + } + } + return true; } - } - return true; - } - private boolean haveSameExceptionSignatures(PsiMethod method1, PsiMethod method2) { - final PsiReferenceList list1 = method1.getThrowsList(); - final PsiClassType[] exceptions1 = list1.getReferencedTypes(); - final PsiReferenceList list2 = method2.getThrowsList(); - final PsiClassType[] exceptions2 = list2.getReferencedTypes(); - if (exceptions1.length != exceptions2.length) { - return false; - } - final Set set1 = new HashSet(Arrays.asList(exceptions1)); - for (PsiClassType anException : exceptions2) { - if (!set1.contains(anException)) { - return false; + private boolean haveSameExceptionSignatures(PsiMethod method1, PsiMethod method2) { + final PsiReferenceList list1 = method1.getThrowsList(); + final PsiClassType[] exceptions1 = list1.getReferencedTypes(); + final PsiReferenceList list2 = method2.getThrowsList(); + final PsiClassType[] exceptions2 = list2.getReferencedTypes(); + if (exceptions1.length != exceptions2.length) { + return false; + } + final Set set1 = new HashSet(Arrays.asList(exceptions1)); + for (PsiClassType anException : exceptions2) { + if (!set1.contains(anException)) { + return false; + } + } + return true; } - } - return true; - } - private boolean methodsHaveSameReturnTypes(PsiMethod method1, PsiMethod method2) { - final PsiType type1 = method1.getReturnType(); - if (type1 == null) { - return false; - } - final PsiClass superClass = method2.getContainingClass(); - final PsiClass aClass = method1.getContainingClass(); - if (aClass == null || superClass == null) return false; - final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); - final PsiType type2 = method2.getReturnType(); - return Comparing.equal(TypeConversionUtil.erasure(type1), TypeConversionUtil.erasure(substitutor.substitute(type2))); - } + private boolean methodsHaveSameReturnTypes(PsiMethod method1, PsiMethod method2) { + final PsiType type1 = method1.getReturnType(); + if (type1 == null) { + return false; + } + final PsiClass superClass = method2.getContainingClass(); + final PsiClass aClass = method1.getContainingClass(); + if (aClass == null || superClass == null) { + return false; + } + final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); + final PsiType type2 = method2.getReturnType(); + return Comparing.equal(TypeConversionUtil.erasure(type1), TypeConversionUtil.erasure(substitutor.substitute(type2))); + } - private boolean isAbstract(PsiMethod method) { - if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { - return true; - } - final PsiClass containingClass = method.getContainingClass(); - return containingClass != null && containingClass.isInterface(); + private boolean isAbstract(PsiMethod method) { + if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { + return true; + } + final PsiClass containingClass = method.getContainingClass(); + return containingClass != null && containingClass.isInterface(); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java index 692d29cd69..067e648908 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java @@ -23,63 +23,62 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl -public class AbstractMethodOverridesConcreteMethodInspection - extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractMethodOverridesConcreteMethodDisplayName().get(); - } +public class AbstractMethodOverridesConcreteMethodInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractMethodOverridesConcreteMethodDisplayName(); + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractMethodOverridesConcreteMethodProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractMethodOverridesConcreteMethodProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new AbstractMethodOverridesConcreteMethodVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new AbstractMethodOverridesConcreteMethodVisitor(); + } - private static class AbstractMethodOverridesConcreteMethodVisitor - extends BaseInspectionVisitor { + private static class AbstractMethodOverridesConcreteMethodVisitor + extends BaseInspectionVisitor { - @Override - public void visitMethod(@Nonnull PsiMethod method) { - //no call to super, so we don't drill into anonymous classes - if (method.isConstructor()) { - return; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return; - } - if (containingClass.isInterface() || - containingClass.isAnnotationType()) { - return; - } - if (!method.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - final PsiMethod[] superMethods = method.findSuperMethods(); - for (final PsiMethod superMethod : superMethods) { - final PsiClass superClass = superMethod.getContainingClass(); - if (superClass == null) { - continue; - } - final String superClassName = superClass.getQualifiedName(); - if (!superClass.isInterface() && - !CommonClassNames.JAVA_LANG_OBJECT.equals(superClassName) && - !superMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { - registerMethodError(method); - return; + @Override + public void visitMethod(@Nonnull PsiMethod method) { + //no call to super, so we don't drill into anonymous classes + if (method.isConstructor()) { + return; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return; + } + if (containingClass.isInterface() || + containingClass.isAnnotationType()) { + return; + } + if (!method.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + final PsiMethod[] superMethods = method.findSuperMethods(); + for (final PsiMethod superMethod : superMethods) { + final PsiClass superClass = superMethod.getContainingClass(); + if (superClass == null) { + continue; + } + final String superClassName = superClass.getQualifiedName(); + if (!superClass.isInterface() && + !CommonClassNames.JAVA_LANG_OBJECT.equals(superClassName) && + !superMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + registerMethodError(method); + return; + } + } } - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodWithMissingImplementationsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodWithMissingImplementationsInspection.java index fba597607b..abacb8cf23 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodWithMissingImplementationsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodWithMissingImplementationsInspection.java @@ -27,6 +27,7 @@ import consulo.application.progress.ProgressManager; import consulo.content.scope.SearchScope; import consulo.language.psi.PsiManager; +import consulo.localize.LocalizeValue; import consulo.util.lang.Pair; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -35,134 +36,116 @@ import java.util.List; @ExtensionImpl -public class AbstractMethodWithMissingImplementationsInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractMethodWithMissingImplementationsDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractMethodWithMissingImplementationsProblemDescriptor().get(); - } - - public BaseInspectionVisitor buildVisitor() { - return new AbstractMethodWithMissingImplementationsVisitor(); - } - - private static class AbstractMethodWithMissingImplementationsVisitor - extends BaseInspectionVisitor { - +public class AbstractMethodWithMissingImplementationsInspection extends BaseInspection { + @Nonnull @Override - public void visitMethod(PsiMethod method) { - super.visitMethod(method); - if (method.getNameIdentifier() == null) { - return; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return; - } - if (!containingClass.isInterface() && - !method.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - final InheritorFinder inheritorFinder = - new InheritorFinder(containingClass); - for (final PsiClass inheritor : inheritorFinder.getInheritors()) { - if (!inheritor.isInterface() && - !inheritor.hasModifierProperty(PsiModifier.ABSTRACT)) { - if (!hasMatchingImplementation(inheritor, method)) { - registerMethodError(method); - return; - } - } - } + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractMethodWithMissingImplementationsDisplayName(); + } + + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractMethodWithMissingImplementationsProblemDescriptor().get(); } - private static boolean hasMatchingImplementation( - @Nonnull PsiClass aClass, - @Nonnull PsiMethod method) { - final PsiMethod overridingMethod = - findOverridingMethod(aClass, method); - if (overridingMethod == null || - overridingMethod.hasModifierProperty(PsiModifier.STATIC)) { - return false; - } - if (!method.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { - return true; - } - final PsiClass superClass = method.getContainingClass(); - final PsiManager manager = overridingMethod.getManager(); - final JavaPsiFacade facade = - JavaPsiFacade.getInstance(manager.getProject()); - return facade.arePackagesTheSame(superClass, aClass); + public BaseInspectionVisitor buildVisitor() { + return new AbstractMethodWithMissingImplementationsVisitor(); } - /** - * @param method the method of which to find an override. - * @param aClass subclass to find the method in. - * @return the overriding method. - */ - @Nullable - private static PsiMethod findOverridingMethod( - PsiClass aClass, @Nonnull PsiMethod method) { - final PsiClass superClass = method.getContainingClass(); - if (aClass.equals(superClass)) { - return null; - } - final PsiSubstitutor substitutor = - TypeConversionUtil.getSuperClassSubstitutor(superClass, - aClass, PsiSubstitutor.EMPTY); - final MethodSignature signature = method.getSignature(substitutor); - final List> pairs = - aClass.findMethodsAndTheirSubstitutorsByName( - signature.getName(), true); - for (Pair pair : pairs) { - final PsiMethod overridingMethod = pair.first; - if (overridingMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { - continue; + private static class AbstractMethodWithMissingImplementationsVisitor extends BaseInspectionVisitor { + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + if (method.getNameIdentifier() == null) { + return; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return; + } + if (!containingClass.isInterface() && !method.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + final InheritorFinder inheritorFinder = new InheritorFinder(containingClass); + for (final PsiClass inheritor : inheritorFinder.getInheritors()) { + if (!inheritor.isInterface() && + !inheritor.hasModifierProperty(PsiModifier.ABSTRACT)) { + if (!hasMatchingImplementation(inheritor, method)) { + registerMethodError(method); + return; + } + } + } } - final PsiClass containingClass = - overridingMethod.getContainingClass(); - if (containingClass.isInterface()) { - continue; + + private static boolean hasMatchingImplementation(@Nonnull PsiClass aClass, @Nonnull PsiMethod method) { + final PsiMethod overridingMethod = findOverridingMethod(aClass, method); + if (overridingMethod == null || overridingMethod.hasModifierProperty(PsiModifier.STATIC)) { + return false; + } + if (!method.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { + return true; + } + final PsiClass superClass = method.getContainingClass(); + final PsiManager manager = overridingMethod.getManager(); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); + return facade.arePackagesTheSame(superClass, aClass); } - final PsiSubstitutor overridingSubstitutor = pair.second; - final MethodSignature foundMethodSignature = - overridingMethod.getSignature(overridingSubstitutor); - if (MethodSignatureUtil.isSubsignature(signature, - foundMethodSignature) && overridingMethod != method) { - return overridingMethod; + + /** + * @param method the method of which to find an override. + * @param aClass subclass to find the method in. + * @return the overriding method. + */ + @Nullable + private static PsiMethod findOverridingMethod( + PsiClass aClass, @Nonnull PsiMethod method + ) { + final PsiClass superClass = method.getContainingClass(); + if (aClass.equals(superClass)) { + return null; + } + final PsiSubstitutor substitutor = + TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); + final MethodSignature signature = method.getSignature(substitutor); + final List> pairs = aClass.findMethodsAndTheirSubstitutorsByName(signature.getName(), true); + for (Pair pair : pairs) { + final PsiMethod overridingMethod = pair.first; + if (overridingMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + continue; + } + final PsiClass containingClass = overridingMethod.getContainingClass(); + if (containingClass.isInterface()) { + continue; + } + final PsiSubstitutor overridingSubstitutor = pair.second; + final MethodSignature foundMethodSignature = overridingMethod.getSignature(overridingSubstitutor); + if (MethodSignatureUtil.isSubsignature(signature, foundMethodSignature) && overridingMethod != method) { + return overridingMethod; + } + } + return null; } - } - return null; } - } - private static class InheritorFinder implements Runnable { + private static class InheritorFinder implements Runnable { + private final PsiClass aClass; + private Collection inheritors = null; - private final PsiClass aClass; - private Collection inheritors = null; - - InheritorFinder(PsiClass aClass) { - this.aClass = aClass; - } + InheritorFinder(PsiClass aClass) { + this.aClass = aClass; + } - public void run() { - final SearchScope searchScope = aClass.getUseScope(); - inheritors = ClassInheritorsSearch.search(aClass, searchScope, true) - .findAll(); - } + public void run() { + final SearchScope searchScope = aClass.getUseScope(); + inheritors = ClassInheritorsSearch.search(aClass, searchScope, true).findAll(); + } - public Collection getInheritors() { - final ProgressManager progressManager = - ProgressManager.getInstance(); - // do not display progress - progressManager.runProcess(this, null); - return inheritors; + public Collection getInheritors() { + final ProgressManager progressManager = ProgressManager.getInstance(); + // do not display progress + progressManager.runProcess(this, null); + return inheritors; + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsAnnotationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsAnnotationInspection.java index 554d7b1908..16413975c6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsAnnotationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsAnnotationInspection.java @@ -25,71 +25,77 @@ import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class ExtendsAnnotationInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "ClassExplicitlyAnnotation"; + } - @Nonnull - public String getID() { - return "ClassExplicitlyAnnotation"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.extendsAnnotationDisplayName().get(); - } - - public boolean isEnabledByDefault() { - return true; - } - - @Nonnull - @RequiredReadAction - public String buildErrorString(Object... infos) { - final PsiClass containingClass = (PsiClass)infos[0]; - return InspectionGadgetsLocalize.extendsAnnotationProblemDescriptor(containingClass.getName()).get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.extendsAnnotationDisplayName(); + } - public BaseInspectionVisitor buildVisitor() { - return new ExtendsAnnotationVisitor(); - } + public boolean isEnabledByDefault() { + return true; + } - private static class ExtendsAnnotationVisitor - extends BaseInspectionVisitor { + @Nonnull + @RequiredReadAction + public String buildErrorString(Object... infos) { + final PsiClass containingClass = (PsiClass) infos[0]; + return InspectionGadgetsLocalize.extendsAnnotationProblemDescriptor(containingClass.getName()).get(); + } - @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (!PsiUtil.isLanguageLevel5OrHigher(aClass)) { - return; - } - if (aClass.isAnnotationType()) { - return; - } - final PsiReferenceList extendsList = aClass.getExtendsList(); - checkReferenceList(extendsList, aClass); - final PsiReferenceList implementsList = aClass.getImplementsList(); - checkReferenceList(implementsList, aClass); + public BaseInspectionVisitor buildVisitor() { + return new ExtendsAnnotationVisitor(); } - private void checkReferenceList(PsiReferenceList referenceList, - PsiClass containingClass) { - if (referenceList == null) { - return; - } - final PsiJavaCodeReferenceElement[] elements = - referenceList.getReferenceElements(); - for (final PsiJavaCodeReferenceElement element : elements) { - final PsiElement referent = element.resolve(); - if (!(referent instanceof PsiClass)) { - continue; + private static class ExtendsAnnotationVisitor + extends BaseInspectionVisitor { + + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (!PsiUtil.isLanguageLevel5OrHigher(aClass)) { + return; + } + if (aClass.isAnnotationType()) { + return; + } + final PsiReferenceList extendsList = aClass.getExtendsList(); + checkReferenceList(extendsList, aClass); + final PsiReferenceList implementsList = aClass.getImplementsList(); + checkReferenceList(implementsList, aClass); } - final PsiClass psiClass = (PsiClass)referent; - psiClass.isAnnotationType(); - if (psiClass.isAnnotationType()) { - registerError(element, containingClass); + + private void checkReferenceList( + PsiReferenceList referenceList, + PsiClass containingClass + ) { + if (referenceList == null) { + return; + } + final PsiJavaCodeReferenceElement[] elements = + referenceList.getReferenceElements(); + for (final PsiJavaCodeReferenceElement element : elements) { + final PsiElement referent = element.resolve(); + if (!(referent instanceof PsiClass)) { + continue; + } + final PsiClass psiClass = (PsiClass) referent; + psiClass.isAnnotationType(); + if (psiClass.isAnnotationType()) { + registerError(element, containingClass); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsUtilityClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsUtilityClassInspection.java index 7ebccaba00..3eda6e13a5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsUtilityClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/ExtendsUtilityClassInspection.java @@ -32,58 +32,57 @@ @ExtensionImpl public class ExtendsUtilityClassInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean ignoreUtilityClasses = false; - @SuppressWarnings("PublicField") - public boolean ignoreUtilityClasses = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.classExtendsUtilityClassDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.classExtendsUtilityClassDisplayName(); + } - @Override - @Nonnull - @RequiredReadAction - protected String buildErrorString(Object... infos) { - final PsiClass superClass = (PsiClass)infos[0]; - final String superClassName = superClass.getName(); - return InspectionGadgetsLocalize.classExtendsUtilityClassProblemDescriptor(superClassName).get(); - } + @Override + @Nonnull + @RequiredReadAction + protected String buildErrorString(Object... infos) { + final PsiClass superClass = (PsiClass) infos[0]; + final String superClassName = superClass.getName(); + return InspectionGadgetsLocalize.classExtendsUtilityClassProblemDescriptor(superClassName).get(); + } - @Nullable - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.classExtendsUtilityClassIgnoreUtilityClassOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreUtilityClasses"); - } + @Nullable + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.classExtendsUtilityClassIgnoreUtilityClassOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreUtilityClasses"); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new ClassExtendsUtilityClassVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new ClassExtendsUtilityClassVisitor(); + } - private class ClassExtendsUtilityClassVisitor extends BaseInspectionVisitor { + private class ClassExtendsUtilityClassVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(PsiClass aClass) { - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - final PsiClass superClass = aClass.getSuperClass(); - if (superClass == null) { - return; - } - if (superClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - if (!UtilityClassUtil.isUtilityClass(superClass)) { - return; - } - if (ignoreUtilityClasses && UtilityClassUtil.isUtilityClass(aClass, false)) { - return; - } - registerClassError(aClass, superClass); + @Override + public void visitClass(PsiClass aClass) { + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + final PsiClass superClass = aClass.getSuperClass(); + if (superClass == null) { + return; + } + if (superClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + if (!UtilityClassUtil.isUtilityClass(superClass)) { + return; + } + if (ignoreUtilityClasses && UtilityClassUtil.isUtilityClass(aClass, false)) { + return; + } + registerClassError(aClass, superClass); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/InterfaceNeverImplementedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/InterfaceNeverImplementedInspection.java index 62e66391f5..29b1d9a1c3 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/InterfaceNeverImplementedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/InterfaceNeverImplementedInspection.java @@ -30,48 +30,48 @@ @ExtensionImpl public class InterfaceNeverImplementedInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean ignoreInterfacesThatOnlyDeclareConstants = false; - /** - * @noinspection PublicField - */ - public boolean ignoreInterfacesThatOnlyDeclareConstants = false; - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.interfaceNeverImplementedDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.interfaceNeverImplementedDisplayName(); + } - @Nullable - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.interfaceNeverImplementedOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreInterfacesThatOnlyDeclareConstants"); - } + @Nullable + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.interfaceNeverImplementedOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreInterfacesThatOnlyDeclareConstants"); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.interfaceNeverImplementedProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.interfaceNeverImplementedProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new InterfaceNeverImplementedVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new InterfaceNeverImplementedVisitor(); + } - private class InterfaceNeverImplementedVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (!aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (ignoreInterfacesThatOnlyDeclareConstants && - aClass.getMethods().length == 0) { - if (aClass.getFields().length != 0) { - return; + private class InterfaceNeverImplementedVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (!aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (ignoreInterfacesThatOnlyDeclareConstants && + aClass.getMethods().length == 0) { + if (aClass.getFields().length != 0) { + return; + } + } + if (InheritanceUtil.hasImplementation(aClass)) { + return; + } + registerClassError(aClass); } - } - if (InheritanceUtil.hasImplementation(aClass)) { - return; - } - registerClassError(aClass); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/NonProtectedConstructorInAbstractClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/NonProtectedConstructorInAbstractClassInspection.java index d59ac4627c..4e2b4ad261 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/NonProtectedConstructorInAbstractClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/NonProtectedConstructorInAbstractClassInspection.java @@ -31,77 +31,75 @@ import javax.swing.*; @ExtensionImpl -public class NonProtectedConstructorInAbstractClassInspection - extends BaseInspection { +public class NonProtectedConstructorInAbstractClassInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignoreNonPublicClasses = false; - /** - * @noinspection PublicField - */ - public boolean m_ignoreNonPublicClasses = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassDisplayName(); + } - @Override - @Nonnull - public String getID() { - return "ConstructorNotProtectedInAbstractClass"; - } + @Override + @Nonnull + public String getID() { + return "ConstructorNotProtectedInAbstractClass"; + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassProblemDescriptor().get(); + } - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignoreNonPublicClasses"); - } + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.nonProtectedConstructorInAbstractClassIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignoreNonPublicClasses"); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new NonProtectedConstructorInAbstractClassVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new NonProtectedConstructorInAbstractClassVisitor(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new ChangeModifierFix(PsiModifier.PROTECTED); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new ChangeModifierFix(PsiModifier.PROTECTED); + } - private class NonProtectedConstructorInAbstractClassVisitor - extends BaseInspectionVisitor { + private class NonProtectedConstructorInAbstractClassVisitor + extends BaseInspectionVisitor { - @Override - public void visitMethod(@Nonnull PsiMethod method) { - //no call to super, so we don't drill into anonymous classes - if (!method.isConstructor()) { - return; - } - if (method.hasModifierProperty(PsiModifier.PROTECTED) - || method.hasModifierProperty(PsiModifier.PRIVATE) - || method.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { - return; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return; - } - if (m_ignoreNonPublicClasses && - !containingClass.hasModifierProperty(PsiModifier.PUBLIC)) { - return; - } - if (!containingClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - if (containingClass.isEnum()) { - return; - } - registerMethodError(method); + @Override + public void visitMethod(@Nonnull PsiMethod method) { + //no call to super, so we don't drill into anonymous classes + if (!method.isConstructor()) { + return; + } + if (method.hasModifierProperty(PsiModifier.PROTECTED) + || method.hasModifierProperty(PsiModifier.PRIVATE) + || method.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { + return; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return; + } + if (m_ignoreNonPublicClasses && + !containingClass.hasModifierProperty(PsiModifier.PUBLIC)) { + return; + } + if (!containingClass.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + if (containingClass.isEnum()) { + return; + } + registerMethodError(method); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RedundantMethodOverrideInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RedundantMethodOverrideInspection.java index e19ecd4f67..9a77f7d6d7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RedundantMethodOverrideInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RedundantMethodOverrideInspection.java @@ -35,276 +35,227 @@ import consulo.language.psi.search.PsiSearchHelper; import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @ExtensionImpl -public class RedundantMethodOverrideInspection extends BaseInspection -{ +public class RedundantMethodOverrideInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.redundantMethodOverrideDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() - { - return InspectionGadgetsLocalize.redundantMethodOverrideDisplayName().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.redundantMethodOverrideProblemDescriptor().get(); + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) - { - return InspectionGadgetsLocalize.redundantMethodOverrideProblemDescriptor().get(); - } + @Override + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + return new RedundantMethodOverrideFix(); + } - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) - { - return new RedundantMethodOverrideFix(); - } + private static class RedundantMethodOverrideFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.redundantMethodOverrideQuickfix(); + } - private static class RedundantMethodOverrideFix extends InspectionGadgetsFix - { + @Override + public void doFix(Project project, ProblemDescriptor descriptor) { + final PsiElement methodNameIdentifier = descriptor.getPsiElement(); + final PsiElement method = methodNameIdentifier.getParent(); + assert method != null; + deleteElement(method); + } + } - @Override - @Nonnull - public String getFamilyName() - { - return InspectionGadgetsLocalize.redundantMethodOverrideQuickfix().get(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new RedundantMethodOverrideVisitor(); + } - @Override - public void doFix(Project project, ProblemDescriptor descriptor) - { - final PsiElement methodNameIdentifier = descriptor.getPsiElement(); - final PsiElement method = methodNameIdentifier.getParent(); - assert method != null; - deleteElement(method); - } - } + private static class RedundantMethodOverrideVisitor extends BaseInspectionVisitor { + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + final PsiCodeBlock body = method.getBody(); + if (body == null) { + return; + } + if (method.getNameIdentifier() == null) { + return; + } + final PsiMethod superMethod = MethodUtils.getSuper(method); + if (superMethod == null) { + return; + } + if (!modifierListsAreEquivalent(method.getModifierList(), superMethod.getModifierList())) { + return; + } + final PsiType superReturnType = superMethod.getReturnType(); + if (superReturnType == null || !superReturnType.equals(method.getReturnType())) { + return; + } + if (method.hasModifierProperty(PsiModifier.FINAL)) { + return; // method overridden and made final - not redundant + } + final PsiCodeBlock superBody = superMethod.getBody(); - @Override - public BaseInspectionVisitor buildVisitor() - { - return new RedundantMethodOverrideVisitor(); - } + EquivalenceChecker checker = new ParameterEquivalenceChecker(method, superMethod); + if (checker.codeBlocksAreEquivalent(body, superBody) || isSuperCallWithSameArguments(body, method, superMethod)) { + registerMethodError(method); + } + } - private static class RedundantMethodOverrideVisitor extends BaseInspectionVisitor - { - @Override - public void visitMethod(PsiMethod method) - { - super.visitMethod(method); - final PsiCodeBlock body = method.getBody(); - if(body == null) - { - return; - } - if(method.getNameIdentifier() == null) - { - return; - } - final PsiMethod superMethod = MethodUtils.getSuper(method); - if(superMethod == null) - { - return; - } - if(!modifierListsAreEquivalent(method.getModifierList(), superMethod.getModifierList())) - { - return; - } - final PsiType superReturnType = superMethod.getReturnType(); - if(superReturnType == null || !superReturnType.equals(method.getReturnType())) - { - return; - } - if(method.hasModifierProperty(PsiModifier.FINAL)) - { - return; // method overridden and made final - not redundant - } - final PsiCodeBlock superBody = superMethod.getBody(); + private static class ParameterEquivalenceChecker extends EquivalenceChecker { + private final PsiMethod myMethod; + private final PsiMethod mySuperMethod; - EquivalenceChecker checker = new ParameterEquivalenceChecker(method, superMethod); - if(checker.codeBlocksAreEquivalent(body, superBody) || isSuperCallWithSameArguments(body, method, superMethod)) - { - registerMethodError(method); - } - } + ParameterEquivalenceChecker(@Nonnull PsiMethod method, @Nonnull PsiMethod superMethod) { + myMethod = method; + mySuperMethod = superMethod; + } - private static class ParameterEquivalenceChecker extends EquivalenceChecker - { - private final PsiMethod myMethod; - private final PsiMethod mySuperMethod; + @Override + protected Decision referenceExpressionsAreEquivalentDecision( + PsiReferenceExpression referenceExpression1, + PsiReferenceExpression referenceExpression2 + ) { + if (areSameParameters(referenceExpression1, referenceExpression2)) { + return EXACTLY_MATCHES; + } + return super.referenceExpressionsAreEquivalentDecision(referenceExpression1, referenceExpression2); + } - ParameterEquivalenceChecker(@Nonnull PsiMethod method, @Nonnull PsiMethod superMethod) - { - myMethod = method; - mySuperMethod = superMethod; - } + private boolean areSameParameters(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) { + // parameters of super method and overridden method should be considered the same + PsiElement resolved1 = referenceExpression1.resolve(); + PsiElement resolved2 = referenceExpression2.resolve(); + if (!(resolved1 instanceof PsiParameter) || !(resolved2 instanceof PsiParameter)) { + return false; + } + PsiElement scope1 = ((PsiParameter) resolved1).getDeclarationScope(); + PsiElement scope2 = ((PsiParameter) resolved2).getDeclarationScope(); + if (scope1 == scope2 || scope1 != myMethod && scope1 != mySuperMethod || scope2 != myMethod && scope2 != mySuperMethod) { + return false; + } + PsiElement parent1 = resolved1.getParent(); + PsiElement parent2 = resolved2.getParent(); + if (!(parent1 instanceof PsiParameterList) || !(parent2 instanceof PsiParameterList)) { + return false; + } + int index1 = ((PsiParameterList) parent1).getParameterIndex((PsiParameter) resolved1); + int index2 = ((PsiParameterList) parent2).getParameterIndex((PsiParameter) resolved2); - @Override - protected Decision referenceExpressionsAreEquivalentDecision(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) - { - if(areSameParameters(referenceExpression1, referenceExpression2)) - { - return EXACTLY_MATCHES; - } - return super.referenceExpressionsAreEquivalentDecision(referenceExpression1, referenceExpression2); - } + return index1 == index2; + } + } - private boolean areSameParameters(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) - { - // parameters of super method and overridden method should be considered the same - PsiElement resolved1 = referenceExpression1.resolve(); - PsiElement resolved2 = referenceExpression2.resolve(); - if(!(resolved1 instanceof PsiParameter) || !(resolved2 instanceof PsiParameter)) - { - return false; - } - PsiElement scope1 = ((PsiParameter) resolved1).getDeclarationScope(); - PsiElement scope2 = ((PsiParameter) resolved2).getDeclarationScope(); - if(scope1 == scope2 || scope1 != myMethod && scope1 != mySuperMethod || scope2 != myMethod && scope2 != mySuperMethod) - { - return false; - } - PsiElement parent1 = resolved1.getParent(); - PsiElement parent2 = resolved2.getParent(); - if(!(parent1 instanceof PsiParameterList) || !(parent2 instanceof PsiParameterList)) - { - return false; - } - int index1 = ((PsiParameterList) parent1).getParameterIndex((PsiParameter) resolved1); - int index2 = ((PsiParameterList) parent2).getParameterIndex((PsiParameter) resolved2); + private boolean isSuperCallWithSameArguments(PsiCodeBlock body, PsiMethod method, PsiMethod superMethod) { + final PsiStatement[] statements = body.getStatements(); + if (statements.length != 1) { + return false; + } + final PsiStatement statement = statements[0]; + final PsiExpression expression; + if (PsiType.VOID.equals(method.getReturnType())) { + if (statement instanceof PsiExpressionStatement) { + final PsiExpressionStatement expressionStatement = (PsiExpressionStatement) statement; + expression = expressionStatement.getExpression(); + } + else { + return false; + } + } + else { + if (statement instanceof PsiReturnStatement) { + final PsiReturnStatement returnStatement = (PsiReturnStatement) statement; + expression = ParenthesesUtils.stripParentheses(returnStatement.getReturnValue()); + } + else { + return false; + } + } + if (!(expression instanceof PsiMethodCallExpression)) { + return false; + } + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression; + if (!MethodCallUtils.isSuperMethodCall(methodCallExpression, method)) { + return false; + } - return index1 == index2; - } - } + if (superMethod.hasModifierProperty(PsiModifier.PROTECTED)) { + final PsiJavaFile file = (PsiJavaFile) method.getContainingFile(); + // implementing a protected method in another package makes it available to that package. + PsiJavaPackage aPackage = JavaPsiFacade.getInstance(method.getProject()).findPackage(file.getPackageName()); + if (aPackage == null) { + return false; // when package statement is incorrect + } + final PackageScope scope = new PackageScope(aPackage, false, false); + if (isOnTheFly()) { + final PsiSearchHelper searchHelper = PsiSearchHelper.SERVICE.getInstance(method.getProject()); + final PsiSearchHelper.SearchCostResult cost = searchHelper.isCheapEnoughToSearch(method.getName(), scope, null, null); + if (cost == PsiSearchHelper.SearchCostResult.ZERO_OCCURRENCES) { + return true; + } + if (cost == PsiSearchHelper.SearchCostResult.TOO_MANY_OCCURRENCES) { + return false; + } + } + final Query search = ReferencesSearch.search(method, scope); + final PsiClass containingClass = method.getContainingClass(); + for (PsiReference reference : search) { + if (!PsiTreeUtil.isAncestor(containingClass, reference.getElement(), true)) { + return false; + } + } + } - private boolean isSuperCallWithSameArguments(PsiCodeBlock body, PsiMethod method, PsiMethod superMethod) - { - final PsiStatement[] statements = body.getStatements(); - if(statements.length != 1) - { - return false; - } - final PsiStatement statement = statements[0]; - final PsiExpression expression; - if(PsiType.VOID.equals(method.getReturnType())) - { - if(statement instanceof PsiExpressionStatement) - { - final PsiExpressionStatement expressionStatement = (PsiExpressionStatement) statement; - expression = expressionStatement.getExpression(); - } - else - { - return false; - } - } - else - { - if(statement instanceof PsiReturnStatement) - { - final PsiReturnStatement returnStatement = (PsiReturnStatement) statement; - expression = ParenthesesUtils.stripParentheses(returnStatement.getReturnValue()); - } - else - { - return false; - } - } - if(!(expression instanceof PsiMethodCallExpression)) - { - return false; - } - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression; - if(!MethodCallUtils.isSuperMethodCall(methodCallExpression, method)) - { - return false; - } + return areSameArguments(methodCallExpression, method); + } - if(superMethod.hasModifierProperty(PsiModifier.PROTECTED)) - { - final PsiJavaFile file = (PsiJavaFile) method.getContainingFile(); - // implementing a protected method in another package makes it available to that package. - PsiJavaPackage aPackage = JavaPsiFacade.getInstance(method.getProject()).findPackage(file.getPackageName()); - if(aPackage == null) - { - return false; // when package statement is incorrect - } - final PackageScope scope = new PackageScope(aPackage, false, false); - if(isOnTheFly()) - { - final PsiSearchHelper searchHelper = PsiSearchHelper.SERVICE.getInstance(method.getProject()); - final PsiSearchHelper.SearchCostResult cost = searchHelper.isCheapEnoughToSearch(method.getName(), scope, null, null); - if(cost == PsiSearchHelper.SearchCostResult.ZERO_OCCURRENCES) - { - return true; - } - if(cost == PsiSearchHelper.SearchCostResult.TOO_MANY_OCCURRENCES) - { - return false; - } - } - final Query search = ReferencesSearch.search(method, scope); - final PsiClass containingClass = method.getContainingClass(); - for(PsiReference reference : search) - { - if(!PsiTreeUtil.isAncestor(containingClass, reference.getElement(), true)) - { - return false; - } - } - } + private static boolean areSameArguments(PsiMethodCallExpression methodCallExpression, PsiMethod method) { + // void foo(int param) { super.foo(42); } is not redundant + PsiExpression[] arguments = methodCallExpression.getArgumentList().getExpressions(); + PsiParameter[] parameters = method.getParameterList().getParameters(); + if (arguments.length != parameters.length) { + return false; + } + for (int i = 0; i < arguments.length; i++) { + PsiExpression argument = arguments[i]; + PsiExpression exp = PsiUtil.deparenthesizeExpression(argument); + if (!(exp instanceof PsiReferenceExpression)) { + return false; + } + PsiElement resolved = ((PsiReferenceExpression) exp).resolve(); + if (!method.getManager().areElementsEquivalent(parameters[i], resolved)) { + return false; + } + } + return true; + } - return areSameArguments(methodCallExpression, method); - } - - private static boolean areSameArguments(PsiMethodCallExpression methodCallExpression, PsiMethod method) - { - // void foo(int param) { super.foo(42); } is not redundant - PsiExpression[] arguments = methodCallExpression.getArgumentList().getExpressions(); - PsiParameter[] parameters = method.getParameterList().getParameters(); - if(arguments.length != parameters.length) - { - return false; - } - for(int i = 0; i < arguments.length; i++) - { - PsiExpression argument = arguments[i]; - PsiExpression exp = PsiUtil.deparenthesizeExpression(argument); - if(!(exp instanceof PsiReferenceExpression)) - { - return false; - } - PsiElement resolved = ((PsiReferenceExpression) exp).resolve(); - if(!method.getManager().areElementsEquivalent(parameters[i], resolved)) - { - return false; - } - } - return true; - } - - private static boolean modifierListsAreEquivalent(@Nullable PsiModifierList list1, @Nullable PsiModifierList list2) - { - if(list1 == null) - { - return list2 == null; - } - else if(list2 == null) - { - return false; - } - if(list1.hasModifierProperty(PsiModifier.STRICTFP) != list2.hasModifierProperty(PsiModifier.STRICTFP) || - list1.hasModifierProperty(PsiModifier.SYNCHRONIZED) != list2.hasModifierProperty(PsiModifier.SYNCHRONIZED) || - list1.hasModifierProperty(PsiModifier.PUBLIC) != list2.hasModifierProperty(PsiModifier.PUBLIC) || - list1.hasModifierProperty(PsiModifier.PROTECTED) != list2.hasModifierProperty(PsiModifier.PROTECTED)) - { - return false; - } - return AnnotationUtil.equal(list1.getAnnotations(), list2.getAnnotations()); - } - } + private static boolean modifierListsAreEquivalent(@Nullable PsiModifierList list1, @Nullable PsiModifierList list2) { + if (list1 == null) { + return list2 == null; + } + else if (list2 == null) { + return false; + } + if (list1.hasModifierProperty(PsiModifier.STRICTFP) != list2.hasModifierProperty(PsiModifier.STRICTFP) || + list1.hasModifierProperty(PsiModifier.SYNCHRONIZED) != list2.hasModifierProperty(PsiModifier.SYNCHRONIZED) || + list1.hasModifierProperty(PsiModifier.PUBLIC) != list2.hasModifierProperty(PsiModifier.PUBLIC) || + list1.hasModifierProperty(PsiModifier.PROTECTED) != list2.hasModifierProperty(PsiModifier.PROTECTED)) { + return false; + } + return AnnotationUtil.equal(list1.getAnnotations(), list2.getAnnotations()); + } + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RefusedBequestInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RefusedBequestInspection.java index a708cf75b8..aa85d18dbb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RefusedBequestInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/RefusedBequestInspection.java @@ -24,6 +24,7 @@ import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.util.lang.xml.XmlStringUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -32,161 +33,162 @@ @ExtensionImpl public class RefusedBequestInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean ignoreEmptySuperMethods = false; - @SuppressWarnings("PublicField") public boolean ignoreEmptySuperMethods = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.refusedBequestDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.refusedBequestProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - //noinspection HardCodedStringLiteral - return new SingleCheckboxOptionsPanel( - XmlStringUtil.wrapInHtml(InspectionGadgetsLocalize.refusedBequestIgnoreEmptySuperMethodsOption().get()), - this, - "ignoreEmptySuperMethods" - ); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new RefusedBequestVisitor(); - } - - private class RefusedBequestVisitor extends BaseInspectionVisitor { - + @Nonnull @Override - public void visitMethod(@Nonnull PsiMethod method) { - super.visitMethod(method); - final PsiCodeBlock body = method.getBody(); - if (body == null) { - return; - } - if (method.getNameIdentifier() == null) { - return; - } - final PsiMethod leastConcreteSuperMethod = getLeastConcreteSuperMethod(method); - if (leastConcreteSuperMethod == null) { - return; - } - final PsiClass objectClass = ClassUtils.findObjectClass(method); - final PsiMethod[] superMethods = method.findSuperMethods(objectClass); - if (superMethods.length > 0) { - return; - } - if (ignoreEmptySuperMethods) { - final PsiMethod superMethod = (PsiMethod)leastConcreteSuperMethod.getNavigationElement(); - if (isTrivial(superMethod)) { - return; - } - } - if (TestUtils.isJUnit4BeforeOrAfterMethod(method)) { - return; - } - if (containsSuperCall(body, leastConcreteSuperMethod)) { - return; - } - registerMethodError(method); + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.refusedBequestDisplayName(); } - private boolean isTrivial(PsiMethod method) { - final PsiCodeBlock body = method.getBody(); - if (body == null) { - return true; - } - final PsiStatement[] statements = body.getStatements(); - if (statements.length == 0) { - return true; - } - if (statements.length > 1) { - return false; - } - final PsiStatement statement = statements[0]; - if (statement instanceof PsiThrowStatement) { - return true; - } - if (statement instanceof PsiReturnStatement) { - final PsiReturnStatement returnStatement = (PsiReturnStatement)statement; - final PsiExpression returnValue = returnStatement.getReturnValue(); - if (returnValue instanceof PsiLiteralExpression) { - return true; - } - } - return false; + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.refusedBequestProblemDescriptor().get(); } - @Nullable - private PsiMethod getLeastConcreteSuperMethod(PsiMethod method) { - final PsiMethod[] superMethods = method.findSuperMethods(true); - for (final PsiMethod superMethod : superMethods) { - final PsiClass containingClass = superMethod.getContainingClass(); - if (containingClass != null && !superMethod.hasModifierProperty(PsiModifier.ABSTRACT) && !containingClass.isInterface()) { - return superMethod; - } - } - return null; + @Override + public JComponent createOptionsPanel() { + //noinspection HardCodedStringLiteral + return new SingleCheckboxOptionsPanel( + XmlStringUtil.wrapInHtml(InspectionGadgetsLocalize.refusedBequestIgnoreEmptySuperMethodsOption().get()), + this, + "ignoreEmptySuperMethods" + ); } - private boolean containsSuperCall(@Nonnull PsiElement context, @Nonnull PsiMethod method) { - final SuperCallVisitor visitor = new SuperCallVisitor(method); - context.accept(visitor); - return visitor.hasSuperCall(); + @Override + public BaseInspectionVisitor buildVisitor() { + return new RefusedBequestVisitor(); } - } - private static class SuperCallVisitor extends JavaRecursiveElementVisitor { + private class RefusedBequestVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + super.visitMethod(method); + final PsiCodeBlock body = method.getBody(); + if (body == null) { + return; + } + if (method.getNameIdentifier() == null) { + return; + } + final PsiMethod leastConcreteSuperMethod = getLeastConcreteSuperMethod(method); + if (leastConcreteSuperMethod == null) { + return; + } + final PsiClass objectClass = ClassUtils.findObjectClass(method); + final PsiMethod[] superMethods = method.findSuperMethods(objectClass); + if (superMethods.length > 0) { + return; + } + if (ignoreEmptySuperMethods) { + final PsiMethod superMethod = (PsiMethod) leastConcreteSuperMethod.getNavigationElement(); + if (isTrivial(superMethod)) { + return; + } + } + if (TestUtils.isJUnit4BeforeOrAfterMethod(method)) { + return; + } + if (containsSuperCall(body, leastConcreteSuperMethod)) { + return; + } + registerMethodError(method); + } - private final PsiMethod methodToSearchFor; - private boolean hasSuperCall = false; + private boolean isTrivial(PsiMethod method) { + final PsiCodeBlock body = method.getBody(); + if (body == null) { + return true; + } + final PsiStatement[] statements = body.getStatements(); + if (statements.length == 0) { + return true; + } + if (statements.length > 1) { + return false; + } + final PsiStatement statement = statements[0]; + if (statement instanceof PsiThrowStatement) { + return true; + } + if (statement instanceof PsiReturnStatement) { + final PsiReturnStatement returnStatement = (PsiReturnStatement) statement; + final PsiExpression returnValue = returnStatement.getReturnValue(); + if (returnValue instanceof PsiLiteralExpression) { + return true; + } + } + return false; + } - SuperCallVisitor(PsiMethod methodToSearchFor) { - this.methodToSearchFor = methodToSearchFor; - } + @Nullable + private PsiMethod getLeastConcreteSuperMethod(PsiMethod method) { + final PsiMethod[] superMethods = method.findSuperMethods(true); + for (final PsiMethod superMethod : superMethods) { + final PsiClass containingClass = superMethod.getContainingClass(); + if (containingClass != null && !superMethod.hasModifierProperty(PsiModifier.ABSTRACT) && !containingClass.isInterface()) { + return superMethod; + } + } + return null; + } - @Override - public void visitElement(@Nonnull PsiElement element) { - if (hasSuperCall) { - return; - } - super.visitElement(element); + private boolean containsSuperCall(@Nonnull PsiElement context, @Nonnull PsiMethod method) { + final SuperCallVisitor visitor = new SuperCallVisitor(method); + context.accept(visitor); + return visitor.hasSuperCall(); + } } - @Override - public void visitMethodCallExpression( - @Nonnull PsiMethodCallExpression expression) { - if (hasSuperCall) { - return; - } - super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier == null) { - return; - } - final String text = qualifier.getText(); - if (!PsiKeyword.SUPER.equals(text)) { - return; - } - final PsiMethod method = expression.resolveMethod(); - if (method == null) { - return; - } - if (method.equals(methodToSearchFor)) { - hasSuperCall = true; - } - } + private static class SuperCallVisitor extends JavaRecursiveElementVisitor { + + private final PsiMethod methodToSearchFor; + private boolean hasSuperCall = false; + + SuperCallVisitor(PsiMethod methodToSearchFor) { + this.methodToSearchFor = methodToSearchFor; + } - public boolean hasSuperCall() { - return hasSuperCall; + @Override + public void visitElement(@Nonnull PsiElement element) { + if (hasSuperCall) { + return; + } + super.visitElement(element); + } + + @Override + public void visitMethodCallExpression( + @Nonnull PsiMethodCallExpression expression + ) { + if (hasSuperCall) { + return; + } + super.visitMethodCallExpression(expression); + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier == null) { + return; + } + final String text = qualifier.getText(); + if (!PsiKeyword.SUPER.equals(text)) { + return; + } + final PsiMethod method = expression.resolveMethod(); + if (method == null) { + return; + } + if (method.equals(methodToSearchFor)) { + hasSuperCall = true; + } + } + + public boolean hasSuperCall() { + return hasSuperCall; + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/StaticInheritanceInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/StaticInheritanceInspection.java index b151951dc4..2f1de61a3b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/StaticInheritanceInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/StaticInheritanceInspection.java @@ -23,6 +23,7 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import java.util.HashSet; @@ -30,70 +31,73 @@ @ExtensionImpl public class StaticInheritanceInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.staticInheritanceDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.staticInheritanceDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.staticInheritanceProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.staticInheritanceProblemDescriptor().get(); + } - @Nonnull - @Override - protected InspectionGadgetsFix[] buildFixes(Object... infos) { - return new InspectionGadgetsFix[]{new StaticInheritanceFix(false), new StaticInheritanceFix(true)}; - } + @Nonnull + @Override + protected InspectionGadgetsFix[] buildFixes(Object... infos) { + return new InspectionGadgetsFix[]{new StaticInheritanceFix(false), new StaticInheritanceFix(true)}; + } - public BaseInspectionVisitor buildVisitor() { - return new StaticInheritanceVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new StaticInheritanceVisitor(); + } - private static class StaticInheritanceVisitor - extends BaseInspectionVisitor { + private static class StaticInheritanceVisitor + extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - final PsiReferenceList implementsList = aClass.getImplementsList(); - if (implementsList == null) { - return; - } - final PsiJavaCodeReferenceElement[] references = - implementsList.getReferenceElements(); - for (final PsiJavaCodeReferenceElement reference : references) { - final PsiClass iface = (PsiClass)reference.resolve(); - if (iface != null) { - if (interfaceContainsOnlyConstants(iface, new HashSet())) { - registerError(reference); - } + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + final PsiReferenceList implementsList = aClass.getImplementsList(); + if (implementsList == null) { + return; + } + final PsiJavaCodeReferenceElement[] references = + implementsList.getReferenceElements(); + for (final PsiJavaCodeReferenceElement reference : references) { + final PsiClass iface = (PsiClass) reference.resolve(); + if (iface != null) { + if (interfaceContainsOnlyConstants(iface, new HashSet())) { + registerError(reference); + } + } + } } - } - } - private static boolean interfaceContainsOnlyConstants( - PsiClass iface, Set visitedIntefaces) { - if (!visitedIntefaces.add(iface)) { - return true; - } - if (iface.getAllFields().length == 0) { - // ignore it, it's either a true interface or just a marker - return false; - } - if (iface.getMethods().length != 0) { - return false; - } - final PsiClass[] parentInterfaces = iface.getInterfaces(); - for (final PsiClass parentInterface : parentInterfaces) { - if (!interfaceContainsOnlyConstants(parentInterface, - visitedIntefaces)) { - return false; + private static boolean interfaceContainsOnlyConstants( + PsiClass iface, Set visitedIntefaces + ) { + if (!visitedIntefaces.add(iface)) { + return true; + } + if (iface.getAllFields().length == 0) { + // ignore it, it's either a true interface or just a marker + return false; + } + if (iface.getMethods().length != 0) { + return false; + } + final PsiClass[] parentInterfaces = iface.getInterfaces(); + for (final PsiClass parentInterface : parentInterfaces) { + if (!interfaceContainsOnlyConstants( + parentInterface, + visitedIntefaces + )) { + return false; + } + } + return true; } - } - return true; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/TypeParameterExtendsFinalClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/TypeParameterExtendsFinalClassInspection.java index 61942cf603..713b191716 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/TypeParameterExtendsFinalClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/TypeParameterExtendsFinalClassInspection.java @@ -30,145 +30,144 @@ import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @ExtensionImpl public class TypeParameterExtendsFinalClassInspection extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.typeParameterExtendsFinalClassDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final Integer problemType = (Integer)infos[1]; - final PsiNamedElement namedElement = (PsiNamedElement)infos[0]; - final String name = namedElement.getName(); - return problemType == 1 - ? InspectionGadgetsLocalize.typeParameterExtendsFinalClassProblemDescriptor1(name).get() - : InspectionGadgetsLocalize.typeParameterExtendsFinalClassProblemDescriptor2(name).get(); - } - - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - return new TypeParameterExtendsFinalClassFix(); - } - - private static class TypeParameterExtendsFinalClassFix extends InspectionGadgetsFix { - - @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.typeParameterExtendsFinalClassQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.typeParameterExtendsFinalClassDisplayName(); } @Override - protected void doFix(@Nonnull Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (parent instanceof PsiTypeParameter) { - final PsiTypeParameter typeParameter = (PsiTypeParameter)parent; - replaceTypeParameterAndReferencesWithType(typeParameter); - } - else if (parent instanceof PsiTypeElement) { - final PsiTypeElement typeElement = (PsiTypeElement)parent; - final PsiElement lastChild = typeElement.getLastChild(); - if (lastChild == null) { - return; - } - typeElement.replace(lastChild); - } + @Nonnull + protected String buildErrorString(Object... infos) { + final Integer problemType = (Integer) infos[1]; + final PsiNamedElement namedElement = (PsiNamedElement) infos[0]; + final String name = namedElement.getName(); + return problemType == 1 + ? InspectionGadgetsLocalize.typeParameterExtendsFinalClassProblemDescriptor1(name).get() + : InspectionGadgetsLocalize.typeParameterExtendsFinalClassProblemDescriptor2(name).get(); } - private static void replaceTypeParameterAndReferencesWithType(PsiTypeParameter typeParameter) { - final PsiReferenceList extendsList = typeParameter.getExtendsList(); - final PsiClassType[] referenceElements = extendsList.getReferencedTypes(); - if (referenceElements.length < 1) { - return; - } - final PsiClass finalClass = referenceElements[0].resolve(); - if (finalClass == null) { - return; - } - final Project project = typeParameter.getProject(); - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - final PsiJavaCodeReferenceElement classReference = factory.createClassReferenceElement(finalClass); - final Query query = ReferencesSearch.search(typeParameter, typeParameter.getUseScope()); - for (PsiReference reference : query) { - final PsiElement referenceElement = reference.getElement(); - referenceElement.replace(classReference); - } - typeParameter.delete(); + @Override + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + return new TypeParameterExtendsFinalClassFix(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new TypeParameterExtendsFinalClassVisitor(); - } + private static class TypeParameterExtendsFinalClassFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.typeParameterExtendsFinalClassQuickfix(); + } - private static class TypeParameterExtendsFinalClassVisitor extends BaseInspectionVisitor { + @Override + protected void doFix(@Nonnull Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (parent instanceof PsiTypeParameter) { + final PsiTypeParameter typeParameter = (PsiTypeParameter) parent; + replaceTypeParameterAndReferencesWithType(typeParameter); + } + else if (parent instanceof PsiTypeElement) { + final PsiTypeElement typeElement = (PsiTypeElement) parent; + final PsiElement lastChild = typeElement.getLastChild(); + if (lastChild == null) { + return; + } + typeElement.replace(lastChild); + } + } - @Override - public void visitTypeParameter(PsiTypeParameter classParameter) { - super.visitTypeParameter(classParameter); - final PsiClassType[] extendsListTypes = classParameter.getExtendsListTypes(); - if (extendsListTypes.length < 1) { - return; - } - final PsiClassType extendsType = extendsListTypes[0]; - final PsiClass aClass = extendsType.resolve(); - if (aClass == null) { - return; - } - if (!aClass.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiIdentifier nameIdentifier = classParameter.getNameIdentifier(); - if (nameIdentifier != null) { - registerError(nameIdentifier, aClass, Integer.valueOf(1)); - } + private static void replaceTypeParameterAndReferencesWithType(PsiTypeParameter typeParameter) { + final PsiReferenceList extendsList = typeParameter.getExtendsList(); + final PsiClassType[] referenceElements = extendsList.getReferencedTypes(); + if (referenceElements.length < 1) { + return; + } + final PsiClass finalClass = referenceElements[0].resolve(); + if (finalClass == null) { + return; + } + final Project project = typeParameter.getProject(); + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + final PsiJavaCodeReferenceElement classReference = factory.createClassReferenceElement(finalClass); + final Query query = ReferencesSearch.search(typeParameter, typeParameter.getUseScope()); + for (PsiReference reference : query) { + final PsiElement referenceElement = reference.getElement(); + referenceElement.replace(classReference); + } + typeParameter.delete(); + } } @Override - public void visitTypeElement(PsiTypeElement typeElement) { - super.visitTypeElement(typeElement); - final PsiType type = typeElement.getType(); - if (!(type instanceof PsiWildcardType)) { - return; - } - final PsiWildcardType wildcardType = (PsiWildcardType)type; - final PsiType extendsBound = wildcardType.getExtendsBound(); - if (!(extendsBound instanceof PsiClassType)) { - return; - } - final PsiClassType classType = (PsiClassType)extendsBound; - final PsiClass aClass = classType.resolve(); - if (aClass == null || !aClass.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - if (isPartOfOverriddenMethod(typeElement)) { - return; - } - registerError(typeElement.getFirstChild(), aClass, Integer.valueOf(2)); + public BaseInspectionVisitor buildVisitor() { + return new TypeParameterExtendsFinalClassVisitor(); } - private static boolean isPartOfOverriddenMethod(PsiTypeElement typeElement) { - final PsiMethod method = PsiTreeUtil.getParentOfType(typeElement, PsiMethod.class); - if (method == null) { - return false; - } - final PsiCodeBlock body = method.getBody(); - if (PsiTreeUtil.isAncestor(body, typeElement, true)) { - return false; - } - return MethodUtils.hasSuper(method); + private static class TypeParameterExtendsFinalClassVisitor extends BaseInspectionVisitor { + + @Override + public void visitTypeParameter(PsiTypeParameter classParameter) { + super.visitTypeParameter(classParameter); + final PsiClassType[] extendsListTypes = classParameter.getExtendsListTypes(); + if (extendsListTypes.length < 1) { + return; + } + final PsiClassType extendsType = extendsListTypes[0]; + final PsiClass aClass = extendsType.resolve(); + if (aClass == null) { + return; + } + if (!aClass.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiIdentifier nameIdentifier = classParameter.getNameIdentifier(); + if (nameIdentifier != null) { + registerError(nameIdentifier, aClass, Integer.valueOf(1)); + } + } + + @Override + public void visitTypeElement(PsiTypeElement typeElement) { + super.visitTypeElement(typeElement); + final PsiType type = typeElement.getType(); + if (!(type instanceof PsiWildcardType)) { + return; + } + final PsiWildcardType wildcardType = (PsiWildcardType) type; + final PsiType extendsBound = wildcardType.getExtendsBound(); + if (!(extendsBound instanceof PsiClassType)) { + return; + } + final PsiClassType classType = (PsiClassType) extendsBound; + final PsiClass aClass = classType.resolve(); + if (aClass == null || !aClass.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + if (isPartOfOverriddenMethod(typeElement)) { + return; + } + registerError(typeElement.getFirstChild(), aClass, Integer.valueOf(2)); + } + + private static boolean isPartOfOverriddenMethod(PsiTypeElement typeElement) { + final PsiMethod method = PsiTreeUtil.getParentOfType(typeElement, PsiMethod.class); + if (method == null) { + return false; + } + final PsiCodeBlock body = method.getBody(); + if (PsiTreeUtil.isAncestor(body, typeElement, true)) { + return false; + } + return MethodUtils.hasSuper(method); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/AbstractMethodCallInConstructorInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/AbstractMethodCallInConstructorInspection.java index e1d64ab5ca..fb003b085b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/AbstractMethodCallInConstructorInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/AbstractMethodCallInConstructorInspection.java @@ -22,53 +22,54 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class AbstractMethodCallInConstructorInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.abstractMethodCallInConstructorDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.abstractMethodCallInConstructorDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.abstractMethodCallInConstructorProblemDescriptor().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.abstractMethodCallInConstructorProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new AbstractMethodCallInConstructorVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new AbstractMethodCallInConstructorVisitor(); + } - private static class AbstractMethodCallInConstructorVisitor extends BaseInspectionVisitor { + private static class AbstractMethodCallInConstructorVisitor extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { - return; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier != null) { - if (!(qualifier instanceof PsiThisExpression) && !(qualifier instanceof PsiSuperExpression)) { - return; + @Override + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { + return; + } + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null) { + if (!(qualifier instanceof PsiThisExpression) && !(qualifier instanceof PsiSuperExpression)) { + return; + } + } + final PsiMethod calledMethod = (PsiMethod) methodExpression.resolve(); + if (calledMethod == null || calledMethod.isConstructor() || !calledMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { + return; + } + final PsiClass calledMethodClass = calledMethod.getContainingClass(); + if (calledMethodClass == null) { + return; + } + final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); + if (!calledMethodClass.equals(containingClass)) { + return; + } + registerMethodCallError(expression); } - } - final PsiMethod calledMethod = (PsiMethod)methodExpression.resolve(); - if (calledMethod == null || calledMethod.isConstructor() || !calledMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { - return; - } - final PsiClass calledMethodClass = calledMethod.getContainingClass(); - if (calledMethodClass == null) { - return; - } - final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); - if (!calledMethodClass.equals(containingClass)) { - return; - } - registerMethodCallError(expression); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableInitializationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableInitializationInspection.java index cb80190c9a..ed62aa4ddd 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableInitializationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableInitializationInspection.java @@ -31,136 +31,139 @@ import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; +import org.intellij.lang.annotations.Pattern; import javax.swing.*; @ExtensionImpl public class InstanceVariableInitializationInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignorePrimitives = false; - /** - * @noinspection PublicField - */ - public boolean m_ignorePrimitives = false; - - @Nonnull - public String getID() { - return "InstanceVariableMayNotBeInitialized"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - final Boolean junitTestCase = (Boolean)infos[0]; - return junitTestCase - ? InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedProblemDescriptorJunit().get() - : InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedProblemDescriptor().get(); - } + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "InstanceVariableMayNotBeInitialized"; + } - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedDisplayName(); + } - public InspectionGadgetsFix buildFix(Object... infos) { - return new MakeInitializerExplicitFix(); - } + @Nonnull + public String buildErrorString(Object... infos) { + final Boolean junitTestCase = (Boolean) infos[0]; + return junitTestCase + ? InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedProblemDescriptorJunit().get() + : InspectionGadgetsLocalize.instanceVariableMayNotBeInitializedProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new InstanceVariableInitializationVisitor(); - } + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); + } - private class InstanceVariableInitializationVisitor extends BaseInspectionVisitor { - @Override - public void visitField(@Nonnull PsiField field) { - if (field.hasModifierProperty(PsiModifier.STATIC) || field.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - if (field.getInitializer() != null) { - return; - } - if (m_ignorePrimitives) { - final PsiType fieldType = field.getType(); - if (ClassUtils.isPrimitive(fieldType)) { - return; - } - } - final PsiClass aClass = field.getContainingClass(); - if (aClass == null) { - return; - } - Project project = field.getProject(); - if (project.getExtensionPoint(ImplicitUsageProvider.class).findFirstSafe(it -> it.isImplicitWrite(field)) != null) { - return; - } - final boolean isTestClass = TestUtils.isJUnitTestClass(aClass); - if (isTestClass) { - if (isInitializedInSetup(field, aClass)) { - return; - } - } - if (isInitializedInInitializer(field)) { - return; - } - if (InitializationUtils.isInitializedInConstructors(field, aClass)) { - return; - } - if (isTestClass) { - registerFieldError(field, Boolean.TRUE); - } - else { - registerFieldError(field, Boolean.FALSE); - } + public InspectionGadgetsFix buildFix(Object... infos) { + return new MakeInitializerExplicitFix(); } - private boolean isInitializedInSetup(PsiField field, PsiClass aClass) { - final PsiMethod setupMethod = getSetupMethod(aClass); - return InitializationUtils.methodAssignsVariableOrFails(setupMethod, field); + public BaseInspectionVisitor buildVisitor() { + return new InstanceVariableInitializationVisitor(); } - @Nullable - private PsiMethod getSetupMethod(@Nonnull PsiClass aClass) { - final PsiMethod[] methods = aClass.findMethodsByName("setUp", false); - for (PsiMethod method : methods) { - if (method.hasModifierProperty(PsiModifier.STATIC)) { - continue; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() != 0) { - continue; + private class InstanceVariableInitializationVisitor extends BaseInspectionVisitor { + @Override + public void visitField(@Nonnull PsiField field) { + if (field.hasModifierProperty(PsiModifier.STATIC) || field.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + if (field.getInitializer() != null) { + return; + } + if (m_ignorePrimitives) { + final PsiType fieldType = field.getType(); + if (ClassUtils.isPrimitive(fieldType)) { + return; + } + } + final PsiClass aClass = field.getContainingClass(); + if (aClass == null) { + return; + } + Project project = field.getProject(); + if (project.getExtensionPoint(ImplicitUsageProvider.class).findFirstSafe(it -> it.isImplicitWrite(field)) != null) { + return; + } + final boolean isTestClass = TestUtils.isJUnitTestClass(aClass); + if (isTestClass) { + if (isInitializedInSetup(field, aClass)) { + return; + } + } + if (isInitializedInInitializer(field)) { + return; + } + if (InitializationUtils.isInitializedInConstructors(field, aClass)) { + return; + } + if (isTestClass) { + registerFieldError(field, Boolean.TRUE); + } + else { + registerFieldError(field, Boolean.FALSE); + } } - if (PsiType.VOID.equals(method.getReturnType())) { - return method; - } - } - return null; - } - private static boolean isInitializedInInitializer(@Nonnull PsiField field) { - final PsiClass aClass = field.getContainingClass(); - if (aClass == null) { - return false; - } - if (InitializationUtils.isInitializedInInitializer(field, aClass)) { - return true; - } - final PsiField[] fields = aClass.getFields(); - for (PsiField otherField : fields) { - if (field.equals(otherField)) { - continue; + private boolean isInitializedInSetup(PsiField field, PsiClass aClass) { + final PsiMethod setupMethod = getSetupMethod(aClass); + return InitializationUtils.methodAssignsVariableOrFails(setupMethod, field); } - if (otherField.hasModifierProperty(PsiModifier.STATIC)) { - continue; + + @Nullable + private PsiMethod getSetupMethod(@Nonnull PsiClass aClass) { + final PsiMethod[] methods = aClass.findMethodsByName("setUp", false); + for (PsiMethod method : methods) { + if (method.hasModifierProperty(PsiModifier.STATIC)) { + continue; + } + final PsiParameterList parameterList = method.getParameterList(); + if (parameterList.getParametersCount() != 0) { + continue; + } + if (PsiType.VOID.equals(method.getReturnType())) { + return method; + } + } + return null; } - final PsiExpression initializer = otherField.getInitializer(); - if (InitializationUtils.expressionAssignsVariableOrFails(initializer, field)) { - return true; + + private static boolean isInitializedInInitializer(@Nonnull PsiField field) { + final PsiClass aClass = field.getContainingClass(); + if (aClass == null) { + return false; + } + if (InitializationUtils.isInitializedInInitializer(field, aClass)) { + return true; + } + final PsiField[] fields = aClass.getFields(); + for (PsiField otherField : fields) { + if (field.equals(otherField)) { + continue; + } + if (otherField.hasModifierProperty(PsiModifier.STATIC)) { + continue; + } + final PsiExpression initializer = otherField.getInitializer(); + if (InitializationUtils.expressionAssignsVariableOrFails(initializer, field)) { + return true; + } + } + return false; } - } - return false; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableUninitializedUseInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableUninitializedUseInspection.java index 626a4a02fc..fdc5515be1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableUninitializedUseInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/InstanceVariableUninitializedUseInspection.java @@ -28,12 +28,13 @@ import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.CheckBox; import consulo.language.editor.ImplicitUsageProvider; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.xml.serializer.InvalidDataException; import consulo.util.xml.serializer.WriteExternalException; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; import org.jdom.Element; -import org.jetbrains.annotations.NonNls; import javax.swing.*; import java.awt.*; @@ -42,149 +43,148 @@ @ExtensionImpl public class InstanceVariableUninitializedUseInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignorePrimitives = false; + + /** + * @noinspection PublicField + */ + public String annotationNamesString = ""; + private final List annotationNames = new ArrayList(); + + public InstanceVariableUninitializedUseInspection() { + parseString(annotationNamesString, annotationNames); + } - /** - * @noinspection PublicField - */ - public boolean m_ignorePrimitives = false; - - /** - * @noinspection PublicField - */ - @NonNls - public String annotationNamesString = ""; - private final List annotationNames = new ArrayList(); - - public InstanceVariableUninitializedUseInspection() { - parseString(annotationNamesString, annotationNames); - } - - @Override - @Nonnull - public String getID() { - return "InstanceVariableUsedBeforeInitialized"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.instanceVariableUsedBeforeInitializedDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.instanceVariableUsedBeforeInitializedProblemDescriptor().get(); - } - - @Override - public void readSettings(@Nonnull Element element) throws InvalidDataException { - super.readSettings(element); - parseString(annotationNamesString, annotationNames); - } - - @Override - public void writeSettings(@Nonnull Element element) throws WriteExternalException { - annotationNamesString = formatString(annotationNames); - super.writeSettings(element); - } - - @Override - public JComponent createOptionsPanel() { - final JComponent panel = new JPanel(new GridBagLayout()); - - final JPanel annotationsPanel = SpecialAnnotationsUtil.createSpecialAnnotationsListControl( - annotationNames, - InspectionGadgetsLocalize.ignoreIfAnnotatedBy().get() - ); - final CheckBox checkBox = - new CheckBox(InspectionGadgetsLocalize.primitiveFieldsIgnoreOption().get(), this, "m_ignorePrimitives"); - - final GridBagConstraints constraints = new GridBagConstraints(); - constraints.gridx = 0; - constraints.gridy = 0; - constraints.weightx = 1.0; - constraints.weighty = 1.0; - constraints.fill = GridBagConstraints.BOTH; - panel.add(annotationsPanel, constraints); - - constraints.gridy = 1; - constraints.weighty = 0.0; - constraints.fill = GridBagConstraints.HORIZONTAL; - panel.add(checkBox, constraints); - - return panel; - } - - @Nonnull - @Override - protected InspectionGadgetsFix[] buildFixes(Object... infos) { - final PsiField field = (PsiField)infos[0]; - return AddToIgnoreIfAnnotatedByListQuickFix.build(field, annotationNames); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new InstanceVariableInitializationVisitor(); - } - - private class InstanceVariableInitializationVisitor extends BaseInspectionVisitor { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "InstanceVariableUsedBeforeInitialized"; + } + @Nonnull @Override - public void visitField(@Nonnull PsiField field) { - if (field.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - if (field.getInitializer() != null) { - return; - } - final PsiAnnotation annotation = AnnotationUtil.findAnnotation(field, annotationNames); - if (annotation != null) { - return; - } - if (m_ignorePrimitives) { - final PsiType fieldType = field.getType(); - if (ClassUtils.isPrimitive(fieldType)) { - return; - } - } - final PsiClass aClass = field.getContainingClass(); - if (aClass == null) { - return; - } - Project project = field.getProject(); - if (project.getExtensionPoint(ImplicitUsageProvider.class).findFirstSafe(it -> it.isImplicitWrite(field)) != null) { - return; - } - final UninitializedReadCollector uninitializedReadsCollector = new UninitializedReadCollector(); - if (!isInitializedInInitializer(field, uninitializedReadsCollector)) { - final PsiMethod[] constructors = aClass.getConstructors(); - for (final PsiMethod constructor : constructors) { - final PsiCodeBlock body = constructor.getBody(); - uninitializedReadsCollector.blockAssignsVariable(body, field); - } - } - final PsiExpression[] badReads = uninitializedReadsCollector.getUninitializedReads(); - for (PsiExpression expression : badReads) { - registerError(expression, field); - } + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.instanceVariableUsedBeforeInitializedDisplayName(); } - private boolean isInitializedInInitializer(@Nonnull PsiField field, UninitializedReadCollector uninitializedReadsCollector) { - final PsiClass aClass = field.getContainingClass(); - if (aClass == null) { - return false; - } - final PsiClassInitializer[] initializers = aClass.getInitializers(); - for (final PsiClassInitializer initializer : initializers) { - if (!initializer.hasModifierProperty(PsiModifier.STATIC)) { - final PsiCodeBlock body = initializer.getBody(); - if (uninitializedReadsCollector.blockAssignsVariable(body, field)) { - return true; - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.instanceVariableUsedBeforeInitializedProblemDescriptor().get(); + } + + @Override + public void readSettings(@Nonnull Element element) throws InvalidDataException { + super.readSettings(element); + parseString(annotationNamesString, annotationNames); + } + + @Override + public void writeSettings(@Nonnull Element element) throws WriteExternalException { + annotationNamesString = formatString(annotationNames); + super.writeSettings(element); + } + + @Override + public JComponent createOptionsPanel() { + final JComponent panel = new JPanel(new GridBagLayout()); + + final JPanel annotationsPanel = SpecialAnnotationsUtil.createSpecialAnnotationsListControl( + annotationNames, + InspectionGadgetsLocalize.ignoreIfAnnotatedBy().get() + ); + final CheckBox checkBox = + new CheckBox(InspectionGadgetsLocalize.primitiveFieldsIgnoreOption().get(), this, "m_ignorePrimitives"); + + final GridBagConstraints constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 0; + constraints.weightx = 1.0; + constraints.weighty = 1.0; + constraints.fill = GridBagConstraints.BOTH; + panel.add(annotationsPanel, constraints); + + constraints.gridy = 1; + constraints.weighty = 0.0; + constraints.fill = GridBagConstraints.HORIZONTAL; + panel.add(checkBox, constraints); + + return panel; + } + + @Nonnull + @Override + protected InspectionGadgetsFix[] buildFixes(Object... infos) { + final PsiField field = (PsiField) infos[0]; + return AddToIgnoreIfAnnotatedByListQuickFix.build(field, annotationNames); + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new InstanceVariableInitializationVisitor(); + } + + private class InstanceVariableInitializationVisitor extends BaseInspectionVisitor { + + @Override + public void visitField(@Nonnull PsiField field) { + if (field.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + if (field.getInitializer() != null) { + return; + } + final PsiAnnotation annotation = AnnotationUtil.findAnnotation(field, annotationNames); + if (annotation != null) { + return; + } + if (m_ignorePrimitives) { + final PsiType fieldType = field.getType(); + if (ClassUtils.isPrimitive(fieldType)) { + return; + } + } + final PsiClass aClass = field.getContainingClass(); + if (aClass == null) { + return; + } + Project project = field.getProject(); + if (project.getExtensionPoint(ImplicitUsageProvider.class).findFirstSafe(it -> it.isImplicitWrite(field)) != null) { + return; + } + final UninitializedReadCollector uninitializedReadsCollector = new UninitializedReadCollector(); + if (!isInitializedInInitializer(field, uninitializedReadsCollector)) { + final PsiMethod[] constructors = aClass.getConstructors(); + for (final PsiMethod constructor : constructors) { + final PsiCodeBlock body = constructor.getBody(); + uninitializedReadsCollector.blockAssignsVariable(body, field); + } + } + final PsiExpression[] badReads = uninitializedReadsCollector.getUninitializedReads(); + for (PsiExpression expression : badReads) { + registerError(expression, field); + } + } + + private boolean isInitializedInInitializer(@Nonnull PsiField field, UninitializedReadCollector uninitializedReadsCollector) { + final PsiClass aClass = field.getContainingClass(); + if (aClass == null) { + return false; + } + final PsiClassInitializer[] initializers = aClass.getInitializers(); + for (final PsiClassInitializer initializer : initializers) { + if (!initializer.hasModifierProperty(PsiModifier.STATIC)) { + final PsiCodeBlock body = initializer.getBody(); + if (uninitializedReadsCollector.blockAssignsVariable(body, field)) { + return true; + } + } + } + return false; } - } - return false; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonFinalStaticVariableUsedInClassInitializationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonFinalStaticVariableUsedInClassInitializationInspection.java index 6ec7ba2c68..6e530acd7e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonFinalStaticVariableUsedInClassInitializationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonFinalStaticVariableUsedInClassInitializationInspection.java @@ -15,40 +15,37 @@ */ package com.intellij.java.impl.ig.initialization; -import com.siyeh.localize.InspectionGadgetsLocalize; -import jakarta.annotation.Nonnull; - +import com.intellij.java.impl.ig.fixes.MakeFieldFinalFix; import com.intellij.java.language.psi.PsiField; -import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; -import com.intellij.java.impl.ig.fixes.MakeFieldFinalFix; +import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; - +import consulo.localize.LocalizeValue; +import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @ExtensionImpl -public class NonFinalStaticVariableUsedInClassInitializationInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.nonFinalStaticVariableInitializationDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nonFinalStaticVariableInitializationProblemDescriptor().get(); - } - - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - final PsiField field = (PsiField)infos[0]; - return MakeFieldFinalFix.buildFix(field); - } - - public BaseInspectionVisitor buildVisitor() { - return new NonFinalStaticVariableUsedInClassInitializationVisitor(); - } +public class NonFinalStaticVariableUsedInClassInitializationInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nonFinalStaticVariableInitializationDisplayName(); + } + + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nonFinalStaticVariableInitializationProblemDescriptor().get(); + } + + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + final PsiField field = (PsiField) infos[0]; + return MakeFieldFinalFix.buildFix(field); + } + + public BaseInspectionVisitor buildVisitor() { + return new NonFinalStaticVariableUsedInClassInitializationVisitor(); + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonThreadSafeLazyInitializationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonThreadSafeLazyInitializationInspection.java index 7440fb1d33..32b14bec6e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonThreadSafeLazyInitializationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/NonThreadSafeLazyInitializationInspection.java @@ -30,6 +30,7 @@ import consulo.language.psi.search.ReferencesSearch; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -37,200 +38,216 @@ import java.util.Collection; @ExtensionImpl -public class NonThreadSafeLazyInitializationInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.nonThreadSafeLazyInitializationDisplayName().get(); - } +public class NonThreadSafeLazyInitializationInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.nonThreadSafeLazyInitializationDisplayName(); + } - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.nonThreadSafeLazyInitializationProblemDescriptor().get(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.nonThreadSafeLazyInitializationProblemDescriptor().get(); + } - public BaseInspectionVisitor buildVisitor() { - return new UnsafeSafeLazyInitializationVisitor(); - } + public BaseInspectionVisitor buildVisitor() { + return new UnsafeSafeLazyInitializationVisitor(); + } - private static class UnsafeSafeLazyInitializationVisitor - extends BaseInspectionVisitor { + private static class UnsafeSafeLazyInitializationVisitor + extends BaseInspectionVisitor { + + @Override + public void visitAssignmentExpression( + @Nonnull PsiAssignmentExpression expression + ) { + super.visitAssignmentExpression(expression); + final PsiExpression lhs = expression.getLExpression(); + if (!(lhs instanceof PsiReferenceExpression)) { + return; + } + final PsiReference reference = (PsiReference) lhs; + final PsiElement referent = reference.resolve(); + if (!(referent instanceof PsiField)) { + return; + } + final PsiField field = (PsiField) referent; + if (!field.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + if (isInStaticInitializer(expression)) { + return; + } + if (isInSynchronizedContext(expression)) { + return; + } + if (!isLazy(expression, (PsiReferenceExpression) lhs)) { + return; + } + boolean assignedOnce = isAssignedOnce(referent); + boolean safeToDelete = isSafeToDeleteIfStatement(expression); + registerError(lhs, assignedOnce && safeToDelete); + } - @Override - public void visitAssignmentExpression( - @Nonnull PsiAssignmentExpression expression) { - super.visitAssignmentExpression(expression); - final PsiExpression lhs = expression.getLExpression(); - if (!(lhs instanceof PsiReferenceExpression)) { - return; - } - final PsiReference reference = (PsiReference)lhs; - final PsiElement referent = reference.resolve(); - if (!(referent instanceof PsiField)) { - return; - } - final PsiField field = (PsiField)referent; - if (!field.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - if (isInStaticInitializer(expression)) { - return; - } - if (isInSynchronizedContext(expression)) { - return; - } - if (!isLazy(expression, (PsiReferenceExpression)lhs)) { - return; - } - boolean assignedOnce = isAssignedOnce(referent); - boolean safeToDelete = isSafeToDeleteIfStatement(expression); - registerError(lhs, assignedOnce && safeToDelete); - } + private static boolean isAssignedOnce(PsiElement referent) { + final int[] writeCount = new int[1]; + return ReferencesSearch.search(referent).forEach(new Processor() { + public boolean process(PsiReference reference) { + PsiElement element = reference.getElement(); + if (!(element instanceof PsiExpression)) { + return true; + } + if (!PsiUtil.isAccessedForWriting((PsiExpression) element)) { + return true; + } + return ++writeCount[0] != 2; + } + }); + } - private static boolean isAssignedOnce(PsiElement referent) { - final int[] writeCount = new int[1]; - return ReferencesSearch.search(referent).forEach(new Processor() { - public boolean process(PsiReference reference) { - PsiElement element = reference.getElement(); - if (!(element instanceof PsiExpression)) { - return true; - } - if (!PsiUtil.isAccessedForWriting((PsiExpression)element)) { - return true; - } - return ++writeCount[0] != 2; + private static boolean isSafeToDeleteIfStatement(PsiElement expression) { + PsiIfStatement ifStatement = PsiTreeUtil.getParentOfType(expression, PsiIfStatement.class); + if (ifStatement.getElseBranch() != null) { + return false; + } + PsiStatement thenBranch = ifStatement.getThenBranch(); + if (thenBranch == null) { + return false; + } + if (!(thenBranch instanceof PsiBlockStatement)) { + return true; + } + return ((PsiBlockStatement) thenBranch).getCodeBlock().getStatements().length == 1; } - }); - } - private static boolean isSafeToDeleteIfStatement(PsiElement expression) { - PsiIfStatement ifStatement = PsiTreeUtil.getParentOfType(expression, PsiIfStatement.class); - if (ifStatement.getElseBranch() != null) { - return false; - } - PsiStatement thenBranch = ifStatement.getThenBranch(); - if (thenBranch == null) return false; - if (!(thenBranch instanceof PsiBlockStatement)) { - return true; - } - return ((PsiBlockStatement)thenBranch).getCodeBlock().getStatements().length == 1; - } + private static boolean isLazy( + PsiAssignmentExpression expression, + PsiReferenceExpression lhs + ) { + final PsiIfStatement ifStatement = + PsiTreeUtil.getParentOfType( + expression, + PsiIfStatement.class + ); + if (ifStatement == null) { + return false; + } + final PsiExpression condition = ifStatement.getCondition(); + if (condition == null) { + return false; + } + return isNullComparison(condition, lhs); + } - private static boolean isLazy(PsiAssignmentExpression expression, - PsiReferenceExpression lhs) { - final PsiIfStatement ifStatement = - PsiTreeUtil.getParentOfType(expression, - PsiIfStatement.class); - if (ifStatement == null) { - return false; - } - final PsiExpression condition = ifStatement.getCondition(); - if (condition == null) { - return false; - } - return isNullComparison(condition, lhs); - } + private static boolean isNullComparison( + PsiExpression condition, PsiReferenceExpression reference + ) { + if (!(condition instanceof PsiBinaryExpression)) { + return false; + } + final PsiBinaryExpression comparison = + (PsiBinaryExpression) condition; + final IElementType tokenType = comparison.getOperationTokenType(); + if (!tokenType.equals(JavaTokenType.EQEQ)) { + return false; + } + final PsiExpression lhs = comparison.getLOperand(); + final PsiExpression rhs = comparison.getROperand(); + if (rhs == null) { + return false; + } + final String lhsText = lhs.getText(); + final String rhsText = rhs.getText(); + if (!PsiKeyword.NULL.equals(lhsText) && + !PsiKeyword.NULL.equals(rhsText)) { + return false; + } + final String referenceText = reference.getText(); + return referenceText.equals(lhsText) || + referenceText.equals(rhsText); + } - private static boolean isNullComparison( - PsiExpression condition, PsiReferenceExpression reference) { - if (!(condition instanceof PsiBinaryExpression)) { - return false; - } - final PsiBinaryExpression comparison = - (PsiBinaryExpression)condition; - final IElementType tokenType = comparison.getOperationTokenType(); - if (!tokenType.equals(JavaTokenType.EQEQ)) { - return false; - } - final PsiExpression lhs = comparison.getLOperand(); - final PsiExpression rhs = comparison.getROperand(); - if (rhs == null) { - return false; - } - final String lhsText = lhs.getText(); - final String rhsText = rhs.getText(); - if (!PsiKeyword.NULL.equals(lhsText) && - !PsiKeyword.NULL.equals(rhsText)) { - return false; - } - final String referenceText = reference.getText(); - return referenceText.equals(lhsText) || - referenceText.equals(rhsText); - } + private static boolean isInSynchronizedContext(PsiElement element) { + final PsiSynchronizedStatement syncBlock = + PsiTreeUtil.getParentOfType( + element, + PsiSynchronizedStatement.class + ); + if (syncBlock != null) { + return true; + } + final PsiMethod method = + PsiTreeUtil.getParentOfType( + element, + PsiMethod.class + ); + return method != null && + method.hasModifierProperty(PsiModifier.SYNCHRONIZED) + && method.hasModifierProperty(PsiModifier.STATIC); + } - private static boolean isInSynchronizedContext(PsiElement element) { - final PsiSynchronizedStatement syncBlock = - PsiTreeUtil.getParentOfType(element, - PsiSynchronizedStatement.class); - if (syncBlock != null) { - return true; - } - final PsiMethod method = - PsiTreeUtil.getParentOfType(element, - PsiMethod.class); - return method != null && - method.hasModifierProperty(PsiModifier.SYNCHRONIZED) - && method.hasModifierProperty(PsiModifier.STATIC); + private static boolean isInStaticInitializer(PsiElement element) { + final PsiClassInitializer initializer = + PsiTreeUtil.getParentOfType( + element, + PsiClassInitializer.class + ); + return initializer != null && + initializer.hasModifierProperty(PsiModifier.STATIC); + } } - private static boolean isInStaticInitializer(PsiElement element) { - final PsiClassInitializer initializer = - PsiTreeUtil.getParentOfType(element, - PsiClassInitializer.class); - return initializer != null && - initializer.hasModifierProperty(PsiModifier.STATIC); - } - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - boolean isApplicable = ((Boolean)infos[0]).booleanValue(); - return isApplicable ? new IntroduceHolderFix() : null; - } - - private static class IntroduceHolderFix extends InspectionGadgetsFix { - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - PsiReferenceExpression expression = (PsiReferenceExpression)descriptor.getPsiElement(); - PsiElement resolved = expression.resolve(); - if (!(resolved instanceof PsiField)) return; - PsiField field = (PsiField)resolved; - String holderName = suggestHolderName(field); - @NonNls String text = "private static class " + holderName - + " {" + - "private static final " + field.getType().getCanonicalText() + " " + - field.getName() + " = " + ((PsiAssignmentExpression)expression.getParent()).getRExpression().getText() + ";" - + "}"; - PsiElementFactory elementFactory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory(); - PsiClass holder = elementFactory.createClassFromText(text, field).getInnerClasses()[0]; - PsiMethod method = PsiTreeUtil.getParentOfType(expression, PsiMethod.class); - method.getParent().addBefore(holder, method); - - PsiIfStatement ifStatement = PsiTreeUtil.getParentOfType(expression, PsiIfStatement.class); - ifStatement.delete(); - - final PsiExpression holderReference = elementFactory.createExpressionFromText(holderName + "." + field.getName(), field); - Collection references = ReferencesSearch.search(field).findAll(); - for (PsiReference reference : references) { - PsiElement element = reference.getElement(); - element.replace(holderReference); - } - field.delete(); + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + boolean isApplicable = ((Boolean) infos[0]).booleanValue(); + return isApplicable ? new IntroduceHolderFix() : null; } - @NonNls - private static String suggestHolderName(PsiField field) { - String string = field.getType().getDeepComponentType().getPresentableText(); - final int index = string.indexOf('<'); - if (index != -1) { - string = string.substring(0, index); - } - return string + "Holder"; - } + private static class IntroduceHolderFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return LocalizeValue.localizeTODO("Introduce holder class"); + } + + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + PsiReferenceExpression expression = (PsiReferenceExpression) descriptor.getPsiElement(); + PsiElement resolved = expression.resolve(); + if (!(resolved instanceof PsiField)) { + return; + } + PsiField field = (PsiField) resolved; + String holderName = suggestHolderName(field); + @NonNls String text = "private static class " + holderName + + " {" + + "private static final " + field.getType().getCanonicalText() + " " + + field.getName() + " = " + ((PsiAssignmentExpression) expression.getParent()).getRExpression().getText() + ";" + + "}"; + PsiElementFactory elementFactory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory(); + PsiClass holder = elementFactory.createClassFromText(text, field).getInnerClasses()[0]; + PsiMethod method = PsiTreeUtil.getParentOfType(expression, PsiMethod.class); + method.getParent().addBefore(holder, method); + + PsiIfStatement ifStatement = PsiTreeUtil.getParentOfType(expression, PsiIfStatement.class); + ifStatement.delete(); + + final PsiExpression holderReference = elementFactory.createExpressionFromText(holderName + "." + field.getName(), field); + Collection references = ReferencesSearch.search(field).findAll(); + for (PsiReference reference : references) { + PsiElement element = reference.getElement(); + element.replace(holderReference); + } + field.delete(); + } - @Nonnull - public String getName() { - return "Introduce holder class"; + @NonNls + private static String suggestHolderName(PsiField field) { + String string = field.getType().getDeepComponentType().getPresentableText(); + final int index = string.indexOf('<'); + if (index != -1) { + string = string.substring(0, index); + } + return string + "Holder"; + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverridableMethodCallDuringObjectConstructionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverridableMethodCallDuringObjectConstructionInspection.java index 37de053c33..f14d6ff394 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverridableMethodCallDuringObjectConstructionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverridableMethodCallDuringObjectConstructionInspection.java @@ -30,105 +30,104 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; @ExtensionImpl public class OverridableMethodCallDuringObjectConstructionInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.overridableMethodCallInConstructorDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.overridableMethodCallInConstructorDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.overridableMethodCallInConstructorProblemDescriptor().get(); - } - - @Override - @Nonnull - protected InspectionGadgetsFix[] buildFixes(Object... infos) { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)infos[0]; - final PsiClass callClass = ClassUtils.getContainingClass(methodCallExpression); - final PsiMethod method = methodCallExpression.resolveMethod(); - if (method == null) { - return InspectionGadgetsFix.EMPTY_ARRAY; + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.overridableMethodCallInConstructorProblemDescriptor().get(); } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null || !containingClass.equals(callClass) || MethodUtils.isOverridden(method)) { - return InspectionGadgetsFix.EMPTY_ARRAY; + + @Override + @Nonnull + protected InspectionGadgetsFix[] buildFixes(Object... infos) { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) infos[0]; + final PsiClass callClass = ClassUtils.getContainingClass(methodCallExpression); + final PsiMethod method = methodCallExpression.resolveMethod(); + if (method == null) { + return InspectionGadgetsFix.EMPTY_ARRAY; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null || !containingClass.equals(callClass) || MethodUtils.isOverridden(method)) { + return InspectionGadgetsFix.EMPTY_ARRAY; + } + final String methodName = method.getName(); + return new InspectionGadgetsFix[]{ + new MakeClassFinalFix(containingClass), + new MakeMethodFinalFix(methodName) + }; } - final String methodName = method.getName(); - return new InspectionGadgetsFix[]{ - new MakeClassFinalFix(containingClass), - new MakeMethodFinalFix(methodName) - }; - } - private static class MakeMethodFinalFix extends InspectionGadgetsFix { + private static class MakeMethodFinalFix extends InspectionGadgetsFix { + private final String methodName; - private final String methodName; + MakeMethodFinalFix(String methodName) { + this.methodName = methodName; + } - MakeMethodFinalFix(String methodName) { - this.methodName = methodName; - } + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.makeMethodFinalFixName(methodName); + } - @Override - @Nonnull - public String getName() { - return InspectionGadgetsLocalize.makeMethodFinalFixName(methodName).get(); + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement methodName = descriptor.getPsiElement(); + final PsiElement methodExpression = methodName.getParent(); + final PsiMethodCallExpression methodCall = (PsiMethodCallExpression) methodExpression.getParent(); + final PsiMethod method = methodCall.resolveMethod(); + if (method == null) { + return; + } + final PsiModifierList modifierList = method.getModifierList(); + modifierList.setModifierProperty(PsiModifier.FINAL, true); + } } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement methodName = descriptor.getPsiElement(); - final PsiElement methodExpression = methodName.getParent(); - final PsiMethodCallExpression methodCall = (PsiMethodCallExpression)methodExpression.getParent(); - final PsiMethod method = methodCall.resolveMethod(); - if (method == null) { - return; - } - final PsiModifierList modifierList = method.getModifierList(); - modifierList.setModifierProperty(PsiModifier.FINAL, true); + public BaseInspectionVisitor buildVisitor() { + return new OverridableMethodCallInConstructorVisitor(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new OverridableMethodCallInConstructorVisitor(); - } + private static class OverridableMethodCallInConstructorVisitor extends BaseInspectionVisitor { - private static class OverridableMethodCallInConstructorVisitor extends BaseInspectionVisitor { - - @Override - public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { - return; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier != null) { - if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) { - return; + @Override + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { + return; + } + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null) { + if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) { + return; + } + } + final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); + if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiMethod calledMethod = expression.resolveMethod(); + if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod)) { + return; + } + final PsiClass calledMethodClass = calledMethod.getContainingClass(); + if (calledMethodClass == null || !calledMethodClass.equals(containingClass)) { + return; + } + registerMethodCallError(expression, expression); } - } - final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); - if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiMethod calledMethod = expression.resolveMethod(); - if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod)) { - return; - } - final PsiClass calledMethodClass = calledMethod.getContainingClass(); - if (calledMethodClass == null || !calledMethodClass.equals(containingClass)) { - return; - } - registerMethodCallError(expression, expression); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverriddenMethodCallDuringObjectConstructionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverriddenMethodCallDuringObjectConstructionInspection.java index 9b7be5f952..d2b2059af5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverriddenMethodCallDuringObjectConstructionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/OverriddenMethodCallDuringObjectConstructionInspection.java @@ -25,59 +25,59 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; @ExtensionImpl public class OverriddenMethodCallDuringObjectConstructionInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.overriddenMethodCallInConstructorDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.overriddenMethodCallInConstructorDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.overriddenMethodCallInConstructorProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.overriddenMethodCallInConstructorProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new OverriddenMethodCallInConstructorVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new OverriddenMethodCallInConstructorVisitor(); + } - private static class OverriddenMethodCallInConstructorVisitor extends BaseInspectionVisitor { + private static class OverriddenMethodCallInConstructorVisitor extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { - return; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier != null) { - if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) { - return; + @Override + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + if (!MethodCallUtils.isCallDuringObjectConstruction(expression)) { + return; + } + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null) { + if (!(qualifier instanceof PsiThisExpression || qualifier instanceof PsiSuperExpression)) { + return; + } + } + final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); + if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiMethod calledMethod = expression.resolveMethod(); + if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod)) { + return; + } + final PsiClass calledMethodClass = calledMethod.getContainingClass(); + if (!InheritanceUtil.isInheritorOrSelf(containingClass, calledMethodClass, true)) { + return; + } + if (!MethodUtils.isOverriddenInHierarchy(calledMethod, containingClass)) { + return; + } + registerMethodCallError(expression); } - } - final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); - if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiMethod calledMethod = expression.resolveMethod(); - if (calledMethod == null || !PsiUtil.canBeOverriden(calledMethod)) { - return; - } - final PsiClass calledMethodClass = calledMethod.getContainingClass(); - if (!InheritanceUtil.isInheritorOrSelf(containingClass, calledMethodClass, true)) { - return; - } - if (!MethodUtils.isOverriddenInHierarchy(calledMethod, containingClass)) { - return; - } - registerMethodCallError(expression); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableInitializationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableInitializationInspection.java index 7d4be8380d..28af7f03bf 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableInitializationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableInitializationInspection.java @@ -27,87 +27,90 @@ import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; import javax.swing.*; @ExtensionImpl public class StaticVariableInitializationInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignorePrimitives = false; - /** - * @noinspection PublicField - */ - public boolean m_ignorePrimitives = false; - - @Override - @Nonnull - public String getID() { - return "StaticVariableMayNotBeInitialized"; - } + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "StaticVariableMayNotBeInitialized"; + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.staticVariableMayNotBeInitializedDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.staticVariableMayNotBeInitializedDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.staticVariableMayNotBeInitializedProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.staticVariableMayNotBeInitializedProblemDescriptor().get(); + } - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); - } + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new MakeInitializerExplicitFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new MakeInitializerExplicitFix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new StaticVariableInitializationVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new StaticVariableInitializationVisitor(); + } - private class StaticVariableInitializationVisitor - extends BaseInspectionVisitor { + private class StaticVariableInitializationVisitor + extends BaseInspectionVisitor { - @Override - public void visitField(@Nonnull PsiField field) { - if (!field.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - if (field.getInitializer() != null) { - return; - } - final PsiClass containingClass = field.getContainingClass(); - if (containingClass == null) { - return; - } - if (containingClass.isEnum()) { - return; - } - if (m_ignorePrimitives) { - final PsiType type = field.getType(); - if (ClassUtils.isPrimitive(type)) { - return; - } - } - final PsiClassInitializer[] initializers = - containingClass.getInitializers(); - for (final PsiClassInitializer initializer : initializers) { - if (initializer.hasModifierProperty(PsiModifier.STATIC)) { - final PsiCodeBlock body = initializer.getBody(); - if (InitializationUtils.blockAssignsVariableOrFails(body, - field)) { - return; - } + @Override + public void visitField(@Nonnull PsiField field) { + if (!field.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + if (field.getInitializer() != null) { + return; + } + final PsiClass containingClass = field.getContainingClass(); + if (containingClass == null) { + return; + } + if (containingClass.isEnum()) { + return; + } + if (m_ignorePrimitives) { + final PsiType type = field.getType(); + if (ClassUtils.isPrimitive(type)) { + return; + } + } + final PsiClassInitializer[] initializers = + containingClass.getInitializers(); + for (final PsiClassInitializer initializer : initializers) { + if (initializer.hasModifierProperty(PsiModifier.STATIC)) { + final PsiCodeBlock body = initializer.getBody(); + if (InitializationUtils.blockAssignsVariableOrFails( + body, + field + )) { + return; + } + } + } + registerFieldError(field); } - } - registerFieldError(field); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableUninitializedUseInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableUninitializedUseInspection.java index f94def9833..0d967a0e9d 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableUninitializedUseInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/StaticVariableUninitializedUseInspection.java @@ -25,109 +25,110 @@ import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; import javax.swing.*; @ExtensionImpl public class StaticVariableUninitializedUseInspection extends BaseInspection { + /** + * @noinspection PublicField + */ + public boolean m_ignorePrimitives = false; - /** - * @noinspection PublicField - */ - public boolean m_ignorePrimitives = false; - - @Override - @Nonnull - public String getID() { - return "StaticVariableUsedBeforeInitialization"; - } + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "StaticVariableUsedBeforeInitialization"; + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.staticVariableUsedBeforeInitializationDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.staticVariableUsedBeforeInitializationDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.staticVariableUsedBeforeInitializationProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.staticVariableUsedBeforeInitializationProblemDescriptor().get(); + } - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); - } + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.primitiveFieldsIgnoreOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "m_ignorePrimitives"); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new StaticVariableInitializationVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new StaticVariableInitializationVisitor(); + } - private class StaticVariableInitializationVisitor - extends BaseInspectionVisitor { + private class StaticVariableInitializationVisitor + extends BaseInspectionVisitor { - @Override - public void visitField(@Nonnull PsiField field) { - if (!field.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - if (field.getInitializer() != null) { - return; - } - final PsiClass containingClass = field.getContainingClass(); - if (containingClass == null) { - return; - } - if (containingClass.isEnum()) { - return; - } - if (m_ignorePrimitives) { - final PsiType type = field.getType(); - if (ClassUtils.isPrimitive(type)) { - return; - } - } - final PsiClassInitializer[] initializers = - containingClass.getInitializers(); - // Do the static initializers come in actual order in file? - // (They need to.) - final UninitializedReadCollector uninitializedReadCollector = - new UninitializedReadCollector(); - boolean assigned = false; - for (final PsiClassInitializer initializer : initializers) { - if (!initializer.hasModifierProperty(PsiModifier.STATIC)) { - continue; - } - final PsiCodeBlock body = initializer.getBody(); - if (uninitializedReadCollector.blockAssignsVariable( - body, field)) { - assigned = true; - break; - } - } - if (assigned) { - final PsiExpression[] badReads = - uninitializedReadCollector.getUninitializedReads(); - for (PsiExpression badRead : badReads) { - registerError(badRead); - } - return; - } - final PsiMethod[] methods = containingClass.getMethods(); - for (PsiMethod method : methods) { - if (!method.hasModifierProperty(PsiModifier.STATIC)) { - continue; + @Override + public void visitField(@Nonnull PsiField field) { + if (!field.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + if (field.getInitializer() != null) { + return; + } + final PsiClass containingClass = field.getContainingClass(); + if (containingClass == null) { + return; + } + if (containingClass.isEnum()) { + return; + } + if (m_ignorePrimitives) { + final PsiType type = field.getType(); + if (ClassUtils.isPrimitive(type)) { + return; + } + } + final PsiClassInitializer[] initializers = + containingClass.getInitializers(); + // Do the static initializers come in actual order in file? + // (They need to.) + final UninitializedReadCollector uninitializedReadCollector = + new UninitializedReadCollector(); + boolean assigned = false; + for (final PsiClassInitializer initializer : initializers) { + if (!initializer.hasModifierProperty(PsiModifier.STATIC)) { + continue; + } + final PsiCodeBlock body = initializer.getBody(); + if (uninitializedReadCollector.blockAssignsVariable( + body, field)) { + assigned = true; + break; + } + } + if (assigned) { + final PsiExpression[] badReads = + uninitializedReadCollector.getUninitializedReads(); + for (PsiExpression badRead : badReads) { + registerError(badRead); + } + return; + } + final PsiMethod[] methods = containingClass.getMethods(); + for (PsiMethod method : methods) { + if (!method.hasModifierProperty(PsiModifier.STATIC)) { + continue; + } + final PsiCodeBlock body = method.getBody(); + uninitializedReadCollector.blockAssignsVariable(body, field); + } + final PsiExpression[] moreBadReads = + uninitializedReadCollector.getUninitializedReads(); + for (PsiExpression badRead : moreBadReads) { + registerError(badRead); + } } - final PsiCodeBlock body = method.getBody(); - uninitializedReadCollector.blockAssignsVariable(body, field); - } - final PsiExpression[] moreBadReads = - uninitializedReadCollector.getUninitializedReads(); - for (PsiExpression badRead : moreBadReads) { - registerError(badRead); - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/ThisEscapedInConstructorInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/ThisEscapedInConstructorInspection.java index 745cb26d63..e964a5c244 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/initialization/ThisEscapedInConstructorInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/initialization/ThisEscapedInConstructorInspection.java @@ -23,151 +23,153 @@ import consulo.annotation.component.ExtensionImpl; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class ThisEscapedInConstructorInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "ThisEscapedInObjectConstruction"; + } - @Override - @Nonnull - public String getID() { - return "ThisEscapedInObjectConstruction"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.thisReferenceEscapedInConstructionDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.thisReferenceEscapedInConstructionDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.thisReferenceEscapedInConstructionProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.thisReferenceEscapedInConstructionProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new ThisExposedInConstructorInspectionVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new ThisExposedInConstructorInspectionVisitor(); + } - private static class ThisExposedInConstructorInspectionVisitor extends BaseInspectionVisitor { + private static class ThisExposedInConstructorInspectionVisitor extends BaseInspectionVisitor { - @Override - public void visitThisExpression(PsiThisExpression expression) { - super.visitThisExpression(expression); - if (!isInInitializer(expression)) { - return; - } - final PsiJavaCodeReferenceElement qualifier = expression.getQualifier(); - final PsiClass containingClass = ClassUtils.getContainingClass(expression); - if (qualifier != null) { - final PsiElement element = qualifier.resolve(); - if (!(element instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)element; - if (!aClass.equals(containingClass)) { - return; + @Override + public void visitThisExpression(PsiThisExpression expression) { + super.visitThisExpression(expression); + if (!isInInitializer(expression)) { + return; + } + final PsiJavaCodeReferenceElement qualifier = expression.getQualifier(); + final PsiClass containingClass = ClassUtils.getContainingClass(expression); + if (qualifier != null) { + final PsiElement element = qualifier.resolve(); + if (!(element instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) element; + if (!aClass.equals(containingClass)) { + return; + } + } + final PsiElement parent = expression.getParent(); + if (parent instanceof PsiAssignmentExpression) { + final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent; + if (!thisEscapesToField(expression, assignmentExpression)) { + return; + } + registerError(expression); + } + else if (parent instanceof PsiExpressionList) { + final PsiElement grandParent = parent.getParent(); + if (grandParent instanceof PsiNewExpression) { + final PsiNewExpression newExpression = (PsiNewExpression) grandParent; + if (!thisEscapesToConstructor(expression, newExpression)) { + return; + } + registerError(expression); + } + else if (grandParent instanceof PsiMethodCallExpression) { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent; + if (!thisEscapesToMethod(expression, methodCallExpression)) { + return; + } + registerError(expression); + } + } } - } - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiAssignmentExpression) { - final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)parent; - if (!thisEscapesToField(expression, assignmentExpression)) { - return; - } - registerError(expression); - } - else if (parent instanceof PsiExpressionList) { - final PsiElement grandParent = parent.getParent(); - if (grandParent instanceof PsiNewExpression) { - final PsiNewExpression newExpression = (PsiNewExpression)grandParent; - if (!thisEscapesToConstructor(expression, newExpression)) { - return; - } - registerError(expression); - } - else if (grandParent instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)grandParent; - if (!thisEscapesToMethod(expression, methodCallExpression)) { - return; - } - registerError(expression); - } - } - } - private static boolean thisEscapesToMethod(PsiThisExpression expression, PsiMethodCallExpression methodCallExpression) { - final PsiMethod method = methodCallExpression.resolveMethod(); - if (method == null) { - return false; - } - final PsiClass containingClass = ClassUtils.getContainingClass(expression); - if (containingClass == null) { - return false; - } - final PsiClass methodClass = method.getContainingClass(); - if (method.hasModifierProperty(PsiModifier.STATIC)) { - return true; - } - return methodClass != null && !containingClass.isInheritor(methodClass, true); - } + private static boolean thisEscapesToMethod(PsiThisExpression expression, PsiMethodCallExpression methodCallExpression) { + final PsiMethod method = methodCallExpression.resolveMethod(); + if (method == null) { + return false; + } + final PsiClass containingClass = ClassUtils.getContainingClass(expression); + if (containingClass == null) { + return false; + } + final PsiClass methodClass = method.getContainingClass(); + if (method.hasModifierProperty(PsiModifier.STATIC)) { + return true; + } + return methodClass != null && !containingClass.isInheritor(methodClass, true); + } - private static boolean thisEscapesToConstructor(PsiThisExpression expression, PsiNewExpression newExpression) { - final PsiClass containingClass = ClassUtils.getContainingClass(expression); - final PsiJavaCodeReferenceElement referenceElement = newExpression.getClassReference(); - if (referenceElement == null) { - return false; - } - final PsiElement element = referenceElement.resolve(); - if (!(element instanceof PsiClass)) { - return false; - } - final PsiClass constructorClass = (PsiClass)element; - return !PsiTreeUtil.isAncestor(containingClass, constructorClass, false) || - constructorClass.hasModifierProperty(PsiModifier.STATIC); - } + private static boolean thisEscapesToConstructor(PsiThisExpression expression, PsiNewExpression newExpression) { + final PsiClass containingClass = ClassUtils.getContainingClass(expression); + final PsiJavaCodeReferenceElement referenceElement = newExpression.getClassReference(); + if (referenceElement == null) { + return false; + } + final PsiElement element = referenceElement.resolve(); + if (!(element instanceof PsiClass)) { + return false; + } + final PsiClass constructorClass = (PsiClass) element; + return !PsiTreeUtil.isAncestor(containingClass, constructorClass, false) || + constructorClass.hasModifierProperty(PsiModifier.STATIC); + } - private static boolean thisEscapesToField(PsiThisExpression expression, PsiAssignmentExpression assignmentExpression) { - final PsiExpression rhs = assignmentExpression.getRExpression(); - if (!expression.equals(rhs)) { - return false; - } - final PsiExpression lExpression = assignmentExpression.getLExpression(); - if (!(lExpression instanceof PsiReferenceExpression)) { - return false; - } - final PsiReferenceExpression leftExpression = (PsiReferenceExpression)lExpression; - final PsiElement element = leftExpression.resolve(); - if (!(element instanceof PsiField)) { - return false; - } - final PsiField field = (PsiField)element; - if (field.hasModifierProperty(PsiModifier.STATIC)) { - return true; - } - final PsiClass assignmentClass = ClassUtils.getContainingClass(assignmentExpression); - final PsiClass fieldClass = field.getContainingClass(); - return !(assignmentClass == null || fieldClass == null || assignmentClass.isInheritor(fieldClass, true) || - PsiTreeUtil.isAncestor(assignmentClass, fieldClass, false)); - } + private static boolean thisEscapesToField(PsiThisExpression expression, PsiAssignmentExpression assignmentExpression) { + final PsiExpression rhs = assignmentExpression.getRExpression(); + if (!expression.equals(rhs)) { + return false; + } + final PsiExpression lExpression = assignmentExpression.getLExpression(); + if (!(lExpression instanceof PsiReferenceExpression)) { + return false; + } + final PsiReferenceExpression leftExpression = (PsiReferenceExpression) lExpression; + final PsiElement element = leftExpression.resolve(); + if (!(element instanceof PsiField)) { + return false; + } + final PsiField field = (PsiField) element; + if (field.hasModifierProperty(PsiModifier.STATIC)) { + return true; + } + final PsiClass assignmentClass = ClassUtils.getContainingClass(assignmentExpression); + final PsiClass fieldClass = field.getContainingClass(); + return !(assignmentClass == null || fieldClass == null || assignmentClass.isInheritor(fieldClass, true) || + PsiTreeUtil.isAncestor(assignmentClass, fieldClass, false)); + } - /** - * @return true if CallExpression is in a constructor, instance - * initializer, or field initializer. Otherwise false - */ - private static boolean isInInitializer(PsiElement call) { - final PsiMethod method = PsiTreeUtil.getParentOfType(call, PsiMethod.class, true, PsiClass.class); - if (method != null) { - return method.isConstructor(); - } - final PsiField field = PsiTreeUtil.getParentOfType(call, PsiField.class, true, PsiClass.class); - if (field != null) { - return true; - } - final PsiClassInitializer classInitializer = PsiTreeUtil.getParentOfType(call, PsiClassInitializer.class, true, PsiClass.class); - return classInitializer != null && !classInitializer.hasModifierProperty(PsiModifier.STATIC); + /** + * @return true if CallExpression is in a constructor, instance + * initializer, or field initializer. Otherwise false + */ + private static boolean isInInitializer(PsiElement call) { + final PsiMethod method = PsiTreeUtil.getParentOfType(call, PsiMethod.class, true, PsiClass.class); + if (method != null) { + return method.isConstructor(); + } + final PsiField field = PsiTreeUtil.getParentOfType(call, PsiField.class, true, PsiClass.class); + if (field != null) { + return true; + } + final PsiClassInitializer classInitializer = PsiTreeUtil.getParentOfType(call, PsiClassInitializer.class, true, PsiClass.class); + return classInitializer != null && !classInitializer.hasModifierProperty(PsiModifier.STATIC); + } } - } } \ No newline at end of file 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 81110e1531..653590aeab 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 @@ -95,7 +95,6 @@ protected InspectionGadgetsFix buildFix(Object... infos) { } private static class AbsoluteAlignmentInUserInterfaceFix extends InspectionGadgetsFix { - private final String myClassName; private final String myReplacement; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/CharacterComparisonInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/CharacterComparisonInspection.java index e72c3e62d0..8bf8dc4eee 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/CharacterComparisonInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/CharacterComparisonInspection.java @@ -25,57 +25,59 @@ import com.siyeh.ig.psiutils.ExpressionUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class CharacterComparisonInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "CharacterComparison"; + } - @Override - @Nonnull - public String getID() { - return "CharacterComparison"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.characterComparisonDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.characterComparisonProblemDescriptor().get(); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new CharacterComparisonVisitor(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.characterComparisonDisplayName(); + } - private static class CharacterComparisonVisitor extends BaseInspectionVisitor { + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.characterComparisonProblemDescriptor().get(); + } @Override - public void visitBinaryExpression(@Nonnull PsiBinaryExpression expression) { - super.visitBinaryExpression(expression); - final PsiExpression rhs = expression.getROperand(); - if (!ComparisonUtils.isComparison(expression) || ComparisonUtils.isEqualityComparison(expression)) { - return; - } - final PsiExpression lhs = expression.getLOperand(); - if (!isCharacter(lhs) || !isCharacter(rhs)) { - return; - } - if (NonNlsUtils.isNonNlsAnnotated(lhs) || NonNlsUtils.isNonNlsAnnotated(rhs)) { - return; - } - registerError(expression); + public BaseInspectionVisitor buildVisitor() { + return new CharacterComparisonVisitor(); } - private static boolean isCharacter(@Nullable PsiExpression expression) { - return ExpressionUtils.hasType(expression, PsiKeyword.CHAR) - || ExpressionUtils.hasType(expression, CommonClassNames.JAVA_LANG_CHARACTER); + private static class CharacterComparisonVisitor extends BaseInspectionVisitor { + + @Override + public void visitBinaryExpression(@Nonnull PsiBinaryExpression expression) { + super.visitBinaryExpression(expression); + final PsiExpression rhs = expression.getROperand(); + if (!ComparisonUtils.isComparison(expression) || ComparisonUtils.isEqualityComparison(expression)) { + return; + } + final PsiExpression lhs = expression.getLOperand(); + if (!isCharacter(lhs) || !isCharacter(rhs)) { + return; + } + if (NonNlsUtils.isNonNlsAnnotated(lhs) || NonNlsUtils.isNonNlsAnnotated(rhs)) { + return; + } + registerError(expression); + } + + private static boolean isCharacter(@Nullable PsiExpression expression) { + return ExpressionUtils.hasType(expression, PsiKeyword.CHAR) + || ExpressionUtils.hasType(expression, CommonClassNames.JAVA_LANG_CHARACTER); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/DateToStringInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/DateToStringInspection.java index 1de91c7dd0..47fc14ad80 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/DateToStringInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/internationalization/DateToStringInspection.java @@ -26,56 +26,59 @@ import com.siyeh.ig.psiutils.TypeUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; +import org.intellij.lang.annotations.Pattern; @ExtensionImpl public class DateToStringInspection extends BaseInspection { + @Nonnull + @Override + @Pattern(VALID_ID_PATTERN) + public String getID() { + return "CallToDateToString"; + } - @Override - @Nonnull - public String getID() { - return "CallToDateToString"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.callToDateTostringDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.callToDateTostringDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.callToDateTostringProblemDescriptor().get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.callToDateTostringProblemDescriptor().get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new DateToStringVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new DateToStringVisitor(); + } - private static class DateToStringVisitor extends BaseInspectionVisitor { + private static class DateToStringVisitor extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression( - @Nonnull PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - final String methodName = MethodCallUtils.getMethodName(expression); - if (!HardcodedMethodConstants.TO_STRING.equals(methodName)) { - return; - } - final PsiType targetType = MethodCallUtils.getTargetType(expression); - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_UTIL_DATE, targetType)) { - return; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - if (argumentList.getExpressions().length != 0) { - return; - } - if (NonNlsUtils.isNonNlsAnnotatedUse(expression)) { - return; - } - registerMethodCallError(expression); + @Override + public void visitMethodCallExpression( + @Nonnull PsiMethodCallExpression expression + ) { + super.visitMethodCallExpression(expression); + final String methodName = MethodCallUtils.getMethodName(expression); + if (!HardcodedMethodConstants.TO_STRING.equals(methodName)) { + return; + } + final PsiType targetType = MethodCallUtils.getTargetType(expression); + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_UTIL_DATE, targetType)) { + return; + } + final PsiExpressionList argumentList = expression.getArgumentList(); + if (argumentList.getExpressions().length != 0) { + return; + } + if (NonNlsUtils.isNonNlsAnnotatedUse(expression)) { + return; + } + registerMethodCallError(expression); + } } - } } \ No newline at end of file