diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/ReadResolveAndWriteReplaceProtectedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/ReadResolveAndWriteReplaceProtectedInspection.java index 13c98f5fb..67bd88961 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/ReadResolveAndWriteReplaceProtectedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/ReadResolveAndWriteReplaceProtectedInspection.java @@ -25,58 +25,54 @@ 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 ReadResolveAndWriteReplaceProtectedInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.readresolveWritereplaceProtectedDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.readresolveWritereplaceProtectedProblemDescriptor().get(); - } +public class ReadResolveAndWriteReplaceProtectedInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.readresolveWritereplaceProtectedDisplayName(); + } - public BaseInspectionVisitor buildVisitor() { - return new ReadResolveWriteReplaceProtectedVisitor(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.readresolveWritereplaceProtectedProblemDescriptor().get(); + } - public InspectionGadgetsFix buildFix(Object... infos) { - return new ChangeModifierFix(PsiModifier.PROTECTED); - } + public BaseInspectionVisitor buildVisitor() { + return new ReadResolveWriteReplaceProtectedVisitor(); + } - private static class ReadResolveWriteReplaceProtectedVisitor - extends BaseInspectionVisitor { + public InspectionGadgetsFix buildFix(Object... infos) { + return new ChangeModifierFix(PsiModifier.PROTECTED); + } - @Override - public void visitMethod(@Nonnull PsiMethod method) { - // no call to super, so it doesn't drill down - final PsiClass aClass = method.getContainingClass(); - if (aClass == null) { - return; - } - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (method.hasModifierProperty(PsiModifier.PROTECTED)) { - return; - } - if (aClass.hasModifierProperty(PsiModifier.FINAL) && - method.hasModifierProperty(PsiModifier.PRIVATE)) { - return; - } - if (!SerializationUtils.isReadResolve(method) && - !SerializationUtils.isWriteReplace(method)) { - return; - } - if (!SerializationUtils.isSerializable(aClass)) { - return; - } - registerMethodError(method); + private static class ReadResolveWriteReplaceProtectedVisitor extends BaseInspectionVisitor { + @Override + public void visitMethod(@Nonnull PsiMethod method) { + // no call to super, so it doesn't drill down + final PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + return; + } + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (method.hasModifierProperty(PsiModifier.PROTECTED)) { + return; + } + if (aClass.hasModifierProperty(PsiModifier.FINAL) && method.hasModifierProperty(PsiModifier.PRIVATE)) { + return; + } + if (!SerializationUtils.isReadResolve(method) && !SerializationUtils.isWriteReplace(method)) { + return; + } + if (!SerializationUtils.isSerializable(aClass)) { + return; + } + registerMethodError(method); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialPersistentFieldsWithWrongSignatureInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialPersistentFieldsWithWrongSignatureInspection.java index 93bbbc372..07e9edc2e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialPersistentFieldsWithWrongSignatureInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialPersistentFieldsWithWrongSignatureInspection.java @@ -24,68 +24,64 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; +import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; @ExtensionImpl -public class SerialPersistentFieldsWithWrongSignatureInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serialpersistentfieldsWithWrongSignatureDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.serialpersistentfieldsWithWrongSignatureProblemDescriptor().get(); - } +public class SerialPersistentFieldsWithWrongSignatureInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serialpersistentfieldsWithWrongSignatureDisplayName(); + } - public BaseInspectionVisitor buildVisitor() { - return new SerialPersistentFieldsWithWrongSignatureVisitor(); - } + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.serialpersistentfieldsWithWrongSignatureProblemDescriptor().get(); + } - private static class SerialPersistentFieldsWithWrongSignatureVisitor - extends BaseInspectionVisitor { + public BaseInspectionVisitor buildVisitor() { + return new SerialPersistentFieldsWithWrongSignatureVisitor(); + } - @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - PsiField badSerialPersistentFields = null; - final PsiField[] fields = aClass.getFields(); - for (final PsiField field : fields) { - if (isSerialPersistentFields(field)) { - if (!field.hasModifierProperty(PsiModifier.PRIVATE) || - !field.hasModifierProperty(PsiModifier.STATIC) || - !field.hasModifierProperty(PsiModifier.FINAL)) { - badSerialPersistentFields = field; - break; - } - else { - final PsiType type = field.getType(); - if (!type.equalsToText("java.io.ObjectStreamField" + - "[]")) { - badSerialPersistentFields = field; - break; + private static class SerialPersistentFieldsWithWrongSignatureVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + PsiField badSerialPersistentFields = null; + final PsiField[] fields = aClass.getFields(); + for (final PsiField field : fields) { + if (isSerialPersistentFields(field)) { + if (!field.hasModifierProperty(PsiModifier.PRIVATE) || + !field.hasModifierProperty(PsiModifier.STATIC) || + !field.hasModifierProperty(PsiModifier.FINAL)) { + badSerialPersistentFields = field; + break; + } + else { + final PsiType type = field.getType(); + if (!type.equalsToText("java.io.ObjectStreamField[]")) { + badSerialPersistentFields = field; + break; + } + } + } + } + if (badSerialPersistentFields == null) { + return; } - } + if (!SerializationUtils.isSerializable(aClass)) { + return; + } + registerFieldError(badSerialPersistentFields); } - } - if (badSerialPersistentFields == null) { - return; - } - if (!SerializationUtils.isSerializable(aClass)) { - return; - } - registerFieldError(badSerialPersistentFields); - } - private static boolean isSerialPersistentFields(PsiField field) { - @NonNls final String fieldName = field.getName(); - return "serialPersistentFields".equals(fieldName); + private static boolean isSerialPersistentFields(PsiField field) { + final String fieldName = field.getName(); + return "serialPersistentFields".equals(fieldName); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialVersionUIDNotStaticFinalInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialVersionUIDNotStaticFinalInspection.java index 78e62d62e..b2e56d87a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialVersionUIDNotStaticFinalInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerialVersionUIDNotStaticFinalInspection.java @@ -26,97 +26,94 @@ 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 SerialVersionUIDNotStaticFinalInspection extends BaseInspection { - - @Override - @Nonnull - public String getID() { - return "SerialVersionUIDWithWrongSignature"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongProblemDescriptor().get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - if ((Boolean)infos[0]) { - return null; + @Override + @Nonnull + public String getID() { + return "SerialVersionUIDWithWrongSignature"; } - return new SerialVersionUIDNotStaticFinalFix(); - } - private static class SerialVersionUIDNotStaticFinalFix - extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongDisplayName(); + } + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongQuickfix().get(); + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongProblemDescriptor().get(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiField)) { - return; - } - final PsiField field = (PsiField)parent; - final PsiModifierList modifierList = field.getModifierList(); - if (modifierList == null) { - return; - } - modifierList.setModifierProperty(PsiModifier.PRIVATE, true); - modifierList.setModifierProperty(PsiModifier.STATIC, true); - modifierList.setModifierProperty(PsiModifier.FINAL, true); + protected InspectionGadgetsFix buildFix(Object... infos) { + if ((Boolean) infos[0]) { + return null; + } + return new SerialVersionUIDNotStaticFinalFix(); } - } + private static class SerialVersionUIDNotStaticFinalFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.serialversionuidPrivateStaticFinalLongQuickfix(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new SerialVersionUIDNotStaticFinalVisitor(); - } + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (!(parent instanceof PsiField)) { + return; + } + final PsiField field = (PsiField) parent; + final PsiModifierList modifierList = field.getModifierList(); + if (modifierList == null) { + return; + } + modifierList.setModifierProperty(PsiModifier.PRIVATE, true); + modifierList.setModifierProperty(PsiModifier.STATIC, true); + modifierList.setModifierProperty(PsiModifier.FINAL, true); + } + } - private static class SerialVersionUIDNotStaticFinalVisitor - extends BaseInspectionVisitor { @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - final PsiField field = - aClass.findFieldByName( - HardcodedMethodConstants.SERIAL_VERSION_UID, false); - if (field == null) { - return; - } - final PsiType type = field.getType(); - final boolean wrongType = !PsiType.LONG.equals(type); - if (field.hasModifierProperty(PsiModifier.STATIC) && - field.hasModifierProperty(PsiModifier.PRIVATE) && - field.hasModifierProperty(PsiModifier.FINAL) && - !wrongType) { - return; - } - if (!SerializationUtils.isSerializable(aClass)) { - return; - } - registerFieldError(field, Boolean.valueOf(wrongType)); + public BaseInspectionVisitor buildVisitor() { + return new SerialVersionUIDNotStaticFinalVisitor(); + } + + private static class SerialVersionUIDNotStaticFinalVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + final PsiField field = + aClass.findFieldByName( + HardcodedMethodConstants.SERIAL_VERSION_UID, false); + if (field == null) { + return; + } + final PsiType type = field.getType(); + final boolean wrongType = !PsiType.LONG.equals(type); + if (field.hasModifierProperty(PsiModifier.STATIC) && + field.hasModifierProperty(PsiModifier.PRIVATE) && + field.hasModifierProperty(PsiModifier.FINAL) && + !wrongType) { + return; + } + if (!SerializationUtils.isSerializable(aClass)) { + return; + } + registerFieldError(field, Boolean.valueOf(wrongType)); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerialVersionUIDFieldInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerialVersionUIDFieldInspection.java index 48544e495..741774857 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerialVersionUIDFieldInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerialVersionUIDFieldInspection.java @@ -23,68 +23,67 @@ import com.siyeh.ig.InspectionGadgetsFix; 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 SerializableHasSerialVersionUIDFieldInspection extends SerializableInspection { + @Pattern("[a-zA-Z_0-9.-]+") + @Override + @Nonnull + public String getID() { + return "serial"; + } - @Pattern("[a-zA-Z_0-9.-]+") - @Override - @Nonnull - public String getID() { - return "serial"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serializableClassWithoutSerialversionuidDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.serializableClassWithoutSerialversionuidProblemDescriptor().get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new AddSerialVersionUIDFix(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serializableClassWithoutSerialversionuidDisplayName(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new SerializableHasSerialVersionUIDFieldVisitor(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.serializableClassWithoutSerialversionuidProblemDescriptor().get(); + } - private class SerializableHasSerialVersionUIDFieldVisitor extends BaseInspectionVisitor { + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + return new AddSerialVersionUIDFix(); + } @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) { - return; - } - if (aClass instanceof PsiTypeParameter || aClass instanceof PsiEnumConstantInitializer) { - return; - } - if (ignoreAnonymousInnerClasses && aClass instanceof PsiAnonymousClass) { - return; - } - final PsiField serialVersionUIDField = aClass.findFieldByName(HardcodedMethodConstants.SERIAL_VERSION_UID, false); - if (serialVersionUIDField != null) { - return; - } - if (!SerializationUtils.isSerializable(aClass)) { - return; - } - if (SerializationUtils.hasWriteReplace(aClass)) { - return; - } - if (isIgnoredSubclass(aClass)) { - return; - } - registerClassError(aClass); + public BaseInspectionVisitor buildVisitor() { + return new SerializableHasSerialVersionUIDFieldVisitor(); + } + + private class SerializableHasSerialVersionUIDFieldVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) { + return; + } + if (aClass instanceof PsiTypeParameter || aClass instanceof PsiEnumConstantInitializer) { + return; + } + if (ignoreAnonymousInnerClasses && aClass instanceof PsiAnonymousClass) { + return; + } + final PsiField serialVersionUIDField = aClass.findFieldByName(HardcodedMethodConstants.SERIAL_VERSION_UID, false); + if (serialVersionUIDField != null) { + return; + } + if (!SerializationUtils.isSerializable(aClass)) { + return; + } + if (SerializationUtils.hasWriteReplace(aClass)) { + return; + } + if (isIgnoredSubclass(aClass)) { + return; + } + registerClassError(aClass); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerializationMethodsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerializationMethodsInspection.java index 53dcfb256..6d4d4fbbf 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerializationMethodsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableHasSerializationMethodsInspection.java @@ -23,72 +23,63 @@ 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 SerializableHasSerializationMethodsInspection - extends SerializableInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serializableHasSerializationMethodsDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final boolean hasReadObject = (Boolean)infos[0]; - final boolean hasWriteObject = (Boolean)infos[1]; - if (!hasReadObject && !hasWriteObject) { - return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor().get(); - } - else if (hasReadObject) { - return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor1().get(); - } - else { - return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor2().get(); +public class SerializableHasSerializationMethodsInspection extends SerializableInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serializableHasSerializationMethodsDisplayName(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new SerializableHasSerializationMethodsVisitor(); - } - - private class SerializableHasSerializationMethodsVisitor - extends BaseInspectionVisitor { + @Override + @Nonnull + public String buildErrorString(Object... infos) { + final boolean hasReadObject = (Boolean) infos[0]; + final boolean hasWriteObject = (Boolean) infos[1]; + if (!hasReadObject && !hasWriteObject) { + return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor().get(); + } + else if (hasReadObject) { + return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor1().get(); + } + else { + return InspectionGadgetsLocalize.serializableHasSerializationMethodsProblemDescriptor2().get(); + } + } @Override - public void visitClass(@Nonnull PsiClass aClass) { - // no call to super, so it doesn't drill down - if (aClass.isInterface() || aClass.isAnnotationType() || - aClass.isEnum()) { - return; - } - if (aClass instanceof PsiTypeParameter || - aClass instanceof PsiEnumConstantInitializer) { - return; - } - if (ignoreAnonymousInnerClasses && - aClass instanceof PsiAnonymousClass) { - return; - } - if (!SerializationUtils.isSerializable(aClass)) { - return; - } - final boolean hasReadObject = - SerializationUtils.hasReadObject(aClass); - final boolean hasWriteObject = - SerializationUtils.hasWriteObject(aClass); - if (hasWriteObject && hasReadObject) { - return; - } - if (isIgnoredSubclass(aClass)) { - return; - } - registerClassError(aClass, Boolean.valueOf(hasReadObject), - Boolean.valueOf(hasWriteObject)); + public BaseInspectionVisitor buildVisitor() { + return new SerializableHasSerializationMethodsVisitor(); + } + + private class SerializableHasSerializationMethodsVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + // no call to super, so it doesn't drill down + if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) { + return; + } + if (aClass instanceof PsiTypeParameter || aClass instanceof PsiEnumConstantInitializer) { + return; + } + if (ignoreAnonymousInnerClasses && aClass instanceof PsiAnonymousClass) { + return; + } + if (!SerializationUtils.isSerializable(aClass)) { + return; + } + final boolean hasReadObject = SerializationUtils.hasReadObject(aClass); + final boolean hasWriteObject = SerializationUtils.hasWriteObject(aClass); + if (hasWriteObject && hasReadObject) { + return; + } + if (isIgnoredSubclass(aClass)) { + return; + } + registerClassError(aClass, Boolean.valueOf(hasReadObject), Boolean.valueOf(hasWriteObject)); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableInnerClassHasSerialVersionUIDFieldInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableInnerClassHasSerialVersionUIDFieldInspection.java index 39428afa8..20abd0613 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableInnerClassHasSerialVersionUIDFieldInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableInnerClassHasSerialVersionUIDFieldInspection.java @@ -20,32 +20,32 @@ 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 SerializableInnerClassHasSerialVersionUIDFieldInspection - extends SerializableInspection { +public class SerializableInnerClassHasSerialVersionUIDFieldInspection extends SerializableInspection { + @Nonnull + public String getID() { + return "SerializableNonStaticInnerClassWithoutSerialVersionUID"; + } - @Nonnull - public String getID() { - return "SerializableNonStaticInnerClassWithoutSerialVersionUID"; - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serializableInnerClassHasSerialVersionUidFieldDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serializableInnerClassHasSerialVersionUidFieldDisplayName().get(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.serializableInnerClassHasSerialVersionUidFieldProblemDescriptor().get(); + } - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.serializableInnerClassHasSerialVersionUidFieldProblemDescriptor().get(); - } + protected InspectionGadgetsFix buildFix(Object... infos) { + return new AddSerialVersionUIDFix(); + } - protected InspectionGadgetsFix buildFix(Object... infos) { - return new AddSerialVersionUIDFix(); - } - - public BaseInspectionVisitor buildVisitor() { - return new SerializableInnerClassHasSerialVersionUIDFieldVisitor(this); - } + public BaseInspectionVisitor buildVisitor() { + return new SerializableInnerClassHasSerialVersionUIDFieldVisitor(this); + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableWithUnconstructableAncestorInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableWithUnconstructableAncestorInspection.java index 58b9cdfcc..ccfb626f1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableWithUnconstructableAncestorInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/SerializableWithUnconstructableAncestorInspection.java @@ -24,6 +24,7 @@ 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; @@ -31,70 +32,69 @@ @ExtensionImpl public class SerializableWithUnconstructableAncestorInspection extends BaseInspection { + @Override + @Nonnull + public String getID() { + return "SerializableClassWithUnconstructableAncestor"; + } - @Override - @Nonnull - public String getID() { - return "SerializableClassWithUnconstructableAncestor"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.serializableWithUnconstructableAncestorDisplayName().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.serializableWithUnconstructableAncestorDisplayName(); + } - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiClass ancestor = (PsiClass)infos[0]; - return InspectionGadgetsLocalize.serializableWithUnconstructableAncestorProblemDescriptor(ancestor.getName()).get(); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + final PsiClass ancestor = (PsiClass) infos[0]; + return InspectionGadgetsLocalize.serializableWithUnconstructableAncestorProblemDescriptor(ancestor.getName()).get(); + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new SerializableWithUnconstructableAncestorVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new SerializableWithUnconstructableAncestorVisitor(); + } - private static class SerializableWithUnconstructableAncestorVisitor extends BaseInspectionVisitor { + private static class SerializableWithUnconstructableAncestorVisitor extends BaseInspectionVisitor { - @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (aClass.isInterface() || aClass.isAnnotationType()) { - return; - } - if (!SerializationUtils.isSerializable(aClass) || SerializationUtils.hasWriteReplace(aClass)) { - return; - } - PsiClass ancestor = aClass.getSuperClass(); - final Set visitedClasses = new HashSet(8); - while (ancestor != null && SerializationUtils.isSerializable(ancestor)) { - if (SerializationUtils.hasWriteReplace(ancestor)) { - return; - } - ancestor = ancestor.getSuperClass(); - if (!visitedClasses.add(ancestor)) { - return; + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (aClass.isInterface() || aClass.isAnnotationType()) { + return; + } + if (!SerializationUtils.isSerializable(aClass) || SerializationUtils.hasWriteReplace(aClass)) { + return; + } + PsiClass ancestor = aClass.getSuperClass(); + final Set visitedClasses = new HashSet(8); + while (ancestor != null && SerializationUtils.isSerializable(ancestor)) { + if (SerializationUtils.hasWriteReplace(ancestor)) { + return; + } + ancestor = ancestor.getSuperClass(); + if (!visitedClasses.add(ancestor)) { + return; + } + } + if (ancestor == null || classHasNoArgConstructor(ancestor)) { + return; + } + registerClassError(aClass, ancestor); } - } - if (ancestor == null || classHasNoArgConstructor(ancestor)) { - return; - } - registerClassError(aClass, ancestor); - } - private static boolean classHasNoArgConstructor(PsiClass aClass) { - boolean hasConstructor = false; - boolean hasNoArgConstructor = false; - for (final PsiMethod constructor : aClass.getConstructors()) { - hasConstructor = true; - final PsiParameterList parameterList = constructor.getParameterList(); - if (parameterList.getParametersCount() == 0 && - (constructor.hasModifierProperty(PsiModifier.PUBLIC) || constructor.hasModifierProperty(PsiModifier.PROTECTED))) { - hasNoArgConstructor = true; + private static boolean classHasNoArgConstructor(PsiClass aClass) { + boolean hasConstructor = false; + boolean hasNoArgConstructor = false; + for (final PsiMethod constructor : aClass.getConstructors()) { + hasConstructor = true; + final PsiParameterList parameterList = constructor.getParameterList(); + if (parameterList.getParametersCount() == 0 && + (constructor.hasModifierProperty(PsiModifier.PUBLIC) || constructor.hasModifierProperty(PsiModifier.PROTECTED))) { + hasNoArgConstructor = true; + } + } + return hasNoArgConstructor || !hasConstructor; } - } - return hasNoArgConstructor || !hasConstructor; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldInNonSerializableClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldInNonSerializableClassInspection.java index c42727802..d1e856e61 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldInNonSerializableClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldInNonSerializableClassInspection.java @@ -27,60 +27,55 @@ 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 TransientFieldInNonSerializableClassInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.transientFieldInNonSerializableClassDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - final PsiField field = (PsiField)infos[0]; - return InspectionGadgetsLocalize.transientFieldInNonSerializableClassProblemDescriptor(field.getName()).get(); - } - - public InspectionGadgetsFix buildFix(Object... infos) { - return new TransientFieldInNonSerializableClassFix(); - } - - - private static class TransientFieldInNonSerializableClassFix - extends InspectionGadgetsFix { +public class TransientFieldInNonSerializableClassInspection extends BaseInspection { + @Nonnull + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.transientFieldInNonSerializableClassDisplayName(); + } @Nonnull - public String getName() { - return InspectionGadgetsLocalize.transientFieldInNonSerializableClassRemoveQuickfix().get(); + public String buildErrorString(Object... infos) { + final PsiField field = (PsiField) infos[0]; + return InspectionGadgetsLocalize.transientFieldInNonSerializableClassProblemDescriptor(field.getName()).get(); } - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement transientModifier = descriptor.getPsiElement(); - deleteElement(transientModifier); + public InspectionGadgetsFix buildFix(Object... infos) { + return new TransientFieldInNonSerializableClassFix(); } - } - public BaseInspectionVisitor buildVisitor() { - return new TransientFieldInNonSerializableClassVisitor(); - } + private static class TransientFieldInNonSerializableClassFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.transientFieldInNonSerializableClassRemoveQuickfix(); + } - private static class TransientFieldInNonSerializableClassVisitor - extends BaseInspectionVisitor { + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement transientModifier = descriptor.getPsiElement(); + deleteElement(transientModifier); + } + } + + public BaseInspectionVisitor buildVisitor() { + return new TransientFieldInNonSerializableClassVisitor(); + } - @Override - public void visitField(@Nonnull PsiField field) { - if (!field.hasModifierProperty(PsiModifier.TRANSIENT)) { - return; - } - final PsiClass aClass = field.getContainingClass(); - if (SerializationUtils.isSerializable(aClass)) { - return; - } - registerModifierError(PsiModifier.TRANSIENT, field, field); + private static class TransientFieldInNonSerializableClassVisitor extends BaseInspectionVisitor { + @Override + public void visitField(@Nonnull PsiField field) { + if (!field.hasModifierProperty(PsiModifier.TRANSIENT)) { + return; + } + final PsiClass aClass = field.getContainingClass(); + if (SerializationUtils.isSerializable(aClass)) { + return; + } + registerModifierError(PsiModifier.TRANSIENT, field, field); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldNotInitializedInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldNotInitializedInspection.java index 60af6d9f3..bef344f7a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldNotInitializedInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/serialization/TransientFieldNotInitializedInspection.java @@ -22,79 +22,75 @@ 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 TransientFieldNotInitializedInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.transientFieldNotInitializedDisplayName(); + } - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.transientFieldNotInitializedDisplayName().get(); - } - - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.transientFieldNotInitializedProblemDescriptor().get(); - } - - public BaseInspectionVisitor buildVisitor() { - return new ReadObjectInitializationVisitor(); - } - - private static class ReadObjectInitializationVisitor - extends BaseInspectionVisitor { + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.transientFieldNotInitializedProblemDescriptor().get(); + } - @Override - public void visitField(PsiField field) { - super.visitField(field); - if (!field.hasModifierProperty(PsiModifier.TRANSIENT)) { - return; - } - final PsiClass containingClass = field.getContainingClass(); - if (!SerializationUtils.isSerializable(containingClass)) { - return; - } - final PsiExpression initializer = field.getInitializer(); - if (initializer == null && - !isInitializedInInitializer(field, containingClass) && - !isInitializedInConstructors(field, containingClass)) { - return; - } - if (SerializationUtils.hasReadObject(containingClass)) { - return; - } - registerFieldError(field); + public BaseInspectionVisitor buildVisitor() { + return new ReadObjectInitializationVisitor(); } - private static boolean isInitializedInConstructors( - @Nonnull PsiField field, @Nonnull PsiClass aClass) { - final PsiMethod[] constructors = aClass.getConstructors(); - if (constructors.length == 0) { - return false; - } - for (final PsiMethod constructor : constructors) { - if (!InitializationUtils.methodAssignsVariableOrFails( - constructor, field)) { - return false; + private static class ReadObjectInitializationVisitor extends BaseInspectionVisitor { + @Override + public void visitField(PsiField field) { + super.visitField(field); + if (!field.hasModifierProperty(PsiModifier.TRANSIENT)) { + return; + } + final PsiClass containingClass = field.getContainingClass(); + if (!SerializationUtils.isSerializable(containingClass)) { + return; + } + final PsiExpression initializer = field.getInitializer(); + if (initializer == null && + !isInitializedInInitializer(field, containingClass) && + !isInitializedInConstructors(field, containingClass)) { + return; + } + if (SerializationUtils.hasReadObject(containingClass)) { + return; + } + registerFieldError(field); } - } - return true; - } - private static boolean isInitializedInInitializer( - @Nonnull PsiField field, @Nonnull PsiClass aClass) { - final PsiClassInitializer[] initializers = aClass.getInitializers(); - for (final PsiClassInitializer initializer : initializers) { - if (initializer.hasModifierProperty(PsiModifier.STATIC)) { - continue; + private static boolean isInitializedInConstructors(@Nonnull PsiField field, @Nonnull PsiClass aClass) { + final PsiMethod[] constructors = aClass.getConstructors(); + if (constructors.length == 0) { + return false; + } + for (final PsiMethod constructor : constructors) { + if (!InitializationUtils.methodAssignsVariableOrFails( + constructor, field)) { + return false; + } + } + return true; } - final PsiCodeBlock body = initializer.getBody(); - if (InitializationUtils.blockAssignsVariableOrFails(body, - field)) { - return true; + + private static boolean isInitializedInInitializer(@Nonnull PsiField field, @Nonnull PsiClass aClass) { + final PsiClassInitializer[] initializers = aClass.getInitializers(); + for (final PsiClassInitializer initializer : initializers) { + if (initializer.hasModifierProperty(PsiModifier.STATIC)) { + continue; + } + final PsiCodeBlock body = initializer.getBody(); + if (InitializationUtils.blockAssignsVariableOrFails(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/style/RedundantFieldInitializationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantFieldInitializationInspection.java index bbe24b3b8..d0e554f09 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantFieldInitializationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantFieldInitializationInspection.java @@ -26,6 +26,7 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.inspection.ProblemHighlightType; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -34,78 +35,77 @@ @ExtensionImpl public class RedundantFieldInitializationInspection extends BaseInspection { + @SuppressWarnings("PublicField") + public boolean onlyWarnOnNull = false; - @SuppressWarnings("PublicField") - public boolean onlyWarnOnNull = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.redundantFieldInitializationDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.redundantFieldInitializationProblemDescriptor().get(); - } - - @Nullable - @Override - public JComponent createOptionsPanel() { - return new SingleCheckboxOptionsPanel("Only warn on initialization to null", this, "onlyWarnOnNull"); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new RedundantFieldInitializationFix(); - } - - private static class RedundantFieldInitializationFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.redundantFieldInitializationDisplayName(); + } @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.redundantFieldInitializationRemoveQuickfix().get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.redundantFieldInitializationProblemDescriptor().get(); } + @Nullable @Override - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - descriptor.getPsiElement().delete(); + public JComponent createOptionsPanel() { + return new SingleCheckboxOptionsPanel("Only warn on initialization to null", this, "onlyWarnOnNull"); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new RedundantFieldInitializationVisitor(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new RedundantFieldInitializationFix(); + } - private class RedundantFieldInitializationVisitor extends BaseInspectionVisitor { + private static class RedundantFieldInitializationFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.redundantFieldInitializationRemoveQuickfix(); + } - @Override - public void visitField(@Nonnull PsiField field) { - super.visitField(field); - if (!field.hasInitializer() || field.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiExpression initializer = field.getInitializer(); - if (initializer == null) { - return; - } - final String text = initializer.getText(); - final PsiType type = field.getType(); - if (PsiType.BOOLEAN.equals(type)) { - if (onlyWarnOnNull || !PsiKeyword.FALSE.equals(text)) { - return; + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + descriptor.getPsiElement().delete(); } - } else if (type instanceof PsiPrimitiveType) { - if (onlyWarnOnNull || !ExpressionUtils.isZero(initializer)) { - return; + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new RedundantFieldInitializationVisitor(); + } + + private class RedundantFieldInitializationVisitor extends BaseInspectionVisitor { + @Override + public void visitField(@Nonnull PsiField field) { + super.visitField(field); + if (!field.hasInitializer() || field.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiExpression initializer = field.getInitializer(); + if (initializer == null) { + return; + } + final String text = initializer.getText(); + final PsiType type = field.getType(); + if (PsiType.BOOLEAN.equals(type)) { + if (onlyWarnOnNull || !PsiKeyword.FALSE.equals(text)) { + return; + } + } + else if (type instanceof PsiPrimitiveType) { + if (onlyWarnOnNull || !ExpressionUtils.isZero(initializer)) { + return; + } + } + else if (!PsiType.NULL.equals(initializer.getType())) { + return; + } + registerError(initializer, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } - } else if (!PsiType.NULL.equals(initializer.getType())) { - return; - } - registerError(initializer, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java index 5ddacd305..830a9f43e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.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 jakarta.annotation.Nonnull; @@ -35,183 +36,168 @@ @ExtensionImpl public class RedundantImplementsInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean ignoreSerializable = false; + @SuppressWarnings({"PublicField"}) + public boolean ignoreCloneable = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreSerializable = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreCloneable = false; - - @Override - @Nonnull - public String getID() { - return "RedundantInterfaceDeclaration"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.redundantImplementsDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.redundantImplementsProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel checkboxOptionsPanel = new MultipleCheckboxOptionsPanel(this); - checkboxOptionsPanel.addCheckbox(InspectionGadgetsLocalize.ignoreSerializableOption().get(), "ignoreSerializable"); - checkboxOptionsPanel.addCheckbox(InspectionGadgetsLocalize.ignoreCloneableOption().get(), "ignoreCloneable"); - return checkboxOptionsPanel; - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new RedundantImplementsFix(); - } - - private static class RedundantImplementsFix extends InspectionGadgetsFix { - + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.redundantImplementsRemoveQuickfix().get(); + public String getID() { + return "RedundantInterfaceDeclaration"; } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement implementReference = descriptor.getPsiElement(); - deleteElement(implementReference); + @Nonnull + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.redundantImplementsDisplayName(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new RedundantImplementsVisitor(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.redundantImplementsProblemDescriptor().get(); + } - private class RedundantImplementsVisitor extends BaseInspectionVisitor { + @Override + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel checkboxOptionsPanel = new MultipleCheckboxOptionsPanel(this); + checkboxOptionsPanel.addCheckbox(InspectionGadgetsLocalize.ignoreSerializableOption().get(), "ignoreSerializable"); + checkboxOptionsPanel.addCheckbox(InspectionGadgetsLocalize.ignoreCloneableOption().get(), "ignoreCloneable"); + return checkboxOptionsPanel; + } @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (aClass.isAnnotationType()) { - return; - } - if (aClass.isInterface()) { - checkInterface(aClass); - } - else { - checkConcreteClass(aClass); - } + protected InspectionGadgetsFix buildFix(Object... infos) { + return new RedundantImplementsFix(); } - private void checkInterface(PsiClass aClass) { - final PsiReferenceList extendsList = aClass.getExtendsList(); - if (extendsList == null) { - return; - } - final PsiJavaCodeReferenceElement[] extendsElements = - extendsList.getReferenceElements(); - for (final PsiJavaCodeReferenceElement extendsElement : - extendsElements) { - final PsiElement referent = extendsElement.resolve(); - if (!(referent instanceof PsiClass)) { - continue; + private static class RedundantImplementsFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.redundantImplementsRemoveQuickfix(); } - final PsiClass extendedInterface = (PsiClass)referent; - checkExtendedInterface(extendedInterface, extendsElement, - extendsElements); - } - } - private void checkConcreteClass(PsiClass aClass) { - final PsiReferenceList extendsList = aClass.getExtendsList(); - final PsiReferenceList implementsList = aClass.getImplementsList(); - if (extendsList == null || implementsList == null) { - return; - } - final PsiJavaCodeReferenceElement[] extendsElements = - extendsList.getReferenceElements(); - final PsiJavaCodeReferenceElement[] implementsElements = - implementsList.getReferenceElements(); - for (final PsiJavaCodeReferenceElement implementsElement : - implementsElements) { - final PsiElement referent = implementsElement.resolve(); - if (!(referent instanceof PsiClass)) { - continue; + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement implementReference = descriptor.getPsiElement(); + deleteElement(implementReference); } - final PsiClass implementedClass = (PsiClass)referent; - checkImplementedClass(implementedClass, implementsElement, - extendsElements, implementsElements); - } } - private void checkImplementedClass( - PsiClass implementedClass, - PsiJavaCodeReferenceElement implementsElement, - PsiJavaCodeReferenceElement[] extendsElements, - PsiJavaCodeReferenceElement[] implementsElements) { - final String qualifiedName = implementedClass.getQualifiedName(); - if (ignoreSerializable && CommonClassNames.JAVA_IO_SERIALIZABLE.equals(qualifiedName)) { - return; - } - else if (ignoreCloneable && CommonClassNames.JAVA_LANG_CLONEABLE.equals(qualifiedName)) { - return; - } - for (final PsiJavaCodeReferenceElement extendsElement : - extendsElements) { - final PsiElement extendsReferent = extendsElement.resolve(); - if (!(extendsReferent instanceof PsiClass)) { - continue; - } - final PsiClass extendedClass = (PsiClass)extendsReferent; - if (extendedClass.isInheritor(implementedClass, true)) { - registerError(implementsElement); - return; - } - } - for (final PsiJavaCodeReferenceElement testImplementElement : - implementsElements) { - if (testImplementElement.equals(implementsElement)) { - continue; - } - final PsiElement implementsReferent = - testImplementElement.resolve(); - if (!(implementsReferent instanceof PsiClass)) { - continue; + @Override + public BaseInspectionVisitor buildVisitor() { + return new RedundantImplementsVisitor(); + } + + private class RedundantImplementsVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (aClass.isAnnotationType()) { + return; + } + if (aClass.isInterface()) { + checkInterface(aClass); + } + else { + checkConcreteClass(aClass); + } } - final PsiClass testImplementedClass = - (PsiClass)implementsReferent; - if (testImplementedClass.isInheritor(implementedClass, true)) { - registerError(implementsElement); - return; + + private void checkInterface(PsiClass aClass) { + final PsiReferenceList extendsList = aClass.getExtendsList(); + if (extendsList == null) { + return; + } + final PsiJavaCodeReferenceElement[] extendsElements = extendsList.getReferenceElements(); + for (final PsiJavaCodeReferenceElement extendsElement : extendsElements) { + final PsiElement referent = extendsElement.resolve(); + if (!(referent instanceof PsiClass)) { + continue; + } + final PsiClass extendedInterface = (PsiClass) referent; + checkExtendedInterface(extendedInterface, extendsElement, extendsElements); + } } - } - } - private void checkExtendedInterface( - PsiClass extendedInterface, - PsiJavaCodeReferenceElement extendsElement, - PsiJavaCodeReferenceElement[] extendsElements) { - for (final PsiJavaCodeReferenceElement testExtendsElement : - extendsElements) { - if (testExtendsElement.equals(extendsElement)) { - continue; + private void checkConcreteClass(PsiClass aClass) { + final PsiReferenceList extendsList = aClass.getExtendsList(); + final PsiReferenceList implementsList = aClass.getImplementsList(); + if (extendsList == null || implementsList == null) { + return; + } + final PsiJavaCodeReferenceElement[] extendsElements = extendsList.getReferenceElements(); + final PsiJavaCodeReferenceElement[] implementsElements = implementsList.getReferenceElements(); + for (final PsiJavaCodeReferenceElement implementsElement : implementsElements) { + final PsiElement referent = implementsElement.resolve(); + if (!(referent instanceof PsiClass)) { + continue; + } + final PsiClass implementedClass = (PsiClass) referent; + checkImplementedClass(implementedClass, implementsElement, extendsElements, implementsElements); + } } - final PsiElement implementsReferent = - testExtendsElement.resolve(); - if (!(implementsReferent instanceof PsiClass)) { - continue; + + private void checkImplementedClass( + PsiClass implementedClass, + PsiJavaCodeReferenceElement implementsElement, + PsiJavaCodeReferenceElement[] extendsElements, + PsiJavaCodeReferenceElement[] implementsElements + ) { + final String qualifiedName = implementedClass.getQualifiedName(); + if (ignoreSerializable && CommonClassNames.JAVA_IO_SERIALIZABLE.equals(qualifiedName)) { + return; + } + else if (ignoreCloneable && CommonClassNames.JAVA_LANG_CLONEABLE.equals(qualifiedName)) { + return; + } + for (final PsiJavaCodeReferenceElement extendsElement : extendsElements) { + final PsiElement extendsReferent = extendsElement.resolve(); + if (!(extendsReferent instanceof PsiClass)) { + continue; + } + final PsiClass extendedClass = (PsiClass) extendsReferent; + if (extendedClass.isInheritor(implementedClass, true)) { + registerError(implementsElement); + return; + } + } + for (final PsiJavaCodeReferenceElement testImplementElement : implementsElements) { + if (testImplementElement.equals(implementsElement)) { + continue; + } + final PsiElement implementsReferent = testImplementElement.resolve(); + if (!(implementsReferent instanceof PsiClass)) { + continue; + } + final PsiClass testImplementedClass = (PsiClass) implementsReferent; + if (testImplementedClass.isInheritor(implementedClass, true)) { + registerError(implementsElement); + return; + } + } } - final PsiClass testExtendedInterface = - (PsiClass)implementsReferent; - if (testExtendedInterface.isInheritor(extendedInterface, true)) { - registerError(extendsElement); - return; + + private void checkExtendedInterface( + PsiClass extendedInterface, + PsiJavaCodeReferenceElement extendsElement, + PsiJavaCodeReferenceElement[] extendsElements + ) { + for (final PsiJavaCodeReferenceElement testExtendsElement : extendsElements) { + if (testExtendsElement.equals(extendsElement)) { + continue; + } + final PsiElement implementsReferent = testExtendsElement.resolve(); + if (!(implementsReferent instanceof PsiClass)) { + continue; + } + final PsiClass testExtendedInterface = (PsiClass) implementsReferent; + if (testExtendedInterface.isInheritor(extendedInterface, true)) { + registerError(extendsElement); + return; + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/ReturnThisInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/ReturnThisInspection.java index f2e9a556a..2d45e2fde 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/ReturnThisInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/ReturnThisInspection.java @@ -21,48 +21,48 @@ 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 ReturnThisInspection extends BaseInspection { + @Nonnull + public String getID() { + return "ReturnOfThis"; + } - @Nonnull - public String getID() { - return "ReturnOfThis"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.returnThisDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.returnThisProblemDescriptor().get(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.returnThisDisplayName(); + } - public BaseInspectionVisitor buildVisitor() { - return new ReturnThisVisitor(); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.returnThisProblemDescriptor().get(); + } - private static class ReturnThisVisitor extends BaseInspectionVisitor { + public BaseInspectionVisitor buildVisitor() { + return new ReturnThisVisitor(); + } - @Override - public void visitThisExpression(@Nonnull PsiThisExpression thisValue) { - super.visitThisExpression(thisValue); - if (thisValue.getQualifier() != null) { - return; - } - PsiElement parent = thisValue.getParent(); - while (parent instanceof PsiParenthesizedExpression || - parent instanceof PsiConditionalExpression || - parent instanceof PsiTypeCastExpression) { - parent = parent.getParent(); - } - if (!(parent instanceof PsiReturnStatement)) { - return; - } - registerError(thisValue); + private static class ReturnThisVisitor extends BaseInspectionVisitor { + @Override + public void visitThisExpression(@Nonnull PsiThisExpression thisValue) { + super.visitThisExpression(thisValue); + if (thisValue.getQualifier() != null) { + return; + } + PsiElement parent = thisValue.getParent(); + while (parent instanceof PsiParenthesizedExpression || + parent instanceof PsiConditionalExpression || + parent instanceof PsiTypeCastExpression) { + parent = parent.getParent(); + } + if (!(parent instanceof PsiReturnStatement)) { + return; + } + registerError(thisValue); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/SizeReplaceableByIsEmptyInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/SizeReplaceableByIsEmptyInspection.java index 858fe306d..df269f666 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/SizeReplaceableByIsEmptyInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/SizeReplaceableByIsEmptyInspection.java @@ -31,6 +31,7 @@ import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.ui.ex.awt.table.ListTable; import consulo.ui.ex.awt.table.ListWrappingTableModel; @@ -44,183 +45,187 @@ @ExtensionImpl public class SizeReplaceableByIsEmptyInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean ignoreNegations = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreNegations = false; + @SuppressWarnings("PublicField") + public OrderedSet ignoredTypes = new OrderedSet<>(); - @SuppressWarnings("PublicField") - public OrderedSet ignoredTypes = new OrderedSet<>(); - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.sizeReplaceableByIsemptyDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.expressionCanBeReplacedProblemDescriptor(infos[0]).get(); - } - - @Override - @Nullable - public JComponent createOptionsPanel() { - final JComponent panel = new JPanel(new BorderLayout()); - final ListTable table = new ListTable(new ListWrappingTableModel(ignoredTypes, InspectionGadgetsLocalize.ignoredClassesTable().get())); - JPanel tablePanel = UiUtils.createAddRemoveTreeClassChooserPanel(table, InspectionGadgetsLocalize.chooseClassTypeToIgnore().get()); - final CheckBox checkBox = - new CheckBox(InspectionGadgetsLocalize.sizeReplaceableByIsemptyNegationIgnoreOption().get(), this, "ignoreNegations"); - panel.add(tablePanel, BorderLayout.CENTER); - panel.add(checkBox, BorderLayout.SOUTH); - return panel; - } - - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - return new SizeReplaceableByIsEmptyFix(); - } - - private static class SizeReplaceableByIsEmptyFix extends InspectionGadgetsFix { @Nonnull - public String getName() { - return InspectionGadgetsLocalize.sizeReplaceableByIsemptyQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.sizeReplaceableByIsemptyDisplayName(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiBinaryExpression binaryExpression = (PsiBinaryExpression) descriptor.getPsiElement(); - PsiExpression operand = binaryExpression.getLOperand(); - if (!(operand instanceof PsiMethodCallExpression)) { - operand = binaryExpression.getROperand(); - } - if (!(operand instanceof PsiMethodCallExpression)) { - return; - } - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) operand; - final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - final PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); - if (qualifierExpression == null) { - return; - } - @NonNls String newExpression = qualifierExpression.getText(); - final IElementType tokenType = binaryExpression.getOperationTokenType(); - if (!JavaTokenType.EQEQ.equals(tokenType)) { - newExpression = '!' + newExpression; - } - newExpression += ".isEmpty()"; - replaceExpression(binaryExpression, newExpression); + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.expressionCanBeReplacedProblemDescriptor(infos[0]).get(); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new SizeReplaceableByIsEmptyVisitor(); - } - private class SizeReplaceableByIsEmptyVisitor extends BaseInspectionVisitor { + @Override + @Nullable + public JComponent createOptionsPanel() { + final JComponent panel = new JPanel(new BorderLayout()); + final ListTable table = + new ListTable(new ListWrappingTableModel(ignoredTypes, InspectionGadgetsLocalize.ignoredClassesTable().get())); + JPanel tablePanel = UiUtils.createAddRemoveTreeClassChooserPanel(table, InspectionGadgetsLocalize.chooseClassTypeToIgnore().get()); + final CheckBox checkBox = + new CheckBox(InspectionGadgetsLocalize.sizeReplaceableByIsemptyNegationIgnoreOption().get(), this, "ignoreNegations"); + panel.add(tablePanel, BorderLayout.CENTER); + panel.add(checkBox, BorderLayout.SOUTH); + return panel; + } @Override - public void visitBinaryExpression(PsiBinaryExpression expression) { - super.visitBinaryExpression(expression); - final PsiExpression rhs = expression.getROperand(); - if (rhs == null) { - return; - } - if (!ComparisonUtils.isComparison(expression)) { - return; - } - final PsiExpression lhs = expression.getLOperand(); - if (lhs instanceof PsiMethodCallExpression) { - final String replacementIsEmptyCall = getReplacementIsEmptyCall(lhs, rhs, false, expression.getOperationTokenType()); - if (replacementIsEmptyCall != null) { - registerError(expression, replacementIsEmptyCall); + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + return new SizeReplaceableByIsEmptyFix(); + } + + private static class SizeReplaceableByIsEmptyFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.sizeReplaceableByIsemptyQuickfix(); } - } else if (rhs instanceof PsiMethodCallExpression) { - final String replacementIsEmptyCall = getReplacementIsEmptyCall(rhs, lhs, true, expression.getOperationTokenType()); - if (replacementIsEmptyCall != null) { - registerError(expression, replacementIsEmptyCall); + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiBinaryExpression binaryExpression = (PsiBinaryExpression) descriptor.getPsiElement(); + PsiExpression operand = binaryExpression.getLOperand(); + if (!(operand instanceof PsiMethodCallExpression)) { + operand = binaryExpression.getROperand(); + } + if (!(operand instanceof PsiMethodCallExpression)) { + return; + } + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) operand; + final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + final PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); + if (qualifierExpression == null) { + return; + } + @NonNls String newExpression = qualifierExpression.getText(); + final IElementType tokenType = binaryExpression.getOperationTokenType(); + if (!JavaTokenType.EQEQ.equals(tokenType)) { + newExpression = '!' + newExpression; + } + newExpression += ".isEmpty()"; + replaceExpression(binaryExpression, newExpression); } - } } - @Nullable - private String getReplacementIsEmptyCall(PsiExpression lhs, PsiExpression rhs, boolean flipped, IElementType tokenType) { - final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) lhs; - final String isEmptyCall = getIsEmptyCall(callExpression); - if (isEmptyCall == null) { - return null; - } - final Object object = ExpressionUtils.computeConstantExpression(rhs); - if (!(object instanceof Integer)) { - return null; - } - final Integer integer = (Integer) object; - final int constant = integer.intValue(); - if (constant != 0) { - return null; - } - if (JavaTokenType.EQEQ.equals(tokenType)) { - return isEmptyCall; - } - if (ignoreNegations) { - return null; - } - if (JavaTokenType.NE.equals(tokenType)) { - return '!' + isEmptyCall; - } else if (flipped) { - if (JavaTokenType.LT.equals(tokenType)) { - return '!' + isEmptyCall; - } - } else if (JavaTokenType.GT.equals(tokenType)) { - return '!' + isEmptyCall; - } - return null; + @Override + public BaseInspectionVisitor buildVisitor() { + return new SizeReplaceableByIsEmptyVisitor(); } - @Nullable - private String getIsEmptyCall(PsiMethodCallExpression callExpression) { - final PsiReferenceExpression methodExpression = callExpression.getMethodExpression(); - final String referenceName = methodExpression.getReferenceName(); - if (!HardcodedMethodConstants.SIZE.equals(referenceName) && - !HardcodedMethodConstants.LENGTH.equals(referenceName)) { - return null; - } - final PsiExpressionList argumentList = callExpression.getArgumentList(); - final PsiExpression[] expressions = argumentList.getExpressions(); - if (expressions.length != 0) { - return null; - } - final PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); - if (qualifierExpression == null) { - return null; - } - final PsiType type = qualifierExpression.getType(); - if (!(type instanceof PsiClassType)) { - return null; - } - final PsiClassType classType = (PsiClassType) type; - final PsiClass aClass = classType.resolve(); - if (aClass == null) { - return null; - } - if (PsiTreeUtil.isAncestor(aClass, callExpression, true)) { - return null; - } - for (String ignoredType : ignoredTypes) { - if (InheritanceUtil.isInheritor(aClass, ignoredType)) { - return null; + private class SizeReplaceableByIsEmptyVisitor extends BaseInspectionVisitor { + + @Override + public void visitBinaryExpression(PsiBinaryExpression expression) { + super.visitBinaryExpression(expression); + final PsiExpression rhs = expression.getROperand(); + if (rhs == null) { + return; + } + if (!ComparisonUtils.isComparison(expression)) { + return; + } + final PsiExpression lhs = expression.getLOperand(); + if (lhs instanceof PsiMethodCallExpression) { + final String replacementIsEmptyCall = getReplacementIsEmptyCall(lhs, rhs, false, expression.getOperationTokenType()); + if (replacementIsEmptyCall != null) { + registerError(expression, replacementIsEmptyCall); + } + } + else if (rhs instanceof PsiMethodCallExpression) { + final String replacementIsEmptyCall = getReplacementIsEmptyCall(rhs, lhs, true, expression.getOperationTokenType()); + if (replacementIsEmptyCall != null) { + registerError(expression, replacementIsEmptyCall); + } + } } - } - final PsiMethod[] methods = aClass.findMethodsByName("isEmpty", true); - for (PsiMethod method : methods) { - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() == 0) { - return qualifierExpression.getText() + ".isEmpty()"; + + @Nullable + private String getReplacementIsEmptyCall(PsiExpression lhs, PsiExpression rhs, boolean flipped, IElementType tokenType) { + final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) lhs; + final String isEmptyCall = getIsEmptyCall(callExpression); + if (isEmptyCall == null) { + return null; + } + final Object object = ExpressionUtils.computeConstantExpression(rhs); + if (!(object instanceof Integer)) { + return null; + } + final Integer integer = (Integer) object; + final int constant = integer.intValue(); + if (constant != 0) { + return null; + } + if (JavaTokenType.EQEQ.equals(tokenType)) { + return isEmptyCall; + } + if (ignoreNegations) { + return null; + } + if (JavaTokenType.NE.equals(tokenType)) { + return '!' + isEmptyCall; + } + else if (flipped) { + if (JavaTokenType.LT.equals(tokenType)) { + return '!' + isEmptyCall; + } + } + else if (JavaTokenType.GT.equals(tokenType)) { + return '!' + isEmptyCall; + } + return null; + } + + @Nullable + private String getIsEmptyCall(PsiMethodCallExpression callExpression) { + final PsiReferenceExpression methodExpression = callExpression.getMethodExpression(); + final String referenceName = methodExpression.getReferenceName(); + if (!HardcodedMethodConstants.SIZE.equals(referenceName) && + !HardcodedMethodConstants.LENGTH.equals(referenceName)) { + return null; + } + final PsiExpressionList argumentList = callExpression.getArgumentList(); + final PsiExpression[] expressions = argumentList.getExpressions(); + if (expressions.length != 0) { + return null; + } + final PsiExpression qualifierExpression = methodExpression.getQualifierExpression(); + if (qualifierExpression == null) { + return null; + } + final PsiType type = qualifierExpression.getType(); + if (!(type instanceof PsiClassType)) { + return null; + } + final PsiClassType classType = (PsiClassType) type; + final PsiClass aClass = classType.resolve(); + if (aClass == null) { + return null; + } + if (PsiTreeUtil.isAncestor(aClass, callExpression, true)) { + return null; + } + for (String ignoredType : ignoredTypes) { + if (InheritanceUtil.isInheritor(aClass, ignoredType)) { + return null; + } + } + final PsiMethod[] methods = aClass.findMethodsByName("isEmpty", true); + for (PsiMethod method : methods) { + final PsiParameterList parameterList = method.getParameterList(); + if (parameterList.getParametersCount() == 0) { + return qualifierExpression.getText() + ".isEmpty()"; + } + } + return null; } - } - return null; } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/StringBufferReplaceableByStringInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/StringBufferReplaceableByStringInspection.java index 9a8231e76..1ae660805 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/StringBufferReplaceableByStringInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/StringBufferReplaceableByStringInspection.java @@ -28,304 +28,301 @@ 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 consulo.util.lang.StringUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class StringBufferReplaceableByStringInspection extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.stringBufferReplaceableByStringDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiElement element = (PsiElement)infos[0]; - if (element instanceof PsiNewExpression) { - return InspectionGadgetsLocalize.newStringBufferReplaceableByStringProblemDescriptor().get(); + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.stringBufferReplaceableByStringDisplayName(); } - final String typeText = ((PsiType)infos[1]).getPresentableText(); - return InspectionGadgetsLocalize.stringBufferReplaceableByStringProblemDescriptor(typeText).get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - final String typeText = ((PsiType)infos[1]).getCanonicalText(); - return new StringBufferReplaceableByStringFix(CommonClassNames.JAVA_LANG_STRING_BUILDER.equals(typeText)); - } - private static class StringBufferReplaceableByStringFix extends InspectionGadgetsFix { - - private final boolean isStringBuilder; - - private StringBufferReplaceableByStringFix(boolean isStringBuilder) { - this.isStringBuilder = isStringBuilder; + @Override + @Nonnull + public String buildErrorString(Object... infos) { + final PsiElement element = (PsiElement) infos[0]; + if (element instanceof PsiNewExpression) { + return InspectionGadgetsLocalize.newStringBufferReplaceableByStringProblemDescriptor().get(); + } + final String typeText = ((PsiType) infos[1]).getPresentableText(); + return InspectionGadgetsLocalize.stringBufferReplaceableByStringProblemDescriptor(typeText).get(); } - @Nonnull @Override - public String getName() { - return isStringBuilder - ? InspectionGadgetsLocalize.stringBuilderReplaceableByStringQuickfix().get() - : InspectionGadgetsLocalize.stringBufferReplaceableByStringQuickfix().get(); + protected InspectionGadgetsFix buildFix(Object... infos) { + final String typeText = ((PsiType) infos[1]).getCanonicalText(); + return new StringBufferReplaceableByStringFix(CommonClassNames.JAVA_LANG_STRING_BUILDER.equals(typeText)); } - @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiVariable)) { - if (parent instanceof PsiNewExpression) { - final PsiNewExpression newExpression = (PsiNewExpression)parent; - final PsiExpression stringBuilderExpression = getCompleteExpression(newExpression); - final StringBuilder stringExpression = buildStringExpression(stringBuilderExpression, new StringBuilder()); - if (stringExpression != null && stringBuilderExpression != null) { - replaceExpression(stringBuilderExpression, stringExpression.toString()); - } + private static class StringBufferReplaceableByStringFix extends InspectionGadgetsFix { + private final boolean isStringBuilder; + + private StringBufferReplaceableByStringFix(boolean isStringBuilder) { + this.isStringBuilder = isStringBuilder; } - return; - } - final PsiVariable variable = (PsiVariable)parent; - final PsiTypeElement originalTypeElement = variable.getTypeElement(); - if (originalTypeElement == null) { - return; - } - final PsiExpression initializer = variable.getInitializer(); - if (initializer == null) { - return; - } - final StringBuilder stringExpression = buildStringExpression(initializer, new StringBuilder()); - if (stringExpression == null) { - return; - } - final PsiClassType javaLangString = TypeUtils.getStringType(variable); - final PsiTypeElement typeElement = JavaPsiFacade.getElementFactory(project).createTypeElement(javaLangString); - replaceExpression(initializer, stringExpression.toString()); - originalTypeElement.replace(typeElement); - } - @Nullable - private static StringBuilder buildStringExpression(PsiExpression expression, @NonNls StringBuilder result) { - if (expression instanceof PsiNewExpression) { - final PsiNewExpression newExpression = (PsiNewExpression)expression; - final PsiExpressionList argumentList = newExpression.getArgumentList(); - if (argumentList == null) { - return null; + @Nonnull + @Override + public LocalizeValue getName() { + return isStringBuilder + ? InspectionGadgetsLocalize.stringBuilderReplaceableByStringQuickfix() + : InspectionGadgetsLocalize.stringBufferReplaceableByStringQuickfix(); } - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length == 1) { - final PsiExpression argument = arguments[0]; - final PsiType type = argument.getType(); - if (!PsiType.INT.equals(type)) { - result.append(argument.getText()); - if (type != null && type.equalsToText(CommonClassNames.JAVA_LANG_CHAR_SEQUENCE)) { - result.append(".toString()"); + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (!(parent instanceof PsiVariable)) { + if (parent instanceof PsiNewExpression) { + final PsiNewExpression newExpression = (PsiNewExpression) parent; + final PsiExpression stringBuilderExpression = getCompleteExpression(newExpression); + final StringBuilder stringExpression = buildStringExpression(stringBuilderExpression, new StringBuilder()); + if (stringExpression != null && stringBuilderExpression != null) { + replaceExpression(stringBuilderExpression, stringExpression.toString()); + } + } + return; } - } - } - final PsiElement parent = expression.getParent(); - if (result.length() == 0 && parent instanceof PsiVariable) { - result.append("\"\""); - } - return result; - } - else if (expression instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression; - final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - result = buildStringExpression(qualifier, result); - if (result == null) { - return null; - } - if ("toString".equals(methodExpression.getReferenceName())) { - if (result.length() == 0) { - result.append("\"\""); - } - } - else { - final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length != 1) { - return null; - } - final PsiExpression argument = arguments[0]; - final PsiType type = argument.getType(); - final String argumentText = argument.getText(); - if (result.length() != 0) { - result.append('+'); - if (ParenthesesUtils.getPrecedence(argument) > ParenthesesUtils.ADDITIVE_PRECEDENCE || - (type instanceof PsiPrimitiveType && ParenthesesUtils.getPrecedence(argument) == ParenthesesUtils.ADDITIVE_PRECEDENCE)) { - result.append('(').append(argumentText).append(')'); + final PsiVariable variable = (PsiVariable) parent; + final PsiTypeElement originalTypeElement = variable.getTypeElement(); + if (originalTypeElement == null) { + return; } - else { - if (StringUtil.startsWithChar(argumentText, '+')) { - result.append(' '); - } - result.append(argumentText); + final PsiExpression initializer = variable.getInitializer(); + if (initializer == null) { + return; } - } - else { - if (type instanceof PsiPrimitiveType) { - if (argument instanceof PsiLiteralExpression) { - final PsiLiteralExpression literalExpression = (PsiLiteralExpression)argument; - result.append('"').append(literalExpression.getValue()).append('"'); - } - else { - result.append("String.valueOf(").append(argumentText).append(")"); - } + final StringBuilder stringExpression = buildStringExpression(initializer, new StringBuilder()); + if (stringExpression == null) { + return; } - else { - if (ParenthesesUtils.getPrecedence(argument) >= ParenthesesUtils.ADDITIVE_PRECEDENCE) { - result.append('(').append(argumentText).append(')'); - } - else { - if (type != null && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { - result.append("String.valueOf(").append(argumentText).append(")"); + final PsiClassType javaLangString = TypeUtils.getStringType(variable); + final PsiTypeElement typeElement = JavaPsiFacade.getElementFactory(project).createTypeElement(javaLangString); + replaceExpression(initializer, stringExpression.toString()); + originalTypeElement.replace(typeElement); + } + + @Nullable + private static StringBuilder buildStringExpression(PsiExpression expression, StringBuilder result) { + if (expression instanceof PsiNewExpression) { + final PsiNewExpression newExpression = (PsiNewExpression) expression; + final PsiExpressionList argumentList = newExpression.getArgumentList(); + if (argumentList == null) { + return null; + } + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length == 1) { + final PsiExpression argument = arguments[0]; + final PsiType type = argument.getType(); + if (!PsiType.INT.equals(type)) { + result.append(argument.getText()); + if (type != null && type.equalsToText(CommonClassNames.JAVA_LANG_CHAR_SEQUENCE)) { + result.append(".toString()"); + } + } + } + final PsiElement parent = expression.getParent(); + if (result.length() == 0 && parent instanceof PsiVariable) { + result.append("\"\""); + } + return result; + } + else if (expression instanceof PsiMethodCallExpression) { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression; + final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + result = buildStringExpression(qualifier, result); + if (result == null) { + return null; + } + if ("toString".equals(methodExpression.getReferenceName())) { + if (result.length() == 0) { + result.append("\"\""); + } } else { - result.append(argumentText); + final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 1) { + return null; + } + final PsiExpression argument = arguments[0]; + final PsiType type = argument.getType(); + final String argumentText = argument.getText(); + if (result.length() != 0) { + result.append('+'); + if (ParenthesesUtils.getPrecedence(argument) > ParenthesesUtils.ADDITIVE_PRECEDENCE || + (type instanceof PsiPrimitiveType && ParenthesesUtils.getPrecedence(argument) == ParenthesesUtils.ADDITIVE_PRECEDENCE)) { + result.append('(').append(argumentText).append(')'); + } + else { + if (StringUtil.startsWithChar(argumentText, '+')) { + result.append(' '); + } + result.append(argumentText); + } + } + else { + if (type instanceof PsiPrimitiveType) { + if (argument instanceof PsiLiteralExpression) { + final PsiLiteralExpression literalExpression = (PsiLiteralExpression) argument; + result.append('"').append(literalExpression.getValue()).append('"'); + } + else { + result.append("String.valueOf(").append(argumentText).append(")"); + } + } + else { + if (ParenthesesUtils.getPrecedence(argument) >= ParenthesesUtils.ADDITIVE_PRECEDENCE) { + result.append('(').append(argumentText).append(')'); + } + else { + if (type != null && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { + result.append("String.valueOf(").append(argumentText).append(")"); + } + else { + result.append(argumentText); + } + } + } + } } - } + return result; } - } + return null; } - return result; - } - return null; } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new StringBufferReplaceableByStringVisitor(); - } - - private static class StringBufferReplaceableByStringVisitor extends BaseInspectionVisitor { @Override - public void visitLocalVariable(@Nonnull PsiLocalVariable variable) { - super.visitLocalVariable(variable); - final PsiCodeBlock codeBlock = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class); - if (codeBlock == null) { - return; - } - final PsiType type = variable.getType(); - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUFFER, type) && - !TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUILDER, type)) { - return; - } - final PsiExpression initializer = variable.getInitializer(); - if (initializer == null) { - return; - } - if (!isNewStringBufferOrStringBuilder(initializer)) { - return; - } - if (VariableAccessUtils.variableIsAssigned(variable, codeBlock)) { - return; - } - if (VariableAccessUtils.variableIsAssignedFrom(variable, codeBlock)) { - return; - } - if (VariableAccessUtils.variableIsReturned(variable, codeBlock)) { - return; - } - if (VariableAccessUtils.variableIsPassedAsMethodArgument(variable, codeBlock)) { - return; - } - if (variableIsModified(variable, codeBlock)) { - return; - } - registerVariableError(variable, variable, type); + public BaseInspectionVisitor buildVisitor() { + return new StringBufferReplaceableByStringVisitor(); } - @Override - public void visitNewExpression(PsiNewExpression expression) { - super.visitNewExpression(expression); - final PsiType type = expression.getType(); - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUFFER, type) && - !TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUILDER, type)) { - return; - } - final PsiExpression completeExpression = getCompleteExpression(expression); - if (completeExpression == null) { - return; - } - registerNewExpressionError(expression, expression, type); - } + private static class StringBufferReplaceableByStringVisitor extends BaseInspectionVisitor { + @Override + public void visitLocalVariable(@Nonnull PsiLocalVariable variable) { + super.visitLocalVariable(variable); + final PsiCodeBlock codeBlock = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class); + if (codeBlock == null) { + return; + } + final PsiType type = variable.getType(); + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUFFER, type) && + !TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUILDER, type)) { + return; + } + final PsiExpression initializer = variable.getInitializer(); + if (initializer == null) { + return; + } + if (!isNewStringBufferOrStringBuilder(initializer)) { + return; + } + if (VariableAccessUtils.variableIsAssigned(variable, codeBlock)) { + return; + } + if (VariableAccessUtils.variableIsAssignedFrom(variable, codeBlock)) { + return; + } + if (VariableAccessUtils.variableIsReturned(variable, codeBlock)) { + return; + } + if (VariableAccessUtils.variableIsPassedAsMethodArgument(variable, codeBlock)) { + return; + } + if (variableIsModified(variable, codeBlock)) { + return; + } + registerVariableError(variable, variable, type); + } - public static boolean variableIsModified(PsiVariable variable, PsiElement context) { - final VariableIsModifiedVisitor visitor = new VariableIsModifiedVisitor(variable); - context.accept(visitor); - return visitor.isModified(); - } + @Override + public void visitNewExpression(PsiNewExpression expression) { + super.visitNewExpression(expression); + final PsiType type = expression.getType(); + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUFFER, type) && + !TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING_BUILDER, type)) { + return; + } + final PsiExpression completeExpression = getCompleteExpression(expression); + if (completeExpression == null) { + return; + } + registerNewExpressionError(expression, expression, type); + } - private static boolean isNewStringBufferOrStringBuilder(PsiExpression expression) { - if (expression == null) { - return false; - } - else if (expression instanceof PsiNewExpression) { - return true; - } - else if (expression instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression; - if (!isAppend(methodCallExpression)) { - return false; + public static boolean variableIsModified(PsiVariable variable, PsiElement context) { + final VariableIsModifiedVisitor visitor = new VariableIsModifiedVisitor(variable); + context.accept(visitor); + return visitor.isModified(); } - final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - return isNewStringBufferOrStringBuilder(qualifier); - } - return false; - } - public static boolean isAppend(PsiMethodCallExpression methodCallExpression) { - final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - @NonNls final String methodName = methodExpression.getReferenceName(); - return "append".equals(methodName); - } - } + private static boolean isNewStringBufferOrStringBuilder(PsiExpression expression) { + if (expression == null) { + return false; + } + else if (expression instanceof PsiNewExpression) { + return true; + } + else if (expression instanceof PsiMethodCallExpression) { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression; + if (!isAppend(methodCallExpression)) { + return false; + } + final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + return isNewStringBufferOrStringBuilder(qualifier); + } + return false; + } - @Nullable - private static PsiExpression getCompleteExpression(PsiNewExpression expression) { - PsiElement completeExpression = expression; - boolean found = false; - while (true) { - final PsiElement parent = completeExpression.getParent(); - if (!(parent instanceof PsiReferenceExpression)) { - break; - } - final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)parent; - final PsiElement grandParent = parent.getParent(); - if (!(grandParent instanceof PsiMethodCallExpression)) { - break; - } - @NonNls final String name = referenceExpression.getReferenceName(); - if ("append".equals(name)) { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)grandParent; - final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length != 1) { - return null; + public static boolean isAppend(PsiMethodCallExpression methodCallExpression) { + final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + final String methodName = methodExpression.getReferenceName(); + return "append".equals(methodName); } - } - else { - if (!"toString".equals(name)) { - return null; + } + + @Nullable + private static PsiExpression getCompleteExpression(PsiNewExpression expression) { + PsiElement completeExpression = expression; + boolean found = false; + while (true) { + final PsiElement parent = completeExpression.getParent(); + if (!(parent instanceof PsiReferenceExpression)) { + break; + } + final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) parent; + final PsiElement grandParent = parent.getParent(); + if (!(grandParent instanceof PsiMethodCallExpression)) { + break; + } + final String name = referenceExpression.getReferenceName(); + if ("append".equals(name)) { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent; + final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 1) { + return null; + } + } + else { + if (!"toString".equals(name)) { + return null; + } + found = true; + } + completeExpression = grandParent; + if (found) { + return (PsiExpression) completeExpression; + } } - found = true; - } - completeExpression = grandParent; - if (found) { - return (PsiExpression)completeExpression; - } + return null; } - return null; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/TypeParameterExtendsObjectInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/TypeParameterExtendsObjectInspection.java index 5e7b250a5..093427c9a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/TypeParameterExtendsObjectInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/TypeParameterExtendsObjectInspection.java @@ -26,136 +26,127 @@ 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 TypeParameterExtendsObjectInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.typeParameterExtendsObjectDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.typeParameterExtendsObjectDisplayName().get(); - } - - @Override - @Nonnull - public String getID() { - return "TypeParameterExplicitlyExtendsObject"; - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final Integer type = (Integer)infos[0]; - return type == 1 - ? InspectionGadgetsLocalize.typeParameterExtendsObjectProblemDescriptor1().get() - : InspectionGadgetsLocalize.typeParameterExtendsObjectProblemDescriptor2().get(); - } - - @Override - public boolean isEnabledByDefault() { - return true; - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new ExtendsObjectFix(); - } - - private static class ExtendsObjectFix extends InspectionGadgetsFix { + @Override + @Nonnull + public String getID() { + return "TypeParameterExplicitlyExtendsObject"; + } + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.extendsObjectRemoveQuickfix().get(); + protected String buildErrorString(Object... infos) { + final Integer type = (Integer) infos[0]; + return type == 1 + ? InspectionGadgetsLocalize.typeParameterExtendsObjectProblemDescriptor1().get() + : InspectionGadgetsLocalize.typeParameterExtendsObjectProblemDescriptor2().get(); + } + + @Override + public boolean isEnabledByDefault() { + return true; } @Override - public void doFix(@Nonnull Project project, - ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement identifier = descriptor.getPsiElement(); - final PsiElement parent = identifier.getParent(); - if (parent instanceof PsiTypeParameter) { - final PsiTypeParameter typeParameter = - (PsiTypeParameter)parent; - final PsiReferenceList extendsList = - typeParameter.getExtendsList(); - final PsiJavaCodeReferenceElement[] referenceElements = - extendsList.getReferenceElements(); - for (PsiJavaCodeReferenceElement referenceElement : - referenceElements) { - deleteElement(referenceElement); + protected InspectionGadgetsFix buildFix(Object... infos) { + return new ExtendsObjectFix(); + } + + private static class ExtendsObjectFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.extendsObjectRemoveQuickfix(); } - } - else { - final PsiTypeElement typeElement = (PsiTypeElement)parent; - PsiElement child = typeElement.getLastChild(); - while (child != null) { - if (child instanceof PsiJavaToken) { - final PsiJavaToken javaToken = (PsiJavaToken)child; - final IElementType tokenType = javaToken.getTokenType(); - if (tokenType == JavaTokenType.QUEST) { - return; + + @Override + public void doFix(@Nonnull Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement identifier = descriptor.getPsiElement(); + final PsiElement parent = identifier.getParent(); + if (parent instanceof PsiTypeParameter) { + final PsiTypeParameter typeParameter = (PsiTypeParameter) parent; + final PsiReferenceList extendsList = typeParameter.getExtendsList(); + final PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements(); + for (PsiJavaCodeReferenceElement referenceElement : referenceElements) { + deleteElement(referenceElement); + } + } + else { + final PsiTypeElement typeElement = (PsiTypeElement) parent; + PsiElement child = typeElement.getLastChild(); + while (child != null) { + if (child instanceof PsiJavaToken) { + final PsiJavaToken javaToken = (PsiJavaToken) child; + final IElementType tokenType = javaToken.getTokenType(); + if (tokenType == JavaTokenType.QUEST) { + return; + } + } + child.delete(); + child = typeElement.getLastChild(); + } } - } - child.delete(); - child = typeElement.getLastChild(); } - } } - } - - public BaseInspectionVisitor buildVisitor() { - return new ExtendsObjectVisitor(); - } - - private static class ExtendsObjectVisitor extends BaseInspectionVisitor { - @Override - public void visitTypeParameter(PsiTypeParameter parameter) { - super.visitTypeParameter(parameter); - final PsiClassType[] extendsListTypes = - parameter.getExtendsListTypes(); - if (extendsListTypes.length != 1) { - return; - } - final PsiClassType extendsType = extendsListTypes[0]; - if (!extendsType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { - return; - } - final PsiIdentifier nameIdentifier = parameter.getNameIdentifier(); - if (nameIdentifier == null) { - return; - } - registerError(nameIdentifier, Integer.valueOf(1)); + public BaseInspectionVisitor buildVisitor() { + return new ExtendsObjectVisitor(); } + private static class ExtendsObjectVisitor extends BaseInspectionVisitor { + @Override + public void visitTypeParameter(PsiTypeParameter parameter) { + super.visitTypeParameter(parameter); + final PsiClassType[] extendsListTypes = parameter.getExtendsListTypes(); + if (extendsListTypes.length != 1) { + return; + } + final PsiClassType extendsType = extendsListTypes[0]; + if (!extendsType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { + return; + } + final PsiIdentifier nameIdentifier = parameter.getNameIdentifier(); + if (nameIdentifier == null) { + return; + } + registerError(nameIdentifier, Integer.valueOf(1)); + } - @Override - public void visitTypeElement(PsiTypeElement typeElement) { - super.visitTypeElement(typeElement); - final PsiElement lastChild = typeElement.getLastChild(); - if (!(lastChild instanceof PsiTypeElement)) { - return; - } - final PsiType type = typeElement.getType(); - if (!(type instanceof PsiWildcardType)) { - return; - } - final PsiWildcardType wildcardType = (PsiWildcardType)type; - if (!wildcardType.isExtends()) { - return; - } - final PsiType extendsBound = wildcardType.getBound(); - if (!TypeUtils.isJavaLangObject(extendsBound)) { - return; - } - final PsiElement firstChild = typeElement.getFirstChild(); - if (firstChild == null) { - return; - } - registerError(firstChild, Integer.valueOf(2)); + @Override + public void visitTypeElement(PsiTypeElement typeElement) { + super.visitTypeElement(typeElement); + final PsiElement lastChild = typeElement.getLastChild(); + if (!(lastChild instanceof PsiTypeElement)) { + return; + } + final PsiType type = typeElement.getType(); + if (!(type instanceof PsiWildcardType)) { + return; + } + final PsiWildcardType wildcardType = (PsiWildcardType) type; + if (!wildcardType.isExtends()) { + return; + } + final PsiType extendsBound = wildcardType.getBound(); + if (!TypeUtils.isJavaLangObject(extendsBound)) { + return; + } + final PsiElement firstChild = typeElement.getFirstChild(); + if (firstChild == null) { + return; + } + registerError(firstChild, Integer.valueOf(2)); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnclearBinaryExpressionInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnclearBinaryExpressionInspection.java index 3e00534d8..93caba368 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnclearBinaryExpressionInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnclearBinaryExpressionInspection.java @@ -27,289 +27,287 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiWhiteSpace; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; -import org.jetbrains.annotations.NonNls; @ExtensionImpl public class UnclearBinaryExpressionInspection extends BaseInspection { - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.unclearBinaryExpressionDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unclearBinaryExpressionProblemDescriptor().get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new UnclearBinaryExpressionFix(); - } - - private static class UnclearBinaryExpressionFix extends InspectionGadgetsFix { - @Nonnull @Override - public String getName() { - return InspectionGadgetsLocalize.unclearBinaryExpressionQuickfix().get(); + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unclearBinaryExpressionDisplayName(); } + @Nonnull @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - if (!(element instanceof PsiExpression)) { - return; - } - final PsiExpression expression = (PsiExpression)element; - final StringBuilder newExpressionText = createReplacementText(expression, new StringBuilder()); - replaceExpression(expression, newExpressionText.toString()); - } - - private static StringBuilder createReplacementText(@Nullable PsiExpression expression, StringBuilder out) { - if (expression instanceof PsiPolyadicExpression) { - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)expression; - final IElementType tokenType = polyadicExpression.getOperationTokenType(); - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiPolyadicExpression) { - final PsiPolyadicExpression parentPolyadicExpression = (PsiPolyadicExpression)parent; - final IElementType parentOperationSign = parentPolyadicExpression.getOperationTokenType(); - final boolean parentheses = !tokenType.equals(parentOperationSign); - appendText(polyadicExpression, parentheses, out); - } else { - final boolean parentheses = parent instanceof PsiConditionalExpression || parent instanceof PsiInstanceOfExpression; - appendText(polyadicExpression, parentheses, out); - } - } - else if (expression instanceof PsiParenthesizedExpression) { - final PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression)expression; - final PsiExpression unwrappedExpression = parenthesizedExpression.getExpression(); - final PsiElement parent = expression.getParent(); - if (!(parent instanceof PsiParenthesizedExpression)) { - out.append('('); - createReplacementText(unwrappedExpression, out); - out.append(')'); - } - else { - createReplacementText(unwrappedExpression, out); - } - } - else if (expression instanceof PsiInstanceOfExpression) { - final PsiInstanceOfExpression instanceofExpression = (PsiInstanceOfExpression)expression; - final PsiElement parent = expression.getParent(); - final boolean parentheses = mightBeConfusingExpression(parent); - appendText(instanceofExpression, parentheses, out); - } - else if (expression instanceof PsiConditionalExpression) { - final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)expression; - final PsiElement parent = expression.getParent(); - final boolean parentheses = mightBeConfusingExpression(parent); - appendText(conditionalExpression, parentheses, out); - } - else if (expression instanceof PsiAssignmentExpression) { - final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression; - final PsiElement parent = expression.getParent(); - final boolean parentheses = mightBeConfusingExpression(parent) && !isSimpleAssignment(assignmentExpression, parent); - appendText(assignmentExpression, parentheses, out); - } - else if (expression != null) { - out.append(expression.getText()); - } - return out; + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unclearBinaryExpressionProblemDescriptor().get(); } - private static boolean isSimpleAssignment(PsiAssignmentExpression assignmentExpression, PsiElement parent) { - if (!(parent instanceof PsiAssignmentExpression)) { - return false; - } - final PsiAssignmentExpression parentAssignmentExpression = (PsiAssignmentExpression)parent; - final IElementType parentTokenType = parentAssignmentExpression.getOperationTokenType(); - final IElementType tokenType = assignmentExpression.getOperationTokenType(); - return parentTokenType.equals(tokenType); + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + return new UnclearBinaryExpressionFix(); } - private static void appendText(PsiAssignmentExpression assignmentExpression, boolean parentheses, StringBuilder out) { - if (parentheses) { - out.append('('); - } - final PsiExpression lhs = assignmentExpression.getLExpression(); - out.append(lhs.getText()); - final PsiJavaToken sign = assignmentExpression.getOperationSign(); - out.append(sign.getText()); - final PsiExpression rhs = assignmentExpression.getRExpression(); - createReplacementText(rhs, out); - if (parentheses) { - out.append(')'); - } - } + private static class UnclearBinaryExpressionFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unclearBinaryExpressionQuickfix(); + } - private static void appendText(PsiInstanceOfExpression instanceofExpression, boolean parentheses, @NonNls StringBuilder out) { - if (parentheses) { - out.append('('); - } - final PsiExpression operand = instanceofExpression.getOperand(); - createReplacementText(operand, out); - out.append(" instanceof "); - final PsiTypeElement checkType = instanceofExpression.getCheckType(); - if (checkType != null) { - out.append(checkType.getText()); - } - if (parentheses) { - out.append(')'); - } - } + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + if (!(element instanceof PsiExpression)) { + return; + } + final PsiExpression expression = (PsiExpression) element; + final StringBuilder newExpressionText = createReplacementText(expression, new StringBuilder()); + replaceExpression(expression, newExpressionText.toString()); + } - private static void appendText(PsiConditionalExpression conditionalExpression, boolean parentheses, StringBuilder out) { - if (parentheses) { - out.append('('); - } - final PsiExpression condition = conditionalExpression.getCondition(); - createReplacementText(condition, out); - out.append('?'); - final PsiExpression thenExpression = conditionalExpression.getThenExpression(); - createReplacementText(thenExpression, out); - out.append(':'); - final PsiExpression elseExpression = conditionalExpression.getElseExpression(); - createReplacementText(elseExpression, out); - if (parentheses) { - out.append(')'); - } - } + private static StringBuilder createReplacementText(@Nullable PsiExpression expression, StringBuilder out) { + if (expression instanceof PsiPolyadicExpression) { + final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) expression; + final IElementType tokenType = polyadicExpression.getOperationTokenType(); + final PsiElement parent = expression.getParent(); + if (parent instanceof PsiPolyadicExpression) { + final PsiPolyadicExpression parentPolyadicExpression = (PsiPolyadicExpression) parent; + final IElementType parentOperationSign = parentPolyadicExpression.getOperationTokenType(); + final boolean parentheses = !tokenType.equals(parentOperationSign); + appendText(polyadicExpression, parentheses, out); + } + else { + final boolean parentheses = parent instanceof PsiConditionalExpression || parent instanceof PsiInstanceOfExpression; + appendText(polyadicExpression, parentheses, out); + } + } + else if (expression instanceof PsiParenthesizedExpression) { + final PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression) expression; + final PsiExpression unwrappedExpression = parenthesizedExpression.getExpression(); + final PsiElement parent = expression.getParent(); + if (!(parent instanceof PsiParenthesizedExpression)) { + out.append('('); + createReplacementText(unwrappedExpression, out); + out.append(')'); + } + else { + createReplacementText(unwrappedExpression, out); + } + } + else if (expression instanceof PsiInstanceOfExpression) { + final PsiInstanceOfExpression instanceofExpression = (PsiInstanceOfExpression) expression; + final PsiElement parent = expression.getParent(); + final boolean parentheses = mightBeConfusingExpression(parent); + appendText(instanceofExpression, parentheses, out); + } + else if (expression instanceof PsiConditionalExpression) { + final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression) expression; + final PsiElement parent = expression.getParent(); + final boolean parentheses = mightBeConfusingExpression(parent); + appendText(conditionalExpression, parentheses, out); + } + else if (expression instanceof PsiAssignmentExpression) { + final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) expression; + final PsiElement parent = expression.getParent(); + final boolean parentheses = mightBeConfusingExpression(parent) && !isSimpleAssignment(assignmentExpression, parent); + appendText(assignmentExpression, parentheses, out); + } + else if (expression != null) { + out.append(expression.getText()); + } + return out; + } - private static void appendText(PsiPolyadicExpression polyadicExpression, boolean parentheses, StringBuilder out) { - if (parentheses) { - out.append('('); - } - final PsiExpression[] operands = polyadicExpression.getOperands(); - for (PsiExpression operand : operands) { - if (operand == null) { - continue; + private static boolean isSimpleAssignment(PsiAssignmentExpression assignmentExpression, PsiElement parent) { + if (!(parent instanceof PsiAssignmentExpression)) { + return false; + } + final PsiAssignmentExpression parentAssignmentExpression = (PsiAssignmentExpression) parent; + final IElementType parentTokenType = parentAssignmentExpression.getOperationTokenType(); + final IElementType tokenType = assignmentExpression.getOperationTokenType(); + return parentTokenType.equals(tokenType); } - if (PsiType.VOID.equals(operand.getType())) { - throw new ProcessCanceledException(); + + private static void appendText(PsiAssignmentExpression assignmentExpression, boolean parentheses, StringBuilder out) { + if (parentheses) { + out.append('('); + } + final PsiExpression lhs = assignmentExpression.getLExpression(); + out.append(lhs.getText()); + final PsiJavaToken sign = assignmentExpression.getOperationSign(); + out.append(sign.getText()); + final PsiExpression rhs = assignmentExpression.getRExpression(); + createReplacementText(rhs, out); + if (parentheses) { + out.append(')'); + } } - if (operands.length == 1) { - createReplacementText(operand, out); + + private static void appendText(PsiInstanceOfExpression instanceofExpression, boolean parentheses, StringBuilder out) { + if (parentheses) { + out.append('('); + } + final PsiExpression operand = instanceofExpression.getOperand(); + createReplacementText(operand, out); + out.append(" instanceof "); + final PsiTypeElement checkType = instanceofExpression.getCheckType(); + if (checkType != null) { + out.append(checkType.getText()); + } + if (parentheses) { + out.append(')'); + } } - final PsiJavaToken token = polyadicExpression.getTokenBeforeOperand(operand); - if (token != null) { - final PsiElement beforeToken = token.getPrevSibling(); - if (beforeToken instanceof PsiWhiteSpace) { - out.append(beforeToken.getText()); - } - out.append(token.getText()); - final PsiElement afterToken = token.getNextSibling(); - if (afterToken instanceof PsiWhiteSpace) { - out.append(afterToken.getText()); - } + + private static void appendText(PsiConditionalExpression conditionalExpression, boolean parentheses, StringBuilder out) { + if (parentheses) { + out.append('('); + } + final PsiExpression condition = conditionalExpression.getCondition(); + createReplacementText(condition, out); + out.append('?'); + final PsiExpression thenExpression = conditionalExpression.getThenExpression(); + createReplacementText(thenExpression, out); + out.append(':'); + final PsiExpression elseExpression = conditionalExpression.getElseExpression(); + createReplacementText(elseExpression, out); + if (parentheses) { + out.append(')'); + } } - if (operands.length != 1) { - createReplacementText(operand, out); + + private static void appendText(PsiPolyadicExpression polyadicExpression, boolean parentheses, StringBuilder out) { + if (parentheses) { + out.append('('); + } + final PsiExpression[] operands = polyadicExpression.getOperands(); + for (PsiExpression operand : operands) { + if (operand == null) { + continue; + } + if (PsiType.VOID.equals(operand.getType())) { + throw new ProcessCanceledException(); + } + if (operands.length == 1) { + createReplacementText(operand, out); + } + final PsiJavaToken token = polyadicExpression.getTokenBeforeOperand(operand); + if (token != null) { + final PsiElement beforeToken = token.getPrevSibling(); + if (beforeToken instanceof PsiWhiteSpace) { + out.append(beforeToken.getText()); + } + out.append(token.getText()); + final PsiElement afterToken = token.getNextSibling(); + if (afterToken instanceof PsiWhiteSpace) { + out.append(afterToken.getText()); + } + } + if (operands.length != 1) { + createReplacementText(operand, out); + } + } + if (parentheses) { + out.append(')'); + } } - } - if (parentheses) { - out.append(')'); - } } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnclearBinaryExpressionVisitor(); - } - - private static class UnclearBinaryExpressionVisitor extends BaseInspectionVisitor { @Override - public void visitPolyadicExpression(PsiPolyadicExpression expression) { - super.visitPolyadicExpression(expression); - final PsiElement parent = expression.getParent(); - if (mightBeConfusingExpression(parent)) { - return; - } - final IElementType tokenType = expression.getOperationTokenType(); - final PsiExpression[] operands = expression.getOperands(); - for (PsiExpression operand : operands) { - if (operand instanceof PsiInstanceOfExpression) { - registerError(expression); - return; - } - if (!(operand instanceof PsiPolyadicExpression)) { - continue; + public BaseInspectionVisitor buildVisitor() { + return new UnclearBinaryExpressionVisitor(); + } + + private static class UnclearBinaryExpressionVisitor extends BaseInspectionVisitor { + @Override + public void visitPolyadicExpression(PsiPolyadicExpression expression) { + super.visitPolyadicExpression(expression); + final PsiElement parent = expression.getParent(); + if (mightBeConfusingExpression(parent)) { + return; + } + final IElementType tokenType = expression.getOperationTokenType(); + final PsiExpression[] operands = expression.getOperands(); + for (PsiExpression operand : operands) { + if (operand instanceof PsiInstanceOfExpression) { + registerError(expression); + return; + } + if (!(operand instanceof PsiPolyadicExpression)) { + continue; + } + final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) operand; + final IElementType childTokenType = polyadicExpression.getOperationTokenType(); + if (!tokenType.equals(childTokenType)) { + registerError(expression); + return; + } + } } - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)operand; - final IElementType childTokenType = polyadicExpression.getOperationTokenType(); - if (!tokenType.equals(childTokenType)) { - registerError(expression); - return; + + @Override + public void visitConditionalExpression(PsiConditionalExpression expression) { + super.visitConditionalExpression(expression); + final PsiElement parent = expression.getParent(); + if (mightBeConfusingExpression(parent)) { + return; + } + final PsiExpression condition = expression.getCondition(); + final PsiExpression thenExpression = expression.getThenExpression(); + final PsiExpression elseExpression = expression.getElseExpression(); + if (!mightBeConfusingExpression(condition) && !mightBeConfusingExpression(thenExpression) && + !mightBeConfusingExpression(elseExpression)) { + return; + } + registerError(expression); } - } - } - @Override - public void visitConditionalExpression(PsiConditionalExpression expression) { - super.visitConditionalExpression(expression); - final PsiElement parent = expression.getParent(); - if (mightBeConfusingExpression(parent)) { - return; - } - final PsiExpression condition = expression.getCondition(); - final PsiExpression thenExpression = expression.getThenExpression(); - final PsiExpression elseExpression = expression.getElseExpression(); - if (!mightBeConfusingExpression(condition) && !mightBeConfusingExpression(thenExpression) && - !mightBeConfusingExpression(elseExpression)) { - return; - } - registerError(expression); - } + @Override + public void visitInstanceOfExpression(PsiInstanceOfExpression expression) { + super.visitInstanceOfExpression(expression); + final PsiElement parent = expression.getParent(); + if (mightBeConfusingExpression(parent)) { + return; + } + final PsiExpression operand = expression.getOperand(); + if (!mightBeConfusingExpression(operand)) { + return; + } + registerError(expression); + } - @Override - public void visitInstanceOfExpression(PsiInstanceOfExpression expression) { - super.visitInstanceOfExpression(expression); - final PsiElement parent = expression.getParent(); - if (mightBeConfusingExpression(parent)) { - return; - } - final PsiExpression operand = expression.getOperand(); - if (!mightBeConfusingExpression(operand)) { - return; - } - registerError(expression); + @Override + public void visitAssignmentExpression(PsiAssignmentExpression expression) { + super.visitAssignmentExpression(expression); + final PsiElement parent = expression.getParent(); + if (mightBeConfusingExpression(parent)) { + return; + } + final PsiExpression rhs = expression.getRExpression(); + if (!mightBeConfusingExpression(rhs)) { + return; + } + if (!(rhs instanceof PsiAssignmentExpression)) { + return; + } + final PsiAssignmentExpression nestedAssignment = (PsiAssignmentExpression) rhs; + final IElementType nestedTokenType = nestedAssignment.getOperationTokenType(); + final IElementType tokenType = expression.getOperationTokenType(); + if (nestedTokenType.equals(tokenType)) { + return; + } + registerError(expression); + } } - @Override - public void visitAssignmentExpression(PsiAssignmentExpression expression) { - super.visitAssignmentExpression(expression); - final PsiElement parent = expression.getParent(); - if (mightBeConfusingExpression(parent)) { - return; - } - final PsiExpression rhs = expression.getRExpression(); - if (!mightBeConfusingExpression(rhs)) { - return; - } - if (!(rhs instanceof PsiAssignmentExpression)) { - return; - } - final PsiAssignmentExpression nestedAssignment = (PsiAssignmentExpression)rhs; - final IElementType nestedTokenType = nestedAssignment.getOperationTokenType(); - final IElementType tokenType = expression.getOperationTokenType(); - if (nestedTokenType.equals(tokenType)) { - return; - } - registerError(expression); + static boolean mightBeConfusingExpression(@Nullable PsiElement element) { + return element instanceof PsiPolyadicExpression + || element instanceof PsiConditionalExpression + || element instanceof PsiInstanceOfExpression + || element instanceof PsiAssignmentExpression; } - } - - static boolean mightBeConfusingExpression(@Nullable PsiElement element) { - return element instanceof PsiPolyadicExpression || element instanceof PsiConditionalExpression || - element instanceof PsiInstanceOfExpression || element instanceof PsiAssignmentExpression; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java index 461e47a79..d019bd196 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java @@ -33,164 +33,142 @@ import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.Nls; import javax.swing.*; @ExtensionImpl -public class UnnecessarilyQualifiedInnerClassAccessInspection - extends BaseInspection { +public class UnnecessarilyQualifiedInnerClassAccessInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean ignoreReferencesNeedingImport = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreReferencesNeedingImport = false; - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessDisplayName().get(); - } - - @Nonnull - @Override - @RequiredReadAction - protected String buildErrorString(Object... infos) { - final PsiClass aClass = (PsiClass)infos[0]; - return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessProblemDescriptor(aClass.getName()).get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreReferencesNeedingImport"); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarilyQualifiedInnerClassAccessFix(); - } - - private static class UnnecessarilyQualifiedInnerClassAccessFix - extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessDisplayName(); + } @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessQuickfix().get(); + @Override + @RequiredReadAction + protected String buildErrorString(Object... infos) { + final PsiClass aClass = (PsiClass) infos[0]; + return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessProblemDescriptor(aClass.getName()).get(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiJavaCodeReferenceElement)) { - return; - } - final PsiJavaCodeReferenceElement referenceElement = - (PsiJavaCodeReferenceElement)parent; - final PsiElement target = referenceElement.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - ImportUtils.addImportIfNeeded(aClass, element); - element.delete(); + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreReferencesNeedingImport"); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarilyQualifiedInnerClassAccessVisitor(); - } + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarilyQualifiedInnerClassAccessFix(); + } - private class UnnecessarilyQualifiedInnerClassAccessVisitor - extends BaseInspectionVisitor { + private static class UnnecessarilyQualifiedInnerClassAccessFix extends InspectionGadgetsFix { + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessarilyQualifiedInnerClassAccessQuickfix(); + } - @Override - public void visitReferenceElement( - PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - final PsiElement qualifier = reference.getQualifier(); - if (!(qualifier instanceof PsiJavaCodeReferenceElement)) { - return; - } - if (isInImportOrPackage(reference)) { - return; - } - final PsiJavaCodeReferenceElement referenceElement = - (PsiJavaCodeReferenceElement)qualifier; - final PsiReferenceParameterList parameterList = - referenceElement.getParameterList(); - if (parameterList != null && - parameterList.getTypeParameterElements().length > 0) { - return; - } - final PsiElement qualifierTarget = referenceElement.resolve(); - if (!(qualifierTarget instanceof PsiClass)) { - return; - } - final PsiClass referenceClass = - PsiTreeUtil.getParentOfType(reference, PsiClass.class); - if (referenceClass == null) { - return; - } - if (!referenceClass.equals(qualifierTarget) || - PsiTreeUtil.isAncestor(referenceClass.getModifierList(), - reference, true)) { - if (ignoreReferencesNeedingImport && - (PsiTreeUtil.isAncestor(referenceClass, qualifierTarget, - true) || - !PsiTreeUtil.isAncestor(qualifierTarget, - referenceClass, true))) { - return; + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (!(parent instanceof PsiJavaCodeReferenceElement)) { + return; + } + final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) parent; + final PsiElement target = referenceElement.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + ImportUtils.addImportIfNeeded(aClass, element); + element.delete(); } - } - final PsiElement target = reference.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - final PsiClass containingClass = aClass.getContainingClass(); - if (containingClass == null) { - return; - } - if (!containingClass.equals(qualifierTarget)) { - return; - } - final String shortName = aClass.getName(); - if (!isReferenceToTarget(shortName, aClass, reference)) { - return; - } - registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, aClass); } @Override - public void visitReferenceExpression( - PsiReferenceExpression expression) { - visitReferenceElement(expression); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarilyQualifiedInnerClassAccessVisitor(); } - private boolean isReferenceToTarget(String referenceText, PsiClass target, PsiElement context) { - final PsiManager manager = target.getManager(); - final JavaPsiFacade facade = - JavaPsiFacade.getInstance(manager.getProject()); - final PsiResolveHelper resolveHelper = facade.getResolveHelper(); - final PsiClass referencedClass = - resolveHelper.resolveReferencedClass(referenceText, - context); - return manager.areElementsEquivalent(target, referencedClass); - } + private class UnnecessarilyQualifiedInnerClassAccessVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + super.visitReferenceElement(reference); + final PsiElement qualifier = reference.getQualifier(); + if (!(qualifier instanceof PsiJavaCodeReferenceElement)) { + return; + } + if (isInImportOrPackage(reference)) { + return; + } + final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) qualifier; + final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); + if (parameterList != null && parameterList.getTypeParameterElements().length > 0) { + return; + } + final PsiElement qualifierTarget = referenceElement.resolve(); + if (!(qualifierTarget instanceof PsiClass)) { + return; + } + final PsiClass referenceClass = PsiTreeUtil.getParentOfType(reference, PsiClass.class); + if (referenceClass == null) { + return; + } + if (!referenceClass.equals(qualifierTarget) + || PsiTreeUtil.isAncestor(referenceClass.getModifierList(), reference, true)) { + if (ignoreReferencesNeedingImport + && (PsiTreeUtil.isAncestor(referenceClass, qualifierTarget, true) + || !PsiTreeUtil.isAncestor(qualifierTarget, referenceClass, true))) { + return; + } + } + final PsiElement target = reference.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + final PsiClass containingClass = aClass.getContainingClass(); + if (containingClass == null) { + return; + } + if (!containingClass.equals(qualifierTarget)) { + return; + } + final String shortName = aClass.getName(); + if (!isReferenceToTarget(shortName, aClass, reference)) { + return; + } + registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, aClass); + } + + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + visitReferenceElement(expression); + } + + private boolean isReferenceToTarget(String referenceText, PsiClass target, PsiElement context) { + final PsiManager manager = target.getManager(); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); + final PsiResolveHelper resolveHelper = facade.getResolveHelper(); + final PsiClass referencedClass = resolveHelper.resolveReferencedClass(referenceText, context); + return manager.areElementsEquivalent(target, referencedClass); + } - private boolean isInImportOrPackage(PsiElement element) { - while (element instanceof PsiJavaCodeReferenceElement) { - element = element.getParent(); - if (element instanceof PsiImportStatementBase || - element instanceof PsiPackageStatement || - element instanceof PsiImportStaticReferenceElement) { - return true; + private boolean isInImportOrPackage(PsiElement element) { + while (element instanceof PsiJavaCodeReferenceElement) { + element = element.getParent(); + if (element instanceof PsiImportStatementBase || + element instanceof PsiPackageStatement || + element instanceof PsiImportStaticReferenceElement) { + return true; + } + } + return false; } - } - return false; } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticUsageInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticUsageInspection.java index be8e12bfa..6d362b971 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticUsageInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticUsageInspection.java @@ -28,220 +28,227 @@ import consulo.language.editor.inspection.ProblemHighlightType; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; import javax.swing.*; public abstract class UnnecessarilyQualifiedStaticUsageInspection extends BaseInspection implements CleanupLocalInspectionTool { + /** + * @noinspection PublicField + */ + public boolean m_ignoreStaticFieldAccesses = false; - /** - * @noinspection PublicField - */ - public boolean m_ignoreStaticFieldAccesses = false; - - /** - * @noinspection PublicField - */ - public boolean m_ignoreStaticMethodCalls = false; - - /** - * @noinspection PublicField - */ - public boolean m_ignoreStaticAccessFromStaticContext = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiJavaCodeReferenceElement element = (PsiJavaCodeReferenceElement) infos[0]; - final PsiElement parent = element.getParent(); - return parent instanceof PsiMethodCallExpression - ? InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageProblemDescriptor(element.getText()).get() - : InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageProblemDescriptor1(element.getText()).get(); - } - - @Override - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageIgnoreFieldOption().get(), - "m_ignoreStaticFieldAccesses" - ); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageIgnoreMethodOption().get(), - "m_ignoreStaticMethodCalls" - ); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.onlyReportQualifiedStaticUsagesOption().get(), - "m_ignoreStaticAccessFromStaticContext" - ); - return optionsPanel; - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarilyQualifiedStaticUsageFix(); - } - - private static class UnnecessarilyQualifiedStaticUsageFix extends InspectionGadgetsFix { + /** + * @noinspection PublicField + */ + public boolean m_ignoreStaticMethodCalls = false; + + /** + * @noinspection PublicField + */ + public boolean m_ignoreStaticAccessFromStaticContext = false; - @Override @Nonnull - public String getFamilyName() { - return InspectionGadgetsLocalize.unnecessaryQualifierForThisRemoveQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageDisplayName(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - element.delete(); + @Nonnull + public String buildErrorString(Object... infos) { + final PsiJavaCodeReferenceElement element = (PsiJavaCodeReferenceElement) infos[0]; + final PsiElement parent = element.getParent(); + return parent instanceof PsiMethodCallExpression + ? InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageProblemDescriptor(element.getText()).get() + : InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageProblemDescriptor1(element.getText()).get(); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarilyQualifiedStaticUsageVisitor(); - } - - private class UnnecessarilyQualifiedStaticUsageVisitor extends BaseInspectionVisitor { @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - final PsiElement qualifier = reference.getQualifier(); - if (qualifier == null) { - return; - } - if (!isUnnecessarilyQualifiedAccess(reference, m_ignoreStaticAccessFromStaticContext, m_ignoreStaticFieldAccesses, m_ignoreStaticMethodCalls)) { - return; - } - registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, reference); + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageIgnoreFieldOption().get(), + "m_ignoreStaticFieldAccesses" + ); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.unnecessarilyQualifiedStaticUsageIgnoreMethodOption().get(), + "m_ignoreStaticMethodCalls" + ); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.onlyReportQualifiedStaticUsagesOption().get(), + "m_ignoreStaticAccessFromStaticContext" + ); + return optionsPanel; } @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { - visitReferenceElement(expression); - } - } - - public static boolean isUnnecessarilyQualifiedAccess(@Nonnull PsiJavaCodeReferenceElement referenceElement, - boolean ignoreStaticAccessFromStaticContext, - boolean ignoreStaticFieldAccesses, - boolean ignoreStaticMethodCalls) { - if (referenceElement instanceof PsiMethodReferenceExpression) { - return false; - } - final PsiElement parent = referenceElement.getParent(); - if (parent instanceof PsiImportStatementBase) { - return false; - } - final PsiElement qualifierElement = referenceElement.getQualifier(); - if (!(qualifierElement instanceof PsiJavaCodeReferenceElement)) { - return false; - } - final PsiJavaCodeReferenceElement qualifier = (PsiJavaCodeReferenceElement) qualifierElement; - if (isGenericReference(referenceElement, qualifier)) { - return false; - } - final PsiElement target = referenceElement.resolve(); - if ((!(target instanceof PsiField) || ignoreStaticFieldAccesses) && (!(target instanceof PsiMethod) || ignoreStaticMethodCalls)) { - return false; - } - if (ignoreStaticAccessFromStaticContext) { - final PsiMember containingMember = PsiTreeUtil.getParentOfType(referenceElement, PsiMember.class); - if (containingMember != null && !containingMember.hasModifierProperty(PsiModifier.STATIC)) { - return false; - } + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarilyQualifiedStaticUsageFix(); } - final String referenceName = referenceElement.getReferenceName(); - if (referenceName == null) { - return false; + + private static class UnnecessarilyQualifiedStaticUsageFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryQualifierForThisRemoveQuickfix(); + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + element.delete(); + } } - final PsiElement resolvedQualifier = qualifier.resolve(); - if (!(resolvedQualifier instanceof PsiClass)) { - return false; + + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarilyQualifiedStaticUsageVisitor(); + } + + private class UnnecessarilyQualifiedStaticUsageVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + super.visitReferenceElement(reference); + final PsiElement qualifier = reference.getQualifier(); + if (qualifier == null) { + return; + } + if (!isUnnecessarilyQualifiedAccess( + reference, + m_ignoreStaticAccessFromStaticContext, + m_ignoreStaticFieldAccesses, + m_ignoreStaticMethodCalls + )) { + return; + } + registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, reference); + } + + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + visitReferenceElement(expression); + } } - final PsiClass containingClass = PsiTreeUtil.getParentOfType(referenceElement, PsiClass.class); - final PsiClass qualifyingClass = (PsiClass) resolvedQualifier; - if (containingClass == null || !PsiTreeUtil.isAncestor(qualifyingClass, containingClass, false)) { - return false; + + public static boolean isUnnecessarilyQualifiedAccess( + @Nonnull PsiJavaCodeReferenceElement referenceElement, + boolean ignoreStaticAccessFromStaticContext, + boolean ignoreStaticFieldAccesses, + boolean ignoreStaticMethodCalls + ) { + if (referenceElement instanceof PsiMethodReferenceExpression) { + return false; + } + final PsiElement parent = referenceElement.getParent(); + if (parent instanceof PsiImportStatementBase) { + return false; + } + final PsiElement qualifierElement = referenceElement.getQualifier(); + if (!(qualifierElement instanceof PsiJavaCodeReferenceElement)) { + return false; + } + final PsiJavaCodeReferenceElement qualifier = (PsiJavaCodeReferenceElement) qualifierElement; + if (isGenericReference(referenceElement, qualifier)) { + return false; + } + final PsiElement target = referenceElement.resolve(); + if ((!(target instanceof PsiField) || ignoreStaticFieldAccesses) && (!(target instanceof PsiMethod) || ignoreStaticMethodCalls)) { + return false; + } + if (ignoreStaticAccessFromStaticContext) { + final PsiMember containingMember = PsiTreeUtil.getParentOfType(referenceElement, PsiMember.class); + if (containingMember != null && !containingMember.hasModifierProperty(PsiModifier.STATIC)) { + return false; + } + } + final String referenceName = referenceElement.getReferenceName(); + if (referenceName == null) { + return false; + } + final PsiElement resolvedQualifier = qualifier.resolve(); + if (!(resolvedQualifier instanceof PsiClass)) { + return false; + } + final PsiClass containingClass = PsiTreeUtil.getParentOfType(referenceElement, PsiClass.class); + final PsiClass qualifyingClass = (PsiClass) resolvedQualifier; + if (containingClass == null || !PsiTreeUtil.isAncestor(qualifyingClass, containingClass, false)) { + return false; + } + final Project project = referenceElement.getProject(); + final JavaPsiFacade manager = JavaPsiFacade.getInstance(project); + final PsiResolveHelper resolveHelper = manager.getResolveHelper(); + final PsiMember member = (PsiMember) target; + final PsiClass memberClass; + if (target instanceof PsiField) { + final PsiVariable variable = resolveHelper.resolveReferencedVariable(referenceName, referenceElement); + if (variable == null || !variable.equals(member)) { + return false; + } + final TextRange referenceElementTextRange = referenceElement.getTextRange(); + if (referenceElementTextRange == null) { + return false; + } + final TextRange variableTextRange = variable.getTextRange(); + if (variableTextRange == null) { + return false; + } + //illegal forward ref + if (referenceElementTextRange.getStartOffset() < variableTextRange.getEndOffset()) { + return false; + } + final PsiMember memberVariable = (PsiMember) variable; + memberClass = memberVariable.getContainingClass(); + } + else if (target instanceof PsiClass) { + final PsiClass aClass = resolveHelper.resolveReferencedClass(referenceName, referenceElement); + if (aClass == null || !aClass.equals(member)) { + return false; + } + memberClass = aClass.getContainingClass(); + } + else { + return isMethodAccessibleWithoutQualifier(referenceElement, qualifyingClass); + } + return resolvedQualifier.equals(memberClass); } - final Project project = referenceElement.getProject(); - final JavaPsiFacade manager = JavaPsiFacade.getInstance(project); - final PsiResolveHelper resolveHelper = manager.getResolveHelper(); - final PsiMember member = (PsiMember) target; - final PsiClass memberClass; - if (target instanceof PsiField) { - final PsiVariable variable = resolveHelper.resolveReferencedVariable(referenceName, referenceElement); - if (variable == null || !variable.equals(member)) { - return false; - } - final TextRange referenceElementTextRange = referenceElement.getTextRange(); - if (referenceElementTextRange == null) { - return false; - } - final TextRange variableTextRange = variable.getTextRange(); - if (variableTextRange == null) { - return false; - } - //illegal forward ref - if (referenceElementTextRange.getStartOffset() < variableTextRange.getEndOffset()) { - return false; - } - final PsiMember memberVariable = (PsiMember) variable; - memberClass = memberVariable.getContainingClass(); - } else if (target instanceof PsiClass) { - final PsiClass aClass = resolveHelper.resolveReferencedClass(referenceName, referenceElement); - if (aClass == null || !aClass.equals(member)) { + + private static boolean isMethodAccessibleWithoutQualifier(PsiJavaCodeReferenceElement referenceElement, PsiClass qualifyingClass) { + final String referenceName = referenceElement.getReferenceName(); + if (referenceName == null) { + return false; + } + PsiClass containingClass = ClassUtils.getContainingClass(referenceElement); + while (containingClass != null) { + final PsiMethod[] methods = containingClass.findMethodsByName(referenceName, true); + for (final PsiMethod method : methods) { + final String name = method.getName(); + if (referenceName.equals(name)) { + return containingClass.equals(qualifyingClass); + } + } + containingClass = ClassUtils.getContainingClass(containingClass); + } return false; - } - memberClass = aClass.getContainingClass(); - } else { - return isMethodAccessibleWithoutQualifier(referenceElement, qualifyingClass); } - return resolvedQualifier.equals(memberClass); - } - private static boolean isMethodAccessibleWithoutQualifier(PsiJavaCodeReferenceElement referenceElement, PsiClass qualifyingClass) { - final String referenceName = referenceElement.getReferenceName(); - if (referenceName == null) { - return false; - } - PsiClass containingClass = ClassUtils.getContainingClass(referenceElement); - while (containingClass != null) { - final PsiMethod[] methods = containingClass.findMethodsByName(referenceName, true); - for (final PsiMethod method : methods) { - final String name = method.getName(); - if (referenceName.equals(name)) { - return containingClass.equals(qualifyingClass); - } - } - containingClass = ClassUtils.getContainingClass(containingClass); - } - return false; - } - - static boolean isGenericReference(PsiJavaCodeReferenceElement referenceElement, PsiJavaCodeReferenceElement qualifierElement) { - final PsiReferenceParameterList qualifierParameterList = qualifierElement.getParameterList(); - if (qualifierParameterList != null) { - final PsiTypeElement[] typeParameterElements = qualifierParameterList.getTypeParameterElements(); - if (typeParameterElements.length > 0) { - return true; - } - } - final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); - if (parameterList != null) { - final PsiTypeElement[] typeParameterElements = parameterList.getTypeParameterElements(); - if (typeParameterElements.length > 0) { - return true; - } + static boolean isGenericReference(PsiJavaCodeReferenceElement referenceElement, PsiJavaCodeReferenceElement qualifierElement) { + final PsiReferenceParameterList qualifierParameterList = qualifierElement.getParameterList(); + if (qualifierParameterList != null) { + final PsiTypeElement[] typeParameterElements = qualifierParameterList.getTypeParameterElements(); + if (typeParameterElements.length > 0) { + return true; + } + } + final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); + if (parameterList != null) { + final PsiTypeElement[] typeParameterElements = parameterList.getTypeParameterElements(); + if (typeParameterElements.length > 0) { + return true; + } + } + return false; } - return false; - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticallyImportedElementInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticallyImportedElementInspection.java index 1f3f4926a..d35421273 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticallyImportedElementInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarilyQualifiedStaticallyImportedElementInspection.java @@ -28,121 +28,119 @@ 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; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class UnnecessarilyQualifiedStaticallyImportedElementInspection extends BaseInspection { - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - final PsiMember member = (PsiMember)infos[0]; - return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementProblemDescriptor(member.getName()).get(); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarilyQualifiedStaticallyImportedElementFix(); - } - - private static class UnnecessarilyQualifiedStaticallyImportedElementFix extends InspectionGadgetsFix { - @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementDisplayName(); } + @Nonnull @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - element.delete(); + protected String buildErrorString(Object... infos) { + final PsiMember member = (PsiMember) infos[0]; + return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementProblemDescriptor(member.getName()).get(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarilyQualifiedStaticallyImportedElementVisitor(); - } + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarilyQualifiedStaticallyImportedElementFix(); + } - private static class UnnecessarilyQualifiedStaticallyImportedElementVisitor extends BaseInspectionVisitor { + private static class UnnecessarilyQualifiedStaticallyImportedElementFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessarilyQualifiedStaticallyImportedElementQuickfix(); + } - @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { - visitReferenceElement(expression); + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) + throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + element.delete(); + } } @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - final PsiElement qualifier = reference.getQualifier(); - if (!(qualifier instanceof PsiJavaCodeReferenceElement)) { - return; - } - if (PsiTreeUtil.getParentOfType(reference, PsiReferenceExpression.class, PsiImportStatementBase.class) != null) { - return; - } - if (UnnecessarilyQualifiedStaticUsageInspection.isGenericReference(reference, (PsiJavaCodeReferenceElement)qualifier)) return; - final PsiElement target = reference.resolve(); - if (!(target instanceof PsiMember)) { - return; - } - final PsiMember member = (PsiMember)target; - final PsiJavaCodeReferenceElement referenceExpression = (PsiJavaCodeReferenceElement)qualifier; - final PsiElement qualifierTarget = referenceExpression.resolve(); - if (!(qualifierTarget instanceof PsiClass)) { - return; - } - if (!ImportUtils.isStaticallyImported(member, reference)) { - return; - } - if (!isReferenceCorrectWithoutQualifier(reference, member)) { - return; - } - registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, member); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarilyQualifiedStaticallyImportedElementVisitor(); } - private static boolean isReferenceCorrectWithoutQualifier( - PsiJavaCodeReferenceElement reference, PsiMember member) { - final String referenceName = reference.getReferenceName(); - if (referenceName == null) { - return false; - } - final Project project = reference.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiResolveHelper resolveHelper = psiFacade.getResolveHelper(); - if (member instanceof PsiMethod) { - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiExpression expression = factory.createExpressionFromText(referenceName + "()", reference); - final CandidateInfo[] methodCandidates = resolveHelper.getReferencedMethodCandidates((PsiCallExpression)expression, false); - for (CandidateInfo methodCandidate : methodCandidates) { - if (!(methodCandidate.getCurrentFileResolveScope() instanceof PsiImportStaticStatement)) { - return false; - } + private static class UnnecessarilyQualifiedStaticallyImportedElementVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + visitReferenceElement(expression); } - } - else if (member instanceof PsiField) { - final PsiVariable variable = resolveHelper.resolveAccessibleReferencedVariable(referenceName, reference); - if (!member.equals(variable)) { - return false; + + @Override + public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + super.visitReferenceElement(reference); + final PsiElement qualifier = reference.getQualifier(); + if (!(qualifier instanceof PsiJavaCodeReferenceElement)) { + return; + } + if (PsiTreeUtil.getParentOfType(reference, PsiReferenceExpression.class, PsiImportStatementBase.class) != null) { + return; + } + if (UnnecessarilyQualifiedStaticUsageInspection.isGenericReference(reference, (PsiJavaCodeReferenceElement) qualifier)) { + return; + } + final PsiElement target = reference.resolve(); + if (!(target instanceof PsiMember)) { + return; + } + final PsiMember member = (PsiMember) target; + final PsiJavaCodeReferenceElement referenceExpression = (PsiJavaCodeReferenceElement) qualifier; + final PsiElement qualifierTarget = referenceExpression.resolve(); + if (!(qualifierTarget instanceof PsiClass)) { + return; + } + if (!ImportUtils.isStaticallyImported(member, reference)) { + return; + } + if (!isReferenceCorrectWithoutQualifier(reference, member)) { + return; + } + registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL, member); } - } - else if (member instanceof PsiClass) { - final PsiClass aClass = resolveHelper.resolveReferencedClass(referenceName, reference); - if (!member.equals(aClass)) { - return false; + + private static boolean isReferenceCorrectWithoutQualifier(PsiJavaCodeReferenceElement reference, PsiMember member) { + final String referenceName = reference.getReferenceName(); + if (referenceName == null) { + return false; + } + final Project project = reference.getProject(); + final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + final PsiResolveHelper resolveHelper = psiFacade.getResolveHelper(); + if (member instanceof PsiMethod) { + final PsiElementFactory factory = psiFacade.getElementFactory(); + final PsiExpression expression = factory.createExpressionFromText(referenceName + "()", reference); + final CandidateInfo[] methodCandidates = resolveHelper.getReferencedMethodCandidates((PsiCallExpression) expression, false); + for (CandidateInfo methodCandidate : methodCandidates) { + if (!(methodCandidate.getCurrentFileResolveScope() instanceof PsiImportStaticStatement)) { + return false; + } + } + } + else if (member instanceof PsiField) { + final PsiVariable variable = resolveHelper.resolveAccessibleReferencedVariable(referenceName, reference); + if (!member.equals(variable)) { + return false; + } + } + else if (member instanceof PsiClass) { + final PsiClass aClass = resolveHelper.resolveReferencedClass(referenceName, reference); + if (!member.equals(aClass)) { + return false; + } + } + return true; } - } - return true; } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryBlockStatementInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryBlockStatementInspection.java index 6bc715b28..818691063 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryBlockStatementInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryBlockStatementInspection.java @@ -39,107 +39,97 @@ @ExtensionImpl public class UnnecessaryBlockStatementInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean ignoreSwitchBranches = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreSwitchBranches = false; - - @Override - @Nonnull - public String getID() { - return "UnnecessaryCodeBlock"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryCodeBlockDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryBlockStatementProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.ignoreBranchesOfSwitchStatements(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreSwitchBranches"); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryBlockStatementVisitor(); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryBlockFix(); - } + @Override + @Nonnull + public String getID() { + return "UnnecessaryCodeBlock"; + } - private static class UnnecessaryBlockFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryCodeBlockDisplayName(); + } + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryCodeBlockUnwrapQuickfix().get(); + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryBlockStatementProblemDescriptor().get(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement leftBrace = descriptor.getPsiElement(); - final PsiElement parent = leftBrace.getParent(); - if (!(parent instanceof PsiCodeBlock)) { - return; - } - final PsiCodeBlock block = (PsiCodeBlock)parent; - final PsiBlockStatement blockStatement = - (PsiBlockStatement)block.getParent(); - final PsiElement[] children = block.getChildren(); - if (children.length > 2) { - final PsiElement element = blockStatement.getParent(); - element.addRangeBefore(children[1], - children[children.length - 2], blockStatement); - } - blockStatement.delete(); + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.ignoreBranchesOfSwitchStatements(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreSwitchBranches"); } - } - private class UnnecessaryBlockStatementVisitor - extends BaseInspectionVisitor { + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryBlockStatementVisitor(); + } @Override - public void visitBlockStatement( - PsiBlockStatement blockStatement) { - super.visitBlockStatement(blockStatement); - if (ignoreSwitchBranches) { - final PsiElement prevStatement = - PsiTreeUtil.skipSiblingsBackward(blockStatement, - PsiWhiteSpace.class); - if (prevStatement instanceof PsiSwitchLabelStatement) { - return; + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryBlockFix(); + } + + private static class UnnecessaryBlockFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryCodeBlockUnwrapQuickfix(); + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement leftBrace = descriptor.getPsiElement(); + final PsiElement parent = leftBrace.getParent(); + if (!(parent instanceof PsiCodeBlock)) { + return; + } + final PsiCodeBlock block = (PsiCodeBlock) parent; + final PsiBlockStatement blockStatement = (PsiBlockStatement) block.getParent(); + final PsiElement[] children = block.getChildren(); + if (children.length > 2) { + final PsiElement element = blockStatement.getParent(); + element.addRangeBefore(children[1], children[children.length - 2], blockStatement); + } + blockStatement.delete(); + } + } + + private class UnnecessaryBlockStatementVisitor extends BaseInspectionVisitor { + @Override + public void visitBlockStatement(PsiBlockStatement blockStatement) { + super.visitBlockStatement(blockStatement); + if (ignoreSwitchBranches) { + final PsiElement prevStatement = PsiTreeUtil.skipSiblingsBackward(blockStatement, PsiWhiteSpace.class); + if (prevStatement instanceof PsiSwitchLabelStatement) { + return; + } + } + final PsiElement parent = blockStatement.getParent(); + if (!(parent instanceof PsiCodeBlock)) { + return; + } + final PsiCodeBlock codeBlock = blockStatement.getCodeBlock(); + final PsiJavaToken brace = codeBlock.getLBrace(); + if (brace == null) { + return; + } + final PsiCodeBlock parentBlock = (PsiCodeBlock) parent; + if (parentBlock.getStatements().length > 1 && + VariableSearchUtils.containsConflictingDeclarations(codeBlock, parentBlock)) { + return; + } + registerError(brace); + final PsiJavaToken rbrace = codeBlock.getRBrace(); + if (rbrace != null) { + registerError(rbrace); + } } - } - final PsiElement parent = blockStatement.getParent(); - if (!(parent instanceof PsiCodeBlock)) { - return; - } - final PsiCodeBlock codeBlock = blockStatement.getCodeBlock(); - final PsiJavaToken brace = codeBlock.getLBrace(); - if (brace == null) { - return; - } - final PsiCodeBlock parentBlock = (PsiCodeBlock)parent; - if (parentBlock.getStatements().length > 1 && - VariableSearchUtils.containsConflictingDeclarations( - codeBlock, parentBlock)) { - return; - } - registerError(brace); - final PsiJavaToken rbrace = codeBlock.getRBrace(); - if (rbrace != null) { - registerError(rbrace); - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryCallToStringValueOfInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryCallToStringValueOfInspection.java index cb3e2bca9..457507ad1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryCallToStringValueOfInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryCallToStringValueOfInspection.java @@ -26,198 +26,213 @@ 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 jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class UnnecessaryCallToStringValueOfInspection extends BaseInspection { - - @Override - @Nls - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryCallToStringValueofDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - final String text = (String)infos[0]; - return InspectionGadgetsLocalize.unnecessaryCallToStringValueofProblemDescriptor(text).get(); - } - - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - final String text = (String)infos[0]; - return new UnnecessaryCallToStringValueOfFix(text); - } - - public static String calculateReplacementText(PsiExpression expression) { - if (!(expression instanceof PsiPolyadicExpression)) { - return expression.getText(); - } - final PsiType type = expression.getType(); - if (TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type) || - ParenthesesUtils.getPrecedence(expression) < ParenthesesUtils.ADDITIVE_PRECEDENCE) { - return expression.getText(); - } - return '(' + expression.getText() + ')'; - } - - private static class UnnecessaryCallToStringValueOfFix extends InspectionGadgetsFix { - - private final String replacementText; - - UnnecessaryCallToStringValueOfFix(String replacementText) { - this.replacementText = replacementText; + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryCallToStringValueofDisplayName(); } + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryCallToStringValueofQuickfix(replacementText).get(); + protected String buildErrorString(Object... infos) { + final String text = (String) infos[0]; + return InspectionGadgetsLocalize.unnecessaryCallToStringValueofProblemDescriptor(text).get(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)descriptor.getPsiElement(); - final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length != 1) { - return; - } - replaceExpression(methodCallExpression, calculateReplacementText(arguments[0])); + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + final String text = (String) infos[0]; + return new UnnecessaryCallToStringValueOfFix(text); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryCallToStringValueOfVisitor(); - } - private static class UnnecessaryCallToStringValueOfVisitor extends BaseInspectionVisitor { - - @Override - public void visitMethodCallExpression(PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final String referenceName = methodExpression.getReferenceName(); - if (!"valueOf".equals(referenceName)) { - return; - } - if (isCallToStringValueOfNecessary(expression)) { - return; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length != 1) { - return; - } - final PsiExpression argument = arguments[0]; - final PsiType argumentType = argument.getType(); - if (argumentType instanceof PsiArrayType) { - final PsiArrayType arrayType = (PsiArrayType)argumentType; - final PsiType componentType = arrayType.getComponentType(); - if (PsiType.CHAR.equals(componentType)) { - return; + public static String calculateReplacementText(PsiExpression expression) { + if (!(expression instanceof PsiPolyadicExpression)) { + return expression.getText(); + } + final PsiType type = expression.getType(); + if (TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type) || + ParenthesesUtils.getPrecedence(expression) < ParenthesesUtils.ADDITIVE_PRECEDENCE) { + return expression.getText(); } - } - final PsiMethod method = expression.resolveMethod(); - if (method == null) { - return; - } - final PsiClass aClass = method.getContainingClass(); - if (aClass == null) { - return; - } - final String qualifiedName = aClass.getQualifiedName(); - if (!CommonClassNames.JAVA_LANG_STRING.equals(qualifiedName)) { - return; - } - registerError(expression, calculateReplacementText(argument)); + return '(' + expression.getText() + ')'; } - private boolean isCallToStringValueOfNecessary(PsiMethodCallExpression expression) { - final PsiElement parent = ParenthesesUtils.getParentSkipParentheses(expression); - if (parent instanceof PsiPolyadicExpression) { - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)parent; - final PsiType type = polyadicExpression.getType(); - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type)) { - return true; + private static class UnnecessaryCallToStringValueOfFix extends InspectionGadgetsFix { + private final String replacementText; + + UnnecessaryCallToStringValueOfFix(String replacementText) { + this.replacementText = replacementText; } - final PsiExpression[] operands = polyadicExpression.getOperands(); - int index = -1; - for (int i = 0, length = operands.length; i < length; i++) { - final PsiExpression operand = operands[i]; - if (expression.equals(operand)) { - index = i; - } + + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryCallToStringValueofQuickfix(replacementText); } - if (index > 0) { - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index - 1].getType())) { - return true; - } - } else if (operands.length > 1) { - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index + 1].getType())) { - return true; - } - } else { - return true; + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) descriptor.getPsiElement(); + final PsiExpressionList argumentList = methodCallExpression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 1) { + return; + } + replaceExpression(methodCallExpression, calculateReplacementText(arguments[0])); } - } else if (parent instanceof PsiExpressionList) { - final PsiExpressionList expressionList = (PsiExpressionList)parent; - final PsiElement grandParent = expressionList.getParent(); - if (!(grandParent instanceof PsiMethodCallExpression)) { - return true; + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryCallToStringValueOfVisitor(); + } + + private static class UnnecessaryCallToStringValueOfVisitor extends BaseInspectionVisitor { + @Override + public void visitMethodCallExpression(PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final String referenceName = methodExpression.getReferenceName(); + if (!"valueOf".equals(referenceName)) { + return; + } + if (isCallToStringValueOfNecessary(expression)) { + return; + } + final PsiExpressionList argumentList = expression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 1) { + return; + } + final PsiExpression argument = arguments[0]; + final PsiType argumentType = argument.getType(); + if (argumentType instanceof PsiArrayType) { + final PsiArrayType arrayType = (PsiArrayType) argumentType; + final PsiType componentType = arrayType.getComponentType(); + if (PsiType.CHAR.equals(componentType)) { + return; + } + } + final PsiMethod method = expression.resolveMethod(); + if (method == null) { + return; + } + final PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + return; + } + final String qualifiedName = aClass.getQualifiedName(); + if (!CommonClassNames.JAVA_LANG_STRING.equals(qualifiedName)) { + return; + } + registerError(expression, calculateReplacementText(argument)); } - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)grandParent; - final PsiReferenceExpression methodExpression1 = methodCallExpression.getMethodExpression(); - final String name = methodExpression1.getReferenceName(); - final PsiExpression[] expressions = expressionList.getExpressions(); - if ("insert".equals(name)) { - if (expressions.length < 2 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[1]))) { - return true; - } - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_LANG_STRING_BUILDER, CommonClassNames.JAVA_LANG_STRING_BUFFER)) { - return true; - } - } else if ("append".equals(name)) { - if (expressions.length < 1 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[0]))) { - return true; - } - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_LANG_STRING_BUILDER, CommonClassNames.JAVA_LANG_STRING_BUFFER)) { - return true; - } - } else if ("print".equals(name) || "println".equals(name)) { - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_IO_PRINT_STREAM, CommonClassNames.JAVA_IO_PRINT_WRITER)) { - return true; - } + private boolean isCallToStringValueOfNecessary(PsiMethodCallExpression expression) { + final PsiElement parent = ParenthesesUtils.getParentSkipParentheses(expression); + if (parent instanceof PsiPolyadicExpression) { + final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) parent; + final PsiType type = polyadicExpression.getType(); + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type)) { + return true; + } + final PsiExpression[] operands = polyadicExpression.getOperands(); + int index = -1; + for (int i = 0, length = operands.length; i < length; i++) { + final PsiExpression operand = operands[i]; + if (expression.equals(operand)) { + index = i; + } + } + if (index > 0) { + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index - 1].getType())) { + return true; + } + } + else if (operands.length > 1) { + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index + 1].getType())) { + return true; + } + } + else { + return true; + } + } + else if (parent instanceof PsiExpressionList) { + final PsiExpressionList expressionList = (PsiExpressionList) parent; + final PsiElement grandParent = expressionList.getParent(); + if (!(grandParent instanceof PsiMethodCallExpression)) { + return true; + } + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent; + final PsiReferenceExpression methodExpression1 = methodCallExpression.getMethodExpression(); + final String name = methodExpression1.getReferenceName(); + final PsiExpression[] expressions = expressionList.getExpressions(); + if ("insert".equals(name)) { + if (expressions.length < 2 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[1]))) { + return true; + } + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_LANG_STRING_BUILDER, + CommonClassNames.JAVA_LANG_STRING_BUFFER + )) { + return true; + } + + } + else if ("append".equals(name)) { + if (expressions.length < 1 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[0]))) { + return true; + } + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_LANG_STRING_BUILDER, + CommonClassNames.JAVA_LANG_STRING_BUFFER + )) { + return true; + } + } + else if ("print".equals(name) || "println".equals(name)) { + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_IO_PRINT_STREAM, + CommonClassNames.JAVA_IO_PRINT_WRITER + )) { + return true; + } + } + } + else { + return true; + } + return false; } - } else { - return true; - } - return false; - } - private boolean isCallToMethodIn(PsiMethodCallExpression methodCallExpression, String... classNames) { - final PsiMethod method = methodCallExpression.resolveMethod(); - if (method == null) { - return false; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return false; - } - final String qualifiedName = containingClass.getQualifiedName(); - for (String className : classNames) { - if (className.equals(qualifiedName)) { - return true; + private boolean isCallToMethodIn(PsiMethodCallExpression methodCallExpression, String... classNames) { + final PsiMethod method = methodCallExpression.resolveMethod(); + if (method == null) { + return false; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return false; + } + final String qualifiedName = containingClass.getQualifiedName(); + for (String className : classNames) { + if (className.equals(qualifiedName)) { + return true; + } + } + return false; } - } - return false; } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryConstructorInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryConstructorInspection.java index 4a16004a0..883382fcb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryConstructorInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryConstructorInspection.java @@ -15,139 +15,133 @@ */ package com.intellij.java.impl.ig.style; +import com.intellij.java.language.psi.*; +import com.siyeh.ig.BaseInspection; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.language.editor.inspection.ProblemDescriptor; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; -import com.intellij.java.language.psi.*; +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.language.psi.*; -import consulo.language.util.IncorrectOperationException; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.InspectionGadgetsFix; -import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; -import javax.swing.JComponent; +import javax.swing.*; @ExtensionImpl public class UnnecessaryConstructorInspection extends BaseInspection { + private static final String SUPER_CALL_TEXT = PsiKeyword.SUPER + "();"; - @NonNls - private static final String SUPER_CALL_TEXT = PsiKeyword.SUPER + "();"; - - @SuppressWarnings("PublicField") - public boolean ignoreAnnotations = false; - - @Override - @Nonnull - public String getID() { - return "RedundantNoArgConstructor"; - } - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryConstructorDisplayName().get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.unnecessaryConstructorAnnotationOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreAnnotations"); - } + @SuppressWarnings("PublicField") + public boolean ignoreAnnotations = false; - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryConstructorProblemDescriptor().get(); - } + @Override + @Nonnull + public String getID() { + return "RedundantNoArgConstructor"; + } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryConstructorVisitor(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryConstructorDisplayName(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryConstructorFix(); - } + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.unnecessaryConstructorAnnotationOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreAnnotations"); + } - private static class UnnecessaryConstructorFix extends InspectionGadgetsFix { + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryConstructorRemoveQuickfix().get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryConstructorProblemDescriptor().get(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement nameIdentifier = descriptor.getPsiElement(); - final PsiElement constructor = nameIdentifier.getParent(); - assert constructor != null; - deleteElement(constructor); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryConstructorVisitor(); } - } - private class UnnecessaryConstructorVisitor extends BaseInspectionVisitor { @Override - public void visitClass(@Nonnull PsiClass aClass) { - final PsiMethod[] constructors = aClass.getConstructors(); - if (constructors.length != 1) { - return; - } - final PsiMethod constructor = constructors[0]; - if (!constructor.hasModifierProperty(PsiModifier.PRIVATE) && - aClass.hasModifierProperty(PsiModifier.PRIVATE)) { - return; - } - if (!constructor.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) && - aClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { - return; - } - if (!constructor.hasModifierProperty(PsiModifier.PROTECTED) && - aClass.hasModifierProperty(PsiModifier.PROTECTED)) { - return; - } - if (!constructor.hasModifierProperty(PsiModifier.PUBLIC) && - aClass.hasModifierProperty(PsiModifier.PUBLIC)) { - return; - } - final PsiParameterList parameterList = - constructor.getParameterList(); - if (parameterList.getParametersCount() != 0) { - return; - } - if (ignoreAnnotations) { - final PsiModifierList modifierList = - constructor.getModifierList(); - final PsiAnnotation[] annotations = - modifierList.getAnnotations(); - if (annotations.length > 0) { - return; + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryConstructorFix(); + } + + private static class UnnecessaryConstructorFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryConstructorRemoveQuickfix(); } - } - final PsiReferenceList throwsList = constructor.getThrowsList(); - final PsiJavaCodeReferenceElement[] elements = - throwsList.getReferenceElements(); - if (elements.length != 0) { - return; - } - final PsiCodeBlock body = constructor.getBody(); - if (body == null) { - return; - } - final PsiStatement[] statements = body.getStatements(); - if (statements.length == 0) { - registerMethodError(constructor); - } - else if (statements.length == 1) { - final PsiStatement statement = statements[0]; - if (SUPER_CALL_TEXT.equals(statement.getText())) { - registerMethodError(constructor); + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement nameIdentifier = descriptor.getPsiElement(); + final PsiElement constructor = nameIdentifier.getParent(); + assert constructor != null; + deleteElement(constructor); + } + } + + private class UnnecessaryConstructorVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + final PsiMethod[] constructors = aClass.getConstructors(); + if (constructors.length != 1) { + return; + } + final PsiMethod constructor = constructors[0]; + if (!constructor.hasModifierProperty(PsiModifier.PRIVATE) && + aClass.hasModifierProperty(PsiModifier.PRIVATE)) { + return; + } + if (!constructor.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) && + aClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { + return; + } + if (!constructor.hasModifierProperty(PsiModifier.PROTECTED) && + aClass.hasModifierProperty(PsiModifier.PROTECTED)) { + return; + } + if (!constructor.hasModifierProperty(PsiModifier.PUBLIC) && + aClass.hasModifierProperty(PsiModifier.PUBLIC)) { + return; + } + final PsiParameterList parameterList = constructor.getParameterList(); + if (parameterList.getParametersCount() != 0) { + return; + } + if (ignoreAnnotations) { + final PsiModifierList modifierList = constructor.getModifierList(); + final PsiAnnotation[] annotations = modifierList.getAnnotations(); + if (annotations.length > 0) { + return; + } + } + final PsiReferenceList throwsList = constructor.getThrowsList(); + final PsiJavaCodeReferenceElement[] elements = throwsList.getReferenceElements(); + if (elements.length != 0) { + return; + } + final PsiCodeBlock body = constructor.getBody(); + if (body == null) { + return; + } + final PsiStatement[] statements = body.getStatements(); + if (statements.length == 0) { + registerMethodError(constructor); + } + else if (statements.length == 1) { + final PsiStatement statement = statements[0]; + if (SUPER_CALL_TEXT.equals(statement.getText())) { + registerMethodError(constructor); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryEnumModifierInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryEnumModifierInspection.java index 0e0bcc949..3a5231e2f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryEnumModifierInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryEnumModifierInspection.java @@ -28,108 +28,106 @@ 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 UnnecessaryEnumModifierInspection extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryEnumModifierDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiElement parent = (PsiElement)infos[1]; - return parent instanceof PsiMethod - ? InspectionGadgetsLocalize.unnecessaryEnumModifierProblemDescriptor().get() - : InspectionGadgetsLocalize.unnecessaryEnumModifierProblemDescriptor1().get(); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryEnumModifierVisitor(); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryEnumModifierFix((PsiElement)infos[0]); - } - - private static class UnnecessaryEnumModifierFix extends InspectionGadgetsFix { - - private final String m_name; - - private UnnecessaryEnumModifierFix(PsiElement modifier) { - m_name = InspectionGadgetsLocalize.smthUnnecessaryRemoveQuickfix(modifier.getText()).get(); + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryEnumModifierDisplayName(); } @Override @Nonnull - public String getName() { - return m_name; + public String buildErrorString(Object... infos) { + final PsiElement parent = (PsiElement) infos[1]; + return parent instanceof PsiMethod + ? InspectionGadgetsLocalize.unnecessaryEnumModifierProblemDescriptor().get() + : InspectionGadgetsLocalize.unnecessaryEnumModifierProblemDescriptor1().get(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final PsiModifierList modifierList; - if (element instanceof PsiModifierList) { - modifierList = (PsiModifierList)element; - } - else { - modifierList = (PsiModifierList)element.getParent(); - } - assert modifierList != null; - if (modifierList.getParent() instanceof PsiClass) { - modifierList.setModifierProperty(PsiModifier.STATIC, false); - } - else { - modifierList.setModifierProperty(PsiModifier.PRIVATE, false); - } + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryEnumModifierVisitor(); } - } - - private static class UnnecessaryEnumModifierVisitor extends BaseInspectionVisitor { @Override - public void visitClass(@Nonnull PsiClass aClass) { - if (!aClass.isEnum() || !ClassUtils.isInnerClass(aClass) || !aClass.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - final PsiModifierList modifiers = aClass.getModifierList(); - if (modifiers == null) { - return; - } - final PsiElement[] children = modifiers.getChildren(); - for (final PsiElement child : children) { - final String text = child.getText(); - if (PsiModifier.STATIC.equals(text)) { - registerError(child, child, aClass); + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryEnumModifierFix((PsiElement) infos[0]); + } + + private static class UnnecessaryEnumModifierFix extends InspectionGadgetsFix { + private final LocalizeValue myName; + + private UnnecessaryEnumModifierFix(PsiElement modifier) { + myName = InspectionGadgetsLocalize.smthUnnecessaryRemoveQuickfix(modifier.getText()); + } + + @Nonnull + @Override + public LocalizeValue getName() { + return myName; + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + final PsiModifierList modifierList; + if (element instanceof PsiModifierList) { + modifierList = (PsiModifierList) element; + } + else { + modifierList = (PsiModifierList) element.getParent(); + } + assert modifierList != null; + if (modifierList.getParent() instanceof PsiClass) { + modifierList.setModifierProperty(PsiModifier.STATIC, false); + } + else { + modifierList.setModifierProperty(PsiModifier.PRIVATE, false); + } } - } } - @Override - public void visitMethod(@Nonnull PsiMethod method) { - if (!method.isConstructor() || !method.hasModifierProperty(PsiModifier.PRIVATE)) { - return; - } - final PsiClass aClass = method.getContainingClass(); - if (aClass == null || !aClass.isEnum()) { - return; - } - final PsiModifierList modifiers = method.getModifierList(); - final PsiElement[] children = modifiers.getChildren(); - for (final PsiElement child : children) { - final String text = child.getText(); - if (PsiModifier.PRIVATE.equals(text)) { - registerError(child, child, method); + private static class UnnecessaryEnumModifierVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + if (!aClass.isEnum() || !ClassUtils.isInnerClass(aClass) || !aClass.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + final PsiModifierList modifiers = aClass.getModifierList(); + if (modifiers == null) { + return; + } + final PsiElement[] children = modifiers.getChildren(); + for (final PsiElement child : children) { + final String text = child.getText(); + if (PsiModifier.STATIC.equals(text)) { + registerError(child, child, aClass); + } + } + } + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + if (!method.isConstructor() || !method.hasModifierProperty(PsiModifier.PRIVATE)) { + return; + } + final PsiClass aClass = method.getContainingClass(); + if (aClass == null || !aClass.isEnum()) { + return; + } + final PsiModifierList modifiers = method.getModifierList(); + final PsiElement[] children = modifiers.getChildren(); + for (final PsiElement child : children) { + final String text = child.getText(); + if (PsiModifier.PRIVATE.equals(text)) { + registerError(child, child, method); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryFinalOnLocalVariableOrParameterInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryFinalOnLocalVariableOrParameterInspection.java index 265dffb17..35b9860f1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryFinalOnLocalVariableOrParameterInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryFinalOnLocalVariableOrParameterInspection.java @@ -25,6 +25,7 @@ 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 jakarta.annotation.Nullable; @@ -34,238 +35,212 @@ import java.awt.*; @ExtensionImpl -public class UnnecessaryFinalOnLocalVariableOrParameterInspection - extends BaseInspection { +public class UnnecessaryFinalOnLocalVariableOrParameterInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean onlyWarnOnAbstractMethods = false; - @SuppressWarnings({"PublicField"}) - public boolean onlyWarnOnAbstractMethods = false; + @SuppressWarnings("PublicField") + public boolean reportLocalVariables = true; - @SuppressWarnings("PublicField") - public boolean reportLocalVariables = true; + @SuppressWarnings("PublicField") + public boolean reportParameters = true; - @SuppressWarnings("PublicField") - public boolean reportParameters = true; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryFinalOnLocalVariableOrParameterDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiVariable variable = (PsiVariable)infos[0]; - final String variableName = variable.getName(); - return variable instanceof PsiParameter - ? InspectionGadgetsLocalize.unnecessaryFinalOnParameterProblemDescriptor(variableName).get() - : InspectionGadgetsLocalize.unnecessaryFinalOnLocalVariableProblemDescriptor(variableName).get(); - } - - @Override - @Nullable - public JComponent createOptionsPanel() { - final JPanel panel = new JPanel(new GridBagLayout()); - final JCheckBox abstractOnlyCheckBox = - new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalOnParameterOnlyInterfaceOption().get(), onlyWarnOnAbstractMethods) { - @Override - public void setEnabled(boolean b) { - // hack to display correctly on initial opening of - // inspection settings (otherwise it is always enabled) - if (b) { - super.setEnabled(reportParameters); - } - else { - super.setEnabled(false); - } - } - }; - abstractOnlyCheckBox.setEnabled(true); - abstractOnlyCheckBox.addChangeListener(new ChangeListener() { - @Override - public void stateChanged(ChangeEvent e) { - onlyWarnOnAbstractMethods = abstractOnlyCheckBox.isSelected(); - } - }); - final JCheckBox reportLocalVariablesCheckBox = - new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalReportLocalVariablesOption().get(), reportLocalVariables); - final JCheckBox reportParametersCheckBox = - new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalReportParametersOption().get(), reportParameters); - - reportLocalVariablesCheckBox.addChangeListener(new ChangeListener() { - @Override - public void stateChanged(ChangeEvent e) { - reportLocalVariables = - reportLocalVariablesCheckBox.isSelected(); - if (!reportLocalVariables) { - reportParametersCheckBox.setSelected(true); - } - } - }); - reportParametersCheckBox.addChangeListener(new ChangeListener() { - @Override - public void stateChanged(ChangeEvent e) { - reportParameters = - reportParametersCheckBox.isSelected(); - if (!reportParameters) { - reportLocalVariablesCheckBox.setSelected(true); - } - abstractOnlyCheckBox.setEnabled(reportParameters); - } - }); - final GridBagConstraints constraints = new GridBagConstraints(); - constraints.anchor = GridBagConstraints.NORTHWEST; - constraints.fill = GridBagConstraints.HORIZONTAL; - constraints.weightx = 1.0; - panel.add(reportLocalVariablesCheckBox, constraints); - constraints.gridy = 1; - panel.add(reportParametersCheckBox, constraints); - constraints.insets.left = 20; - constraints.gridy = 2; - constraints.weighty = 1.0; - panel.add(abstractOnlyCheckBox, constraints); - return panel; - } - - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryFinalOnLocalVariableOrParameterVisitor(); - } + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryFinalOnLocalVariableOrParameterDisplayName(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new RemoveModifierFix((String)infos[1]); - } + @Override + @Nonnull + public String buildErrorString(Object... infos) { + final PsiVariable variable = (PsiVariable) infos[0]; + final String variableName = variable.getName(); + return variable instanceof PsiParameter + ? InspectionGadgetsLocalize.unnecessaryFinalOnParameterProblemDescriptor(variableName).get() + : InspectionGadgetsLocalize.unnecessaryFinalOnLocalVariableProblemDescriptor(variableName).get(); + } - private class UnnecessaryFinalOnLocalVariableOrParameterVisitor - extends BaseInspectionVisitor { + @Override + @Nullable + public JComponent createOptionsPanel() { + final JPanel panel = new JPanel(new GridBagLayout()); + final JCheckBox abstractOnlyCheckBox = + new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalOnParameterOnlyInterfaceOption().get(), onlyWarnOnAbstractMethods) { + @Override + public void setEnabled(boolean b) { + // hack to display correctly on initial opening of + // inspection settings (otherwise it is always enabled) + if (b) { + super.setEnabled(reportParameters); + } + else { + super.setEnabled(false); + } + } + }; + abstractOnlyCheckBox.setEnabled(true); + abstractOnlyCheckBox.addChangeListener(new ChangeListener() { + @Override + public void stateChanged(ChangeEvent e) { + onlyWarnOnAbstractMethods = abstractOnlyCheckBox.isSelected(); + } + }); + final JCheckBox reportLocalVariablesCheckBox = + new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalReportLocalVariablesOption().get(), reportLocalVariables); + final JCheckBox reportParametersCheckBox = + new JCheckBox(InspectionGadgetsLocalize.unnecessaryFinalReportParametersOption().get(), reportParameters); + + reportLocalVariablesCheckBox.addChangeListener(new ChangeListener() { + @Override + public void stateChanged(ChangeEvent e) { + reportLocalVariables = reportLocalVariablesCheckBox.isSelected(); + if (!reportLocalVariables) { + reportParametersCheckBox.setSelected(true); + } + } + }); + reportParametersCheckBox.addChangeListener(new ChangeListener() { + @Override + public void stateChanged(ChangeEvent e) { + reportParameters = reportParametersCheckBox.isSelected(); + if (!reportParameters) { + reportLocalVariablesCheckBox.setSelected(true); + } + abstractOnlyCheckBox.setEnabled(reportParameters); + } + }); + final GridBagConstraints constraints = new GridBagConstraints(); + constraints.anchor = GridBagConstraints.NORTHWEST; + constraints.fill = GridBagConstraints.HORIZONTAL; + constraints.weightx = 1.0; + panel.add(reportLocalVariablesCheckBox, constraints); + constraints.gridy = 1; + panel.add(reportParametersCheckBox, constraints); + constraints.insets.left = 20; + constraints.gridy = 2; + constraints.weighty = 1.0; + panel.add(abstractOnlyCheckBox, constraints); + return panel; + } @Override - public void visitDeclarationStatement( - PsiDeclarationStatement statement) { - super.visitDeclarationStatement(statement); - if (!reportLocalVariables) { - return; - } - final PsiElement[] declaredElements = - statement.getDeclaredElements(); - if (declaredElements.length == 0) { - return; - } - for (final PsiElement declaredElement : declaredElements) { - if (!(declaredElement instanceof PsiLocalVariable)) { - return; - } - final PsiLocalVariable variable = - (PsiLocalVariable)declaredElement; - if (!variable.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - } - final PsiCodeBlock containingBlock = - PsiTreeUtil.getParentOfType(statement, PsiCodeBlock.class); - if (containingBlock == null) { - return; - } - for (PsiElement declaredElement : declaredElements) { - final PsiLocalVariable variable = - (PsiLocalVariable)declaredElement; - if (VariableAccessUtils.variableIsUsedInInnerClass(variable, - containingBlock)) { - return; - } - } - final PsiLocalVariable variable = - (PsiLocalVariable)statement.getDeclaredElements()[0]; - registerModifierError(PsiModifier.FINAL, variable, variable, - PsiModifier.FINAL); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryFinalOnLocalVariableOrParameterVisitor(); } @Override - public void visitMethod(PsiMethod method) { - super.visitMethod(method); - if (!reportParameters) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - for (final PsiParameter parameter : parameters) { - checkParameter(method, parameter); - } + public InspectionGadgetsFix buildFix(Object... infos) { + return new RemoveModifierFix((String) infos[1]); } - private void checkParameter(PsiMethod method, PsiParameter parameter) { - if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass != null) { - if (containingClass.isInterface() || - containingClass.isAnnotationType()) { - registerModifierError(PsiModifier.FINAL, parameter, - parameter, PsiModifier.FINAL); - return; + private class UnnecessaryFinalOnLocalVariableOrParameterVisitor extends BaseInspectionVisitor { + @Override + public void visitDeclarationStatement(PsiDeclarationStatement statement) { + super.visitDeclarationStatement(statement); + if (!reportLocalVariables) { + return; + } + final PsiElement[] declaredElements = statement.getDeclaredElements(); + if (declaredElements.length == 0) { + return; + } + for (final PsiElement declaredElement : declaredElements) { + if (!(declaredElement instanceof PsiLocalVariable)) { + return; + } + final PsiLocalVariable variable = (PsiLocalVariable) declaredElement; + if (!variable.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + } + final PsiCodeBlock containingBlock = PsiTreeUtil.getParentOfType(statement, PsiCodeBlock.class); + if (containingBlock == null) { + return; + } + for (PsiElement declaredElement : declaredElements) { + final PsiLocalVariable variable = (PsiLocalVariable) declaredElement; + if (VariableAccessUtils.variableIsUsedInInnerClass(variable, containingBlock)) { + return; + } + } + final PsiLocalVariable variable = (PsiLocalVariable) statement.getDeclaredElements()[0]; + registerModifierError(PsiModifier.FINAL, variable, variable, PsiModifier.FINAL); } - } - if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { - registerModifierError(PsiModifier.FINAL, parameter, - parameter, PsiModifier.FINAL); - return; - } - if (onlyWarnOnAbstractMethods) { - return; - } - if (VariableAccessUtils.variableIsUsedInInnerClass(parameter, - method)) { - return; - } - registerModifierError(PsiModifier.FINAL, parameter, - parameter, PsiModifier.FINAL); - } - @Override - public void visitTryStatement(PsiTryStatement statement) { - super.visitTryStatement(statement); - if (onlyWarnOnAbstractMethods || !reportParameters) { - return; - } - final PsiCatchSection[] catchSections = - statement.getCatchSections(); - for (PsiCatchSection catchSection : catchSections) { - final PsiParameter parameter = catchSection.getParameter(); - final PsiCodeBlock catchBlock = catchSection.getCatchBlock(); - if (parameter == null || catchBlock == null) { - continue; + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + if (!reportParameters) { + return; + } + final PsiParameterList parameterList = method.getParameterList(); + final PsiParameter[] parameters = parameterList.getParameters(); + for (final PsiParameter parameter : parameters) { + checkParameter(method, parameter); + } } - if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { - continue; + + private void checkParameter(PsiMethod method, PsiParameter parameter) { + if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass != null) { + if (containingClass.isInterface() || containingClass.isAnnotationType()) { + registerModifierError(PsiModifier.FINAL, parameter, parameter, PsiModifier.FINAL); + return; + } + } + if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { + registerModifierError(PsiModifier.FINAL, parameter, parameter, PsiModifier.FINAL); + return; + } + if (onlyWarnOnAbstractMethods) { + return; + } + if (VariableAccessUtils.variableIsUsedInInnerClass(parameter, method)) { + return; + } + registerModifierError(PsiModifier.FINAL, parameter, parameter, PsiModifier.FINAL); } - if (!VariableAccessUtils.variableIsUsedInInnerClass( - parameter, catchBlock)) { - registerModifierError(PsiModifier.FINAL, parameter, - parameter, PsiModifier.FINAL); + + @Override + public void visitTryStatement(PsiTryStatement statement) { + super.visitTryStatement(statement); + if (onlyWarnOnAbstractMethods || !reportParameters) { + return; + } + final PsiCatchSection[] catchSections = statement.getCatchSections(); + for (PsiCatchSection catchSection : catchSections) { + final PsiParameter parameter = catchSection.getParameter(); + final PsiCodeBlock catchBlock = catchSection.getCatchBlock(); + if (parameter == null || catchBlock == null) { + continue; + } + if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { + continue; + } + if (!VariableAccessUtils.variableIsUsedInInnerClass(parameter, catchBlock)) { + registerModifierError(PsiModifier.FINAL, parameter, parameter, PsiModifier.FINAL); + } + } } - } - } - @Override - public void visitForeachStatement( - PsiForeachStatement statement) { - super.visitForeachStatement(statement); - if (onlyWarnOnAbstractMethods || !reportParameters) { - return; - } - final PsiParameter parameter = statement.getIterationParameter(); - if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { - return; - } - if (VariableAccessUtils.variableIsUsedInInnerClass(parameter, - statement)) { - return; - } - registerModifierError(PsiModifier.FINAL, parameter, - parameter, PsiModifier.FINAL); + @Override + public void visitForeachStatement(PsiForeachStatement statement) { + super.visitForeachStatement(statement); + if (onlyWarnOnAbstractMethods || !reportParameters) { + return; + } + final PsiParameter parameter = statement.getIterationParameter(); + if (!parameter.hasModifierProperty(PsiModifier.FINAL)) { + return; + } + if (VariableAccessUtils.variableIsUsedInInnerClass(parameter, statement)) { + return; + } + registerModifierError(PsiModifier.FINAL, parameter, parameter, PsiModifier.FINAL); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryInterfaceModifierInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryInterfaceModifierInspection.java index 76c6259b4..585591097 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryInterfaceModifierInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryInterfaceModifierInspection.java @@ -24,6 +24,7 @@ import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; @@ -33,179 +34,176 @@ @ExtensionImpl public class UnnecessaryInterfaceModifierInspection extends BaseInspection { - - private static final Set INTERFACE_REDUNDANT_MODIFIERS = - new HashSet(Arrays.asList(PsiModifier.ABSTRACT, PsiModifier.STATIC)); - private static final Set INNER_CLASS_REDUNDANT_MODIFIERS = - new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC)); - private static final Set INNER_INTERFACE_REDUNDANT_MODIFIERS = - new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT, PsiModifier.STATIC)); - private static final Set FIELD_REDUNDANT_MODIFIERS = - new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL)); - private static final Set METHOD_REDUNDANT_MODIFIERS = - new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT)); - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryInterfaceModifierDisplayName().get(); - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - final PsiModifierList modifierList = (PsiModifierList)infos[1]; - final PsiElement parent = modifierList.getParent(); - if (parent instanceof PsiClass) { - final PsiClass aClass = (PsiClass)parent; - final PsiClass containingClass = aClass.getContainingClass(); - if (containingClass != null) { - return aClass.isInterface() - ? InspectionGadgetsLocalize.unnecessaryInterfaceModifierInnerInterfaceOfInterfaceProblemDescriptor().get() - : InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor3().get(); - } - else { - return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor().get(); - } - } - else if (parent instanceof PsiMethod) { - return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor2().get(); - } - else { - return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor4().get(); - } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryInterfaceModifierVisitor(); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryInterfaceModifiersFix((String)infos[0]); - } - - private static class UnnecessaryInterfaceModifiersFix extends InspectionGadgetsFix { - - private final String modifiersText; - - private UnnecessaryInterfaceModifiersFix(String modifiersText) { - this.modifiersText = modifiersText; - } + private static final Set INTERFACE_REDUNDANT_MODIFIERS = + new HashSet(Arrays.asList(PsiModifier.ABSTRACT, PsiModifier.STATIC)); + private static final Set INNER_CLASS_REDUNDANT_MODIFIERS = + new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC)); + private static final Set INNER_INTERFACE_REDUNDANT_MODIFIERS = + new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT, PsiModifier.STATIC)); + private static final Set FIELD_REDUNDANT_MODIFIERS = + new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL)); + private static final Set METHOD_REDUNDANT_MODIFIERS = + new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT)); @Nonnull - public String getName() { - return InspectionGadgetsLocalize.smthUnnecessaryRemoveQuickfix(modifiersText).get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryInterfaceModifierDisplayName(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - final PsiModifierList modifierList; - if (element instanceof PsiModifierList) { - modifierList = (PsiModifierList)element; - } - else { - final PsiElement parent = element.getParent(); - if (!(parent instanceof PsiModifierList)) { - return; + @Nonnull + public String buildErrorString(Object... infos) { + final PsiModifierList modifierList = (PsiModifierList) infos[1]; + final PsiElement parent = modifierList.getParent(); + if (parent instanceof PsiClass) { + final PsiClass aClass = (PsiClass) parent; + final PsiClass containingClass = aClass.getContainingClass(); + if (containingClass != null) { + return aClass.isInterface() + ? InspectionGadgetsLocalize.unnecessaryInterfaceModifierInnerInterfaceOfInterfaceProblemDescriptor().get() + : InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor3().get(); + } + else { + return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor().get(); + } } - modifierList = (PsiModifierList)parent; - } - modifierList.setModifierProperty(PsiModifier.STATIC, false); - final PsiElement modifierOwner = modifierList.getParent(); - assert modifierOwner != null; - if (modifierOwner instanceof PsiClass) { - final PsiClass aClass = (PsiClass)modifierOwner; - if (aClass.isInterface()) { - modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); + else if (parent instanceof PsiMethod) { + return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor2().get(); } - final PsiClass containingClass = ClassUtils.getContainingClass(modifierOwner); - if (containingClass != null && containingClass.isInterface()) { - // do the inner classes - modifierList.setModifierProperty(PsiModifier.PUBLIC, false); + else { + return InspectionGadgetsLocalize.unnecessaryInterfaceModifierProblemDescriptor4().get(); } - } - else if (modifierOwner instanceof PsiMethod) { - modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); - modifierList.setModifierProperty(PsiModifier.PUBLIC, false); - } - else { - modifierList.setModifierProperty(PsiModifier.PUBLIC, false); - modifierList.setModifierProperty(PsiModifier.FINAL, false); - } } - } - - private static class UnnecessaryInterfaceModifierVisitor extends BaseInspectionVisitor { @Override - public void visitClass(@Nonnull PsiClass aClass) { - final PsiClass parent = ClassUtils.getContainingClass(aClass); - if (parent != null && parent.isInterface()) { - final PsiModifierList modifiers = aClass.getModifierList(); - if (aClass.isInterface()) { - checkForRedundantModifiers(modifiers, INNER_INTERFACE_REDUNDANT_MODIFIERS); - } - else { - checkForRedundantModifiers(modifiers, INNER_CLASS_REDUNDANT_MODIFIERS); - } - } - else if (aClass.isInterface()) { - final PsiModifierList modifiers = aClass.getModifierList(); - checkForRedundantModifiers(modifiers, INTERFACE_REDUNDANT_MODIFIERS); - } + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryInterfaceModifierVisitor(); } @Override - public void visitField(@Nonnull PsiField field) { - // don't call super, to keep this from drilling in - final PsiClass containingClass = field.getContainingClass(); - if (containingClass == null) { - return; - } - if (!containingClass.isInterface()) { - return; - } - final PsiModifierList modifiers = field.getModifierList(); - checkForRedundantModifiers(modifiers, FIELD_REDUNDANT_MODIFIERS); + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryInterfaceModifiersFix((String) infos[0]); } - @Override - public void visitMethod(@Nonnull PsiMethod method) { - // don't call super, to keep this from drilling in - final PsiClass aClass = method.getContainingClass(); - if (aClass == null) { - return; - } - if (!aClass.isInterface()) { - return; - } - final PsiModifierList modifiers = method.getModifierList(); - checkForRedundantModifiers(modifiers, METHOD_REDUNDANT_MODIFIERS); + private static class UnnecessaryInterfaceModifiersFix extends InspectionGadgetsFix { + private final String modifiersText; + + private UnnecessaryInterfaceModifiersFix(String modifiersText) { + this.modifiersText = modifiersText; + } + + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.smthUnnecessaryRemoveQuickfix(modifiersText); + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + final PsiModifierList modifierList; + if (element instanceof PsiModifierList) { + modifierList = (PsiModifierList) element; + } + else { + final PsiElement parent = element.getParent(); + if (!(parent instanceof PsiModifierList)) { + return; + } + modifierList = (PsiModifierList) parent; + } + modifierList.setModifierProperty(PsiModifier.STATIC, false); + final PsiElement modifierOwner = modifierList.getParent(); + assert modifierOwner != null; + if (modifierOwner instanceof PsiClass) { + final PsiClass aClass = (PsiClass) modifierOwner; + if (aClass.isInterface()) { + modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); + } + final PsiClass containingClass = ClassUtils.getContainingClass(modifierOwner); + if (containingClass != null && containingClass.isInterface()) { + // do the inner classes + modifierList.setModifierProperty(PsiModifier.PUBLIC, false); + } + } + else if (modifierOwner instanceof PsiMethod) { + modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); + modifierList.setModifierProperty(PsiModifier.PUBLIC, false); + } + else { + modifierList.setModifierProperty(PsiModifier.PUBLIC, false); + modifierList.setModifierProperty(PsiModifier.FINAL, false); + } + } } - public void checkForRedundantModifiers(PsiModifierList list, Set modifiers) { - if (list == null) { - return; - } - final PsiElement[] children = list.getChildren(); - final StringBuilder redundantModifiers = new StringBuilder(); - for (PsiElement child : children) { - final String modifierText = child.getText(); - if (modifiers.contains(modifierText)) { - if (redundantModifiers.length() > 0) { - redundantModifiers.append(' '); - } - redundantModifiers.append(modifierText); + private static class UnnecessaryInterfaceModifierVisitor extends BaseInspectionVisitor { + @Override + public void visitClass(@Nonnull PsiClass aClass) { + final PsiClass parent = ClassUtils.getContainingClass(aClass); + if (parent != null && parent.isInterface()) { + final PsiModifierList modifiers = aClass.getModifierList(); + if (aClass.isInterface()) { + checkForRedundantModifiers(modifiers, INNER_INTERFACE_REDUNDANT_MODIFIERS); + } + else { + checkForRedundantModifiers(modifiers, INNER_CLASS_REDUNDANT_MODIFIERS); + } + } + else if (aClass.isInterface()) { + final PsiModifierList modifiers = aClass.getModifierList(); + checkForRedundantModifiers(modifiers, INTERFACE_REDUNDANT_MODIFIERS); + } + } + + @Override + public void visitField(@Nonnull PsiField field) { + // don't call super, to keep this from drilling in + final PsiClass containingClass = field.getContainingClass(); + if (containingClass == null) { + return; + } + if (!containingClass.isInterface()) { + return; + } + final PsiModifierList modifiers = field.getModifierList(); + checkForRedundantModifiers(modifiers, FIELD_REDUNDANT_MODIFIERS); } - } - for (PsiElement child : children) { - if (modifiers.contains(child.getText())) { - registerError(child, redundantModifiers.toString(), list); + + @Override + public void visitMethod(@Nonnull PsiMethod method) { + // don't call super, to keep this from drilling in + final PsiClass aClass = method.getContainingClass(); + if (aClass == null) { + return; + } + if (!aClass.isInterface()) { + return; + } + final PsiModifierList modifiers = method.getModifierList(); + checkForRedundantModifiers(modifiers, METHOD_REDUNDANT_MODIFIERS); + } + + public void checkForRedundantModifiers(PsiModifierList list, Set modifiers) { + if (list == null) { + return; + } + final PsiElement[] children = list.getChildren(); + final StringBuilder redundantModifiers = new StringBuilder(); + for (PsiElement child : children) { + final String modifierText = child.getText(); + if (modifiers.contains(modifierText)) { + if (redundantModifiers.length() > 0) { + redundantModifiers.append(' '); + } + redundantModifiers.append(modifierText); + } + } + for (PsiElement child : children) { + if (modifiers.contains(child.getText())) { + registerError(child, redundantModifiers.toString(), list); + } + } } - } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryParenthesesInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryParenthesesInspection.java index 5da529356..6bf7f3654 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryParenthesesInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryParenthesesInspection.java @@ -24,113 +24,111 @@ import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import consulo.project.Project; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; import javax.swing.*; public abstract class UnnecessaryParenthesesInspection extends BaseInspection { + @SuppressWarnings({"PublicField"}) + public boolean ignoreClarifyingParentheses = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreClarifyingParentheses = false; + @SuppressWarnings({"PublicField"}) + public boolean ignoreParenthesesOnConditionals = false; - @SuppressWarnings({"PublicField"}) - public boolean ignoreParenthesesOnConditionals = false; - - @SuppressWarnings("PublicField") - public boolean ignoreParenthesesOnLambdaParameter = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryParenthesesDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryParenthesesProblemDescriptor().get(); - } - - @Override - @NonNls - public JComponent createOptionsPanel() { - final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); - optionsPanel.addCheckbox(InspectionGadgetsLocalize.unnecessaryParenthesesOption().get(), "ignoreClarifyingParentheses"); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.unnecessaryParenthesesConditionalOption().get(), - "ignoreParenthesesOnConditionals" - ); - optionsPanel.addCheckbox( - InspectionGadgetsLocalize.ignoreParenthesesAroundSingleNoFormalTypeLambdaParameter().get(), - "ignoreParenthesesOnLambdaParameter" - ); - return optionsPanel; - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryParenthesesVisitor(); - } - - private class UnnecessaryParenthesesFix extends InspectionGadgetsFix { + @SuppressWarnings("PublicField") + public boolean ignoreParenthesesOnLambdaParameter = false; @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryParenthesesRemoveQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryParenthesesDisplayName(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) { - final PsiElement element = descriptor.getPsiElement(); - if (element instanceof PsiParameterList) { - final PsiElementFactory factory = JavaPsiFacade.getElementFactory(element.getProject()); - final PsiParameterList parameterList = (PsiParameterList)element; - final String text = parameterList.getParameters()[0].getName() + "->{}"; - final PsiLambdaExpression expression = (PsiLambdaExpression)factory.createExpressionFromText(text, element); - element.replace(expression.getParameterList()); - } else { - ParenthesesUtils.removeParentheses((PsiExpression)element, ignoreClarifyingParentheses); - } + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryParenthesesProblemDescriptor().get(); } - } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryParenthesesFix(); - } + @Override + public JComponent createOptionsPanel() { + final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); + optionsPanel.addCheckbox(InspectionGadgetsLocalize.unnecessaryParenthesesOption().get(), "ignoreClarifyingParentheses"); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.unnecessaryParenthesesConditionalOption().get(), + "ignoreParenthesesOnConditionals" + ); + optionsPanel.addCheckbox( + InspectionGadgetsLocalize.ignoreParenthesesAroundSingleNoFormalTypeLambdaParameter().get(), + "ignoreParenthesesOnLambdaParameter" + ); + return optionsPanel; + } - private class UnnecessaryParenthesesVisitor extends BaseInspectionVisitor { @Override - public void visitParameterList(PsiParameterList list) { - super.visitParameterList(list); - if (!ignoreParenthesesOnLambdaParameter && list.getParent() instanceof PsiLambdaExpression && list.getParametersCount() == 1) { - final PsiParameter parameter = list.getParameters()[0]; - if (parameter.getTypeElement() == null && list.getFirstChild() != parameter && list.getLastChild() != parameter) { - registerError(list); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryParenthesesVisitor(); + } + + private class UnnecessaryParenthesesFix extends InspectionGadgetsFix { + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryParenthesesRemoveQuickfix(); + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + if (element instanceof PsiParameterList) { + final PsiElementFactory factory = JavaPsiFacade.getElementFactory(element.getProject()); + final PsiParameterList parameterList = (PsiParameterList) element; + final String text = parameterList.getParameters()[0].getName() + "->{}"; + final PsiLambdaExpression expression = (PsiLambdaExpression) factory.createExpressionFromText(text, element); + element.replace(expression.getParameterList()); + } + else { + ParenthesesUtils.removeParentheses((PsiExpression) element, ignoreClarifyingParentheses); + } } - } } @Override - public void visitParenthesizedExpression(PsiParenthesizedExpression expression) { - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiParenthesizedExpression) { - return; - } - if (ignoreParenthesesOnConditionals && parent instanceof PsiConditionalExpression) { - final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)parent; - final PsiExpression condition = conditionalExpression.getCondition(); - if (expression == condition) { - return; + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryParenthesesFix(); + } + + private class UnnecessaryParenthesesVisitor extends BaseInspectionVisitor { + @Override + public void visitParameterList(PsiParameterList list) { + super.visitParameterList(list); + if (!ignoreParenthesesOnLambdaParameter && list.getParent() instanceof PsiLambdaExpression && list.getParametersCount() == 1) { + final PsiParameter parameter = list.getParameters()[0]; + if (parameter.getTypeElement() == null && list.getFirstChild() != parameter && list.getLastChild() != parameter) { + registerError(list); + } + } + } + + @Override + public void visitParenthesizedExpression(PsiParenthesizedExpression expression) { + final PsiElement parent = expression.getParent(); + if (parent instanceof PsiParenthesizedExpression) { + return; + } + if (ignoreParenthesesOnConditionals && parent instanceof PsiConditionalExpression) { + final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression) parent; + final PsiExpression condition = conditionalExpression.getCondition(); + if (expression == condition) { + return; + } + } + if (!ParenthesesUtils.areParenthesesNeeded(expression, ignoreClarifyingParentheses)) { + registerError(expression); + return; + } + super.visitParenthesizedExpression(expression); } - } - if (!ParenthesesUtils.areParenthesesNeeded(expression, ignoreClarifyingParentheses)) { - registerError(expression); - return; - } - super.visitParenthesizedExpression(expression); } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryQualifierForThisInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryQualifierForThisInspection.java index a33c669f1..5e8b51679 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryQualifierForThisInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryQualifierForThisInspection.java @@ -29,71 +29,65 @@ import consulo.language.editor.inspection.ProblemHighlightType; 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 UnnecessaryQualifierForThisInspection - extends BaseInspection { - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryQualifierForThisDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryQualifierForThisProblemDescriptor().get(); - } - - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryQualifierForThisVisitor(); - } - - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryQualifierForThisFix(); - } - - private static class UnnecessaryQualifierForThisFix - extends InspectionGadgetsFix { +public class UnnecessaryQualifierForThisInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryQualifierForThisDisplayName(); + } @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryQualifierForThisRemoveQuickfix().get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryQualifierForThisProblemDescriptor().get(); } - public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement qualifier = descriptor.getPsiElement(); - final PsiThisExpression thisExpression = (PsiThisExpression)qualifier.getParent(); - replaceExpression(thisExpression, PsiKeyword.THIS); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryQualifierForThisVisitor(); } - } - private static class UnnecessaryQualifierForThisVisitor - extends BaseInspectionVisitor { + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryQualifierForThisFix(); + } - @Override - public void visitThisExpression( - @Nonnull PsiThisExpression thisExpression) { - super.visitThisExpression(thisExpression); - final PsiJavaCodeReferenceElement qualifier = - thisExpression.getQualifier(); - if (qualifier == null) { - return; - } - final PsiElement referent = qualifier.resolve(); - if (!(referent instanceof PsiClass)) { - return; - } - final PsiClass containingClass = - ClassUtils.getContainingClass(thisExpression); - if (containingClass == null) { - return; - } - if (!containingClass.equals(referent)) { - return; - } - registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + private static class UnnecessaryQualifierForThisFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryQualifierForThisRemoveQuickfix(); + } + + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement qualifier = descriptor.getPsiElement(); + final PsiThisExpression thisExpression = (PsiThisExpression) qualifier.getParent(); + replaceExpression(thisExpression, PsiKeyword.THIS); + } + } + + private static class UnnecessaryQualifierForThisVisitor extends BaseInspectionVisitor { + @Override + public void visitThisExpression(@Nonnull PsiThisExpression thisExpression) { + super.visitThisExpression(thisExpression); + final PsiJavaCodeReferenceElement qualifier = thisExpression.getQualifier(); + if (qualifier == null) { + return; + } + final PsiElement referent = qualifier.resolve(); + if (!(referent instanceof PsiClass)) { + return; + } + final PsiClass containingClass = ClassUtils.getContainingClass(thisExpression); + if (containingClass == null) { + return; + } + if (!containingClass.equals(referent)) { + return; + } + registerError(qualifier, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySemicolonInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySemicolonInspection.java index 1d3dfebab..1ea3caef9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySemicolonInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySemicolonInspection.java @@ -29,195 +29,183 @@ import consulo.language.psi.PsiWhiteSpace; 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 UnnecessarySemicolonInspection extends BaseInspection { - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarySemicolonDisplayName().get(); - } - - @Override - public boolean isEnabledByDefault() { - return true; - } - - @Override - @Nonnull - public String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessarySemicolonProblemDescriptor().get(); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarySemicolonVisitor(); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarySemicolonFix(); - } - - private static class UnnecessarySemicolonFix extends InspectionGadgetsFix { - @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessarySemicolonRemoveQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarySemicolonDisplayName(); } @Override - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement semicolonElement = descriptor.getPsiElement(); - final PsiElement parent = semicolonElement.getParent(); - if (parent instanceof PsiEmptyStatement) { - final PsiElement lastChild = parent.getLastChild(); - if (lastChild instanceof PsiComment) { - parent.replace(lastChild); - } - else { - deleteElement(parent); - } - } - else { - deleteElement(semicolonElement); - } + public boolean isEnabledByDefault() { + return true; } - } - private static class UnnecessarySemicolonVisitor - extends BaseInspectionVisitor { + @Override + @Nonnull + public String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessarySemicolonProblemDescriptor().get(); + } - /** - * Finds semicolons between the top level classes in a java file. - */ @Override - public void visitFile(PsiFile file) { - final PsiElement firstChild = file.getFirstChild(); - PsiElement sibling = skipForwardWhiteSpacesAndComments(firstChild); - while (sibling != null) { - if (sibling instanceof PsiJavaToken) { - final PsiJavaToken token = (PsiJavaToken)sibling; - final IElementType tokenType = token.getTokenType(); - if (tokenType.equals(JavaTokenType.SEMICOLON)) { - registerError(sibling); - } - } - sibling = skipForwardWhiteSpacesAndComments(sibling); - } - super.visitFile(file); + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarySemicolonVisitor(); } @Override - public void visitClass(@Nonnull PsiClass aClass) { - super.visitClass(aClass); - - findUnnecessarySemicolonsAfterEnumConstants(aClass); - if (!aClass.isEnum()) { - return; - } - final PsiField[] fields = aClass.getFields(); - final PsiElement element; - if (fields.length > 0) { - final PsiField lastField = fields[fields.length - 1]; - if (!(lastField instanceof PsiEnumConstant)) { - return; - } - element = skipForwardWhiteSpacesAndComments(lastField); - } - else { - final PsiElement lBrace = aClass.getLBrace(); - element = skipForwardWhiteSpacesAndComments(lBrace); - } - if (!(element instanceof PsiJavaToken)) { - return; - } - final PsiJavaToken token = (PsiJavaToken)element; - final IElementType tokenType = token.getTokenType(); - if (!tokenType.equals(JavaTokenType.SEMICOLON)) { - return; - } - final PsiElement next = skipForwardWhiteSpacesAndComments(element); - if (next == null || !next.equals(aClass.getRBrace())) { - return; - } - registerError(element); + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarySemicolonFix(); } - private void findUnnecessarySemicolonsAfterEnumConstants( - @Nonnull PsiClass aClass) { - PsiElement child = aClass.getFirstChild(); - while (child != null) { - if (child instanceof PsiJavaToken) { - final PsiJavaToken token = (PsiJavaToken)child; - final IElementType tokenType = token.getTokenType(); - if (tokenType.equals(JavaTokenType.SEMICOLON)) { - final PsiElement prevSibling = - skipBackwardWhiteSpacesAndComments(child); - if (!(prevSibling instanceof PsiEnumConstant)) { - if (prevSibling instanceof PsiJavaToken) { - final PsiJavaToken javaToken = - (PsiJavaToken)prevSibling; - final IElementType prevTokenType = - javaToken.getTokenType(); - if (!JavaTokenType.COMMA.equals(prevTokenType) - && !JavaTokenType.LBRACE.equals( - prevTokenType)) { - registerError(child); + private static class UnnecessarySemicolonFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessarySemicolonRemoveQuickfix(); + } + + @Override + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement semicolonElement = descriptor.getPsiElement(); + final PsiElement parent = semicolonElement.getParent(); + if (parent instanceof PsiEmptyStatement) { + final PsiElement lastChild = parent.getLastChild(); + if (lastChild instanceof PsiComment) { + parent.replace(lastChild); + } + else { + deleteElement(parent); } - } - else { - registerError(child); - } } - } + else { + deleteElement(semicolonElement); + } } - child = skipForwardWhiteSpacesAndComments(child); - } } - @Nullable - private static PsiElement skipForwardWhiteSpacesAndComments( - PsiElement element) { - return PsiTreeUtil.skipSiblingsForward(element, - PsiWhiteSpace.class, PsiComment.class); - } + private static class UnnecessarySemicolonVisitor extends BaseInspectionVisitor { + /** + * Finds semicolons between the top level classes in a java file. + */ + @Override + public void visitFile(PsiFile file) { + final PsiElement firstChild = file.getFirstChild(); + PsiElement sibling = skipForwardWhiteSpacesAndComments(firstChild); + while (sibling != null) { + if (sibling instanceof PsiJavaToken) { + final PsiJavaToken token = (PsiJavaToken) sibling; + final IElementType tokenType = token.getTokenType(); + if (tokenType.equals(JavaTokenType.SEMICOLON)) { + registerError(sibling); + } + } + sibling = skipForwardWhiteSpacesAndComments(sibling); + } + super.visitFile(file); + } - @Nullable - private static PsiElement skipBackwardWhiteSpacesAndComments( - PsiElement element) { - return PsiTreeUtil.skipSiblingsBackward(element, - PsiWhiteSpace.class, PsiComment.class); - } + @Override + public void visitClass(@Nonnull PsiClass aClass) { + super.visitClass(aClass); - @Override - public void visitEmptyStatement(PsiEmptyStatement statement) { - super.visitEmptyStatement(statement); - final PsiElement parent = statement.getParent(); - if (parent instanceof PsiCodeBlock) { - final PsiElement semicolon = statement.getFirstChild(); - if (semicolon == null) { - return; + findUnnecessarySemicolonsAfterEnumConstants(aClass); + if (!aClass.isEnum()) { + return; + } + final PsiField[] fields = aClass.getFields(); + final PsiElement element; + if (fields.length > 0) { + final PsiField lastField = fields[fields.length - 1]; + if (!(lastField instanceof PsiEnumConstant)) { + return; + } + element = skipForwardWhiteSpacesAndComments(lastField); + } + else { + final PsiElement lBrace = aClass.getLBrace(); + element = skipForwardWhiteSpacesAndComments(lBrace); + } + if (!(element instanceof PsiJavaToken)) { + return; + } + final PsiJavaToken token = (PsiJavaToken) element; + final IElementType tokenType = token.getTokenType(); + if (!tokenType.equals(JavaTokenType.SEMICOLON)) { + return; + } + final PsiElement next = skipForwardWhiteSpacesAndComments(element); + if (next == null || !next.equals(aClass.getRBrace())) { + return; + } + registerError(element); } - registerError(semicolon); - } - } - @Override - public void visitResourceList(final PsiResourceList resourceList) { - super.visitResourceList(resourceList); - final PsiElement last = resourceList.getLastChild(); - if (last instanceof PsiJavaToken && ((PsiJavaToken)last).getTokenType() == JavaTokenType.RPARENTH) { - final PsiElement prev = skipBackwardWhiteSpacesAndComments(last); - if (prev instanceof PsiJavaToken && ((PsiJavaToken)prev).getTokenType() == JavaTokenType.SEMICOLON) { - registerError(prev); + private void findUnnecessarySemicolonsAfterEnumConstants(@Nonnull PsiClass aClass) { + PsiElement child = aClass.getFirstChild(); + while (child != null) { + if (child instanceof PsiJavaToken) { + final PsiJavaToken token = (PsiJavaToken) child; + final IElementType tokenType = token.getTokenType(); + if (tokenType.equals(JavaTokenType.SEMICOLON)) { + final PsiElement prevSibling = skipBackwardWhiteSpacesAndComments(child); + if (!(prevSibling instanceof PsiEnumConstant)) { + if (prevSibling instanceof PsiJavaToken) { + final PsiJavaToken javaToken = (PsiJavaToken) prevSibling; + final IElementType prevTokenType = javaToken.getTokenType(); + if (!JavaTokenType.COMMA.equals(prevTokenType) + && !JavaTokenType.LBRACE.equals(prevTokenType)) { + registerError(child); + } + } + else { + registerError(child); + } + } + } + } + child = skipForwardWhiteSpacesAndComments(child); + } + } + + @Nullable + private static PsiElement skipForwardWhiteSpacesAndComments(PsiElement element) { + return PsiTreeUtil.skipSiblingsForward(element, PsiWhiteSpace.class, PsiComment.class); + } + + @Nullable + private static PsiElement skipBackwardWhiteSpacesAndComments(PsiElement element) { + return PsiTreeUtil.skipSiblingsBackward(element, PsiWhiteSpace.class, PsiComment.class); + } + + @Override + public void visitEmptyStatement(PsiEmptyStatement statement) { + super.visitEmptyStatement(statement); + final PsiElement parent = statement.getParent(); + if (parent instanceof PsiCodeBlock) { + final PsiElement semicolon = statement.getFirstChild(); + if (semicolon == null) { + return; + } + registerError(semicolon); + } + } + + @Override + public void visitResourceList(final PsiResourceList resourceList) { + super.visitResourceList(resourceList); + final PsiElement last = resourceList.getLastChild(); + if (last instanceof PsiJavaToken && ((PsiJavaToken) last).getTokenType() == JavaTokenType.RPARENTH) { + final PsiElement prev = skipBackwardWhiteSpacesAndComments(last); + if (prev instanceof PsiJavaToken && ((PsiJavaToken) prev).getTokenType() == JavaTokenType.SEMICOLON) { + registerError(prev); + } + } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperConstructorInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperConstructorInspection.java index 99abab629..33b34c3a5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperConstructorInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperConstructorInspection.java @@ -25,72 +25,65 @@ import consulo.language.editor.inspection.ProblemHighlightType; 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 UnnecessarySuperConstructorInspection - extends BaseInspection { - - @Nonnull - public String getID() { - return "UnnecessaryCallToSuper"; - } - - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarySuperConstructorDisplayName().get(); - } - - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessarySuperConstructorProblemDescriptor().get(); - } - - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarySuperConstructorFix(); - } +public class UnnecessarySuperConstructorInspection extends BaseInspection { + @Nonnull + public String getID() { + return "UnnecessaryCallToSuper"; + } - private static class UnnecessarySuperConstructorFix - extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarySuperConstructorDisplayName(); + } @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessarySuperConstructorRemoveQuickfix().get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessarySuperConstructorProblemDescriptor().get(); } - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement superCall = descriptor.getPsiElement(); - final PsiElement callStatement = superCall.getParent(); - assert callStatement != null; - deleteElement(callStatement); + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarySuperConstructorFix(); } - } - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarySuperConstructorVisitor(); - } + private static class UnnecessarySuperConstructorFix extends InspectionGadgetsFix { + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessarySuperConstructorRemoveQuickfix(); + } + + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement superCall = descriptor.getPsiElement(); + final PsiElement callStatement = superCall.getParent(); + assert callStatement != null; + deleteElement(callStatement); + } + } - private static class UnnecessarySuperConstructorVisitor - extends BaseInspectionVisitor { + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarySuperConstructorVisitor(); + } - @Override - public void visitMethodCallExpression( - @Nonnull PsiMethodCallExpression call) { - super.visitMethodCallExpression(call); - final PsiReferenceExpression methodExpression = - call.getMethodExpression(); - final String methodText = methodExpression.getText(); - if (!PsiKeyword.SUPER.equals(methodText)) { - return; - } - final PsiExpressionList argumentList = call.getArgumentList(); - final PsiExpression[] args = argumentList.getExpressions(); - if (args.length != 0) { - return; - } - registerError(call, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + private static class UnnecessarySuperConstructorVisitor extends BaseInspectionVisitor { + @Override + public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression call) { + super.visitMethodCallExpression(call); + final PsiReferenceExpression methodExpression = call.getMethodExpression(); + final String methodText = methodExpression.getText(); + if (!PsiKeyword.SUPER.equals(methodText)) { + return; + } + final PsiExpressionList argumentList = call.getArgumentList(); + final PsiExpression[] args = argumentList.getExpressions(); + if (args.length != 0) { + return; + } + registerError(call, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperQualifierInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperQualifierInspection.java index 8b7f82719..193a65abd 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperQualifierInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessarySuperQualifierInspection.java @@ -26,117 +26,111 @@ 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; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class UnnecessarySuperQualifierInspection extends BaseInspection { - - @Override - @Nls - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessarySuperQualifierDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessarySuperQualifierProblemDescriptor().get(); - } - - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessarySuperQualifierFix(); - } - - private static class UnnecessarySuperQualifierFix extends InspectionGadgetsFix { @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessarySuperQualifierQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessarySuperQualifierDisplayName(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - element.delete(); + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessarySuperQualifierProblemDescriptor().get(); } - } - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessarySuperQualifierVisitor(); - } - - private static class UnnecessarySuperQualifierVisitor extends BaseInspectionVisitor { @Override - public void visitSuperExpression(PsiSuperExpression expression) { - super.visitSuperExpression(expression); - final PsiJavaCodeReferenceElement qualifier = expression.getQualifier(); - if (qualifier != null) { - return; - } - final PsiElement parent = expression.getParent(); - if (!(parent instanceof PsiReferenceExpression)) { - return; - } - final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)parent; - final PsiElement grandParent = referenceExpression.getParent(); - if (grandParent instanceof PsiMethodCallExpression methodCallExpression) { - if (!hasUnnecessarySuperQualifier(methodCallExpression)) { - return; + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessarySuperQualifierFix(); + } + + private static class UnnecessarySuperQualifierFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessarySuperQualifierQuickfix(); } - } - else { - if (!hasUnnecessarySuperQualifier(referenceExpression)) { - return; + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) + throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + element.delete(); } - } - registerError(expression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } - private static boolean hasUnnecessarySuperQualifier(PsiReferenceExpression referenceExpression) { - final PsiClass parentClass = PsiTreeUtil.getParentOfType(referenceExpression, PsiClass.class); - if (parentClass == null) { - return false; - } - final PsiElement target = referenceExpression.resolve(); - if (!(target instanceof PsiField)) { - return false; - } - final PsiField superField = (PsiField)target; - final PsiReferenceExpression copy = (PsiReferenceExpression) - referenceExpression.copy(); - final PsiElement qualifier = copy.getQualifier(); - if (qualifier == null) { - return false; - } - qualifier.delete(); // remove super - return superField == copy.resolve(); + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessarySuperQualifierVisitor(); } - private static boolean hasUnnecessarySuperQualifier( - PsiMethodCallExpression methodCallExpression) { - final PsiMethod superMethod = - methodCallExpression.resolveMethod(); - if (superMethod == null) { - return false; - } - // check that super.m() and m() resolve to the same method - final PsiMethodCallExpression copy = - (PsiMethodCallExpression)methodCallExpression.copy(); - final PsiReferenceExpression methodExpression = - copy.getMethodExpression(); - final PsiElement qualifier = methodExpression.getQualifier(); - if (qualifier == null) { - return false; - } - qualifier.delete(); //remove super - return superMethod == copy.resolveMethod(); + private static class UnnecessarySuperQualifierVisitor extends BaseInspectionVisitor { + @Override + public void visitSuperExpression(PsiSuperExpression expression) { + super.visitSuperExpression(expression); + final PsiJavaCodeReferenceElement qualifier = expression.getQualifier(); + if (qualifier != null) { + return; + } + final PsiElement parent = expression.getParent(); + if (!(parent instanceof PsiReferenceExpression)) { + return; + } + final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) parent; + final PsiElement grandParent = referenceExpression.getParent(); + if (grandParent instanceof PsiMethodCallExpression methodCallExpression) { + if (!hasUnnecessarySuperQualifier(methodCallExpression)) { + return; + } + } + else { + if (!hasUnnecessarySuperQualifier(referenceExpression)) { + return; + } + } + registerError(expression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } + + private static boolean hasUnnecessarySuperQualifier(PsiReferenceExpression referenceExpression) { + final PsiClass parentClass = PsiTreeUtil.getParentOfType(referenceExpression, PsiClass.class); + if (parentClass == null) { + return false; + } + final PsiElement target = referenceExpression.resolve(); + if (!(target instanceof PsiField)) { + return false; + } + final PsiField superField = (PsiField) target; + final PsiReferenceExpression copy = (PsiReferenceExpression) referenceExpression.copy(); + final PsiElement qualifier = copy.getQualifier(); + if (qualifier == null) { + return false; + } + qualifier.delete(); // remove super + return superField == copy.resolve(); + } + + private static boolean hasUnnecessarySuperQualifier(PsiMethodCallExpression methodCallExpression) { + final PsiMethod superMethod = methodCallExpression.resolveMethod(); + if (superMethod == null) { + return false; + } + // check that super.m() and m() resolve to the same method + final PsiMethodCallExpression copy = (PsiMethodCallExpression) methodCallExpression.copy(); + final PsiReferenceExpression methodExpression = copy.getMethodExpression(); + final PsiElement qualifier = methodExpression.getQualifier(); + if (qualifier == null) { + return false; + } + qualifier.delete(); //remove super + return superMethod == copy.resolveMethod(); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryThisInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryThisInspection.java index 91a95a9d1..55a1ddb98 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryThisInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryThisInspection.java @@ -39,157 +39,153 @@ @ExtensionImpl public class UnnecessaryThisInspection extends BaseInspection { - - @SuppressWarnings("PublicField") - public boolean ignoreAssignments = false; - - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryThisDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryThisProblemDescriptor().get(); - } - - @Nullable - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.unnecessaryThisIgnoreAssignmentsOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreAssignments"); - } - - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new UnnecessaryThisFix(); - } - - private static class UnnecessaryThisFix extends InspectionGadgetsFix { + @SuppressWarnings("PublicField") + public boolean ignoreAssignments = false; @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryThisRemoveQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryThisDisplayName(); } - public void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement thisToken = descriptor.getPsiElement(); - final PsiReferenceExpression thisExpression = - (PsiReferenceExpression)thisToken.getParent(); - assert thisExpression != null; - final String newExpression = thisExpression.getReferenceName(); - if (newExpression == null) { - return; - } - replaceExpression(thisExpression, newExpression); + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryThisProblemDescriptor().get(); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryThisVisitor(); - } - private class UnnecessaryThisVisitor extends BaseInspectionVisitor { + @Nullable + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.unnecessaryThisIgnoreAssignmentsOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreAssignments"); + } @Override - public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) { - super.visitReferenceExpression(expression); - final PsiReferenceParameterList parameterList = expression.getParameterList(); - if (parameterList == null) { - return; - } - if (parameterList.getTypeArguments().length > 0) { - return; - } - final PsiExpression qualifierExpression = expression.getQualifierExpression(); - if (!(qualifierExpression instanceof PsiThisExpression)) { - return; - } - final PsiThisExpression thisExpression = (PsiThisExpression)qualifierExpression; - final PsiJavaCodeReferenceElement qualifier = thisExpression.getQualifier(); - final String referenceName = expression.getReferenceName(); - if (referenceName == null) { - return; - } - if (ignoreAssignments && PsiUtil.isAccessedForWriting(expression)) { - return; - } - final PsiElement parent = expression.getParent(); - if (qualifier == null) { - if (parent instanceof PsiCallExpression) { - // method calls are always in error - registerError(qualifierExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); - return; - } - final PsiElement target = expression.resolve(); - if (!(target instanceof PsiVariable)) { - return; - } - final PsiVariable variable = (PsiVariable)target; - if (!VariableSearchUtils.variableNameResolvesToTarget(referenceName, variable, expression)) { - return; + public InspectionGadgetsFix buildFix(Object... infos) { + return new UnnecessaryThisFix(); + } + + private static class UnnecessaryThisFix extends InspectionGadgetsFix { + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryThisRemoveQuickfix(); } - registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); - } - else { - final String qualifierName = qualifier.getReferenceName(); - if (qualifierName == null) { - return; + + public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement thisToken = descriptor.getPsiElement(); + final PsiReferenceExpression thisExpression = (PsiReferenceExpression) thisToken.getParent(); + assert thisExpression != null; + final String newExpression = thisExpression.getReferenceName(); + if (newExpression == null) { + return; + } + replaceExpression(thisExpression, newExpression); } - if (parent instanceof PsiCallExpression) { - final PsiCallExpression callExpression = (PsiCallExpression)parent; - final PsiMethod calledMethod = callExpression.resolveMethod(); - if (calledMethod == null) { - return; - } - final String methodName = calledMethod.getName(); - PsiClass parentClass = ClassUtils.getContainingClass(expression); - final Project project = expression.getProject(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiResolveHelper resolveHelper = psiFacade.getResolveHelper(); - while (parentClass != null) { - if (qualifierName.equals(parentClass.getName())) { - registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryThisVisitor(); + } + + private class UnnecessaryThisVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) { + super.visitReferenceExpression(expression); + final PsiReferenceParameterList parameterList = expression.getParameterList(); + if (parameterList == null) { + return; } - final PsiMethod[] methods = parentClass.findMethodsByName(methodName, true); - for (PsiMethod method : methods) { - final PsiClass containingClass = method.getContainingClass(); - if (resolveHelper.isAccessible(method, expression, containingClass)) { - if (method.hasModifierProperty(PsiModifier.PRIVATE) && !PsiTreeUtil.isAncestor(containingClass, expression, true)) { - continue; - } + if (parameterList.getTypeArguments().length > 0) { return; - } } - parentClass = ClassUtils.getContainingClass(parentClass); - } - } - else { - final PsiElement target = expression.resolve(); - if (!(target instanceof PsiVariable)) { - return; - } - final PsiVariable variable = (PsiVariable)target; - if (!VariableSearchUtils.variableNameResolvesToTarget(referenceName, variable, expression)) { - return; - } - PsiClass parentClass = ClassUtils.getContainingClass(expression); - while (parentClass != null) { - if (qualifierName.equals(parentClass.getName())) { - registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + final PsiExpression qualifierExpression = expression.getQualifierExpression(); + if (!(qualifierExpression instanceof PsiThisExpression)) { + return; + } + final PsiThisExpression thisExpression = (PsiThisExpression) qualifierExpression; + final PsiJavaCodeReferenceElement qualifier = thisExpression.getQualifier(); + final String referenceName = expression.getReferenceName(); + if (referenceName == null) { + return; } - final PsiField field = parentClass.findFieldByName(referenceName, true); - if (field != null) { - return; + if (ignoreAssignments && PsiUtil.isAccessedForWriting(expression)) { + return; + } + final PsiElement parent = expression.getParent(); + if (qualifier == null) { + if (parent instanceof PsiCallExpression) { + // method calls are always in error + registerError(qualifierExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + return; + } + final PsiElement target = expression.resolve(); + if (!(target instanceof PsiVariable)) { + return; + } + final PsiVariable variable = (PsiVariable) target; + if (!VariableSearchUtils.variableNameResolvesToTarget(referenceName, variable, expression)) { + return; + } + registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } + else { + final String qualifierName = qualifier.getReferenceName(); + if (qualifierName == null) { + return; + } + if (parent instanceof PsiCallExpression) { + final PsiCallExpression callExpression = (PsiCallExpression) parent; + final PsiMethod calledMethod = callExpression.resolveMethod(); + if (calledMethod == null) { + return; + } + final String methodName = calledMethod.getName(); + PsiClass parentClass = ClassUtils.getContainingClass(expression); + final Project project = expression.getProject(); + final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); + final PsiResolveHelper resolveHelper = psiFacade.getResolveHelper(); + while (parentClass != null) { + if (qualifierName.equals(parentClass.getName())) { + registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } + final PsiMethod[] methods = parentClass.findMethodsByName(methodName, true); + for (PsiMethod method : methods) { + final PsiClass containingClass = method.getContainingClass(); + if (resolveHelper.isAccessible(method, expression, containingClass)) { + if (method.hasModifierProperty(PsiModifier.PRIVATE) + && !PsiTreeUtil.isAncestor(containingClass, expression, true)) { + continue; + } + return; + } + } + parentClass = ClassUtils.getContainingClass(parentClass); + } + } + else { + final PsiElement target = expression.resolve(); + if (!(target instanceof PsiVariable)) { + return; + } + final PsiVariable variable = (PsiVariable) target; + if (!VariableSearchUtils.variableNameResolvesToTarget(referenceName, variable, expression)) { + return; + } + PsiClass parentClass = ClassUtils.getContainingClass(expression); + while (parentClass != null) { + if (qualifierName.equals(parentClass.getName())) { + registerError(thisExpression, ProblemHighlightType.LIKE_UNUSED_SYMBOL); + } + final PsiField field = parentClass.findFieldByName(referenceName, true); + if (field != null) { + return; + } + parentClass = ClassUtils.getContainingClass(parentClass); + } + } } - parentClass = ClassUtils.getContainingClass(parentClass); - } } - } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryToStringCallInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryToStringCallInspection.java index 87c66f2f9..b95c686b7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryToStringCallInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnnecessaryToStringCallInspection.java @@ -26,177 +26,193 @@ 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 jakarta.annotation.Nullable; -import org.jetbrains.annotations.Nls; @ExtensionImpl public class UnnecessaryToStringCallInspection extends BaseInspection { - - @Override - @Nls - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unnecessaryTostringCallDisplayName().get(); - } - - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unnecessaryTostringCallProblemDescriptor().get(); - } - - @Override - @Nullable - protected InspectionGadgetsFix buildFix(Object... infos) { - final String text = (String)infos[0]; - return new UnnecessaryCallToStringValueOfFix(text); - } - - public static String calculateReplacementText(PsiExpression expression) { - if (expression == null) { - return "this"; - } - return expression.getText(); - } - - private static class UnnecessaryCallToStringValueOfFix extends InspectionGadgetsFix { - - private final String replacementText; - - UnnecessaryCallToStringValueOfFix(String replacementText) { - this.replacementText = replacementText; + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unnecessaryTostringCallDisplayName(); } + @Override @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unnecessaryCallToStringValueofQuickfix(replacementText).get(); + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unnecessaryTostringCallProblemDescriptor().get(); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)descriptor.getPsiElement().getParent().getParent(); - final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier == null) { - replaceExpression(methodCallExpression, "this"); - } else { - methodCallExpression.replace(qualifier); - } + @Nullable + protected InspectionGadgetsFix buildFix(Object... infos) { + final String text = (String) infos[0]; + return new UnnecessaryCallToStringValueOfFix(text); } - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnnecessaryCallToStringValueOfVisitor(); - } - - private static class UnnecessaryCallToStringValueOfVisitor extends BaseInspectionVisitor { - @Override - public void visitMethodCallExpression(PsiMethodCallExpression expression) { - super.visitMethodCallExpression(expression); - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final String referenceName = methodExpression.getReferenceName(); - if (!"toString".equals(referenceName)) { - return; - } - if (isToStringCallNecessary(expression)) { - return; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - if (arguments.length != 0) { - return; - } - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier != null && qualifier.getType() instanceof PsiArrayType) { - // do not warn on nonsensical code - return; - } - registerMethodCallError(expression, calculateReplacementText(qualifier)); + public static String calculateReplacementText(PsiExpression expression) { + if (expression == null) { + return "this"; + } + return expression.getText(); } - private boolean isToStringCallNecessary(PsiMethodCallExpression expression) { - final PsiElement parent = ParenthesesUtils.getParentSkipParentheses(expression); - if (parent instanceof PsiPolyadicExpression) { - final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)parent; - final PsiType type = polyadicExpression.getType(); - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type)) { - return true; - } - final PsiExpression[] operands = polyadicExpression.getOperands(); - int index = -1; - for (int i = 0, length = operands.length; i < length; i++) { - final PsiExpression operand = operands[i]; - if (expression.equals(operand)) { - index = i; + private static class UnnecessaryCallToStringValueOfFix extends InspectionGadgetsFix { + private final String replacementText; + + UnnecessaryCallToStringValueOfFix(String replacementText) { + this.replacementText = replacementText; } - } - if (index > 0) { - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index - 1].getType())) { - return true; + + @Nonnull + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unnecessaryCallToStringValueofQuickfix(replacementText); } - } else if (operands.length > 1) { - if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index + 1].getType())) { - return true; + + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiMethodCallExpression methodCallExpression = + (PsiMethodCallExpression) descriptor.getPsiElement().getParent().getParent(); + final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier == null) { + replaceExpression(methodCallExpression, "this"); + } + else { + methodCallExpression.replace(qualifier); + } } - } else { - return true; - } - } else if (parent instanceof PsiExpressionList) { - final PsiExpressionList expressionList = (PsiExpressionList)parent; - final PsiElement grandParent = expressionList.getParent(); - if (!(grandParent instanceof PsiMethodCallExpression)) { - return true; - } - final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)grandParent; - final PsiReferenceExpression methodExpression1 = methodCallExpression.getMethodExpression(); - final String name = methodExpression1.getReferenceName(); - final PsiExpression[] expressions = expressionList.getExpressions(); - if ("insert".equals(name)) { - if (expressions.length < 2 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[1]))) { - return true; + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnnecessaryCallToStringValueOfVisitor(); + } + + private static class UnnecessaryCallToStringValueOfVisitor extends BaseInspectionVisitor { + @Override + public void visitMethodCallExpression(PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final String referenceName = methodExpression.getReferenceName(); + if (!"toString".equals(referenceName)) { + return; + } + if (isToStringCallNecessary(expression)) { + return; + } + final PsiExpressionList argumentList = expression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 0) { + return; + } + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null && qualifier.getType() instanceof PsiArrayType) { + // do not warn on nonsensical code + return; + } + registerMethodCallError(expression, calculateReplacementText(qualifier)); } - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_LANG_STRING_BUILDER, CommonClassNames.JAVA_LANG_STRING_BUFFER)) { - return true; - } - } else if ("append".equals(name)) { - if (expressions.length < 1 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[0]))) { - return true; - } - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_LANG_STRING_BUILDER, CommonClassNames.JAVA_LANG_STRING_BUFFER)) { - return true; - } - } else if ("print".equals(name) || "println".equals(name)) { - if (!isCallToMethodIn(methodCallExpression, CommonClassNames.JAVA_IO_PRINT_STREAM, CommonClassNames.JAVA_IO_PRINT_WRITER)) { - return true; - } + private boolean isToStringCallNecessary(PsiMethodCallExpression expression) { + final PsiElement parent = ParenthesesUtils.getParentSkipParentheses(expression); + if (parent instanceof PsiPolyadicExpression) { + final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) parent; + final PsiType type = polyadicExpression.getType(); + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, type)) { + return true; + } + final PsiExpression[] operands = polyadicExpression.getOperands(); + int index = -1; + for (int i = 0, length = operands.length; i < length; i++) { + final PsiExpression operand = operands[i]; + if (expression.equals(operand)) { + index = i; + } + } + if (index > 0) { + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index - 1].getType())) { + return true; + } + } + else if (operands.length > 1) { + if (!TypeUtils.typeEquals(CommonClassNames.JAVA_LANG_STRING, operands[index + 1].getType())) { + return true; + } + } + else { + return true; + } + } + else if (parent instanceof PsiExpressionList) { + final PsiExpressionList expressionList = (PsiExpressionList) parent; + final PsiElement grandParent = expressionList.getParent(); + if (!(grandParent instanceof PsiMethodCallExpression)) { + return true; + } + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent; + final PsiReferenceExpression methodExpression1 = methodCallExpression.getMethodExpression(); + final String name = methodExpression1.getReferenceName(); + final PsiExpression[] expressions = expressionList.getExpressions(); + if ("insert".equals(name)) { + if (expressions.length < 2 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[1]))) { + return true; + } + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_LANG_STRING_BUILDER, + CommonClassNames.JAVA_LANG_STRING_BUFFER + )) { + return true; + } + + } + else if ("append".equals(name)) { + if (expressions.length < 1 || !expression.equals(ParenthesesUtils.stripParentheses(expressions[0]))) { + return true; + } + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_LANG_STRING_BUILDER, + CommonClassNames.JAVA_LANG_STRING_BUFFER + )) { + return true; + } + } + else if ("print".equals(name) || "println".equals(name)) { + if (!isCallToMethodIn( + methodCallExpression, + CommonClassNames.JAVA_IO_PRINT_STREAM, + CommonClassNames.JAVA_IO_PRINT_WRITER + )) { + return true; + } + } + } + else { + return true; + } + return false; } - } else { - return true; - } - return false; - } - private boolean isCallToMethodIn(PsiMethodCallExpression methodCallExpression, String... classNames) { - final PsiMethod method = methodCallExpression.resolveMethod(); - if (method == null) { - return false; - } - final PsiClass containingClass = method.getContainingClass(); - if (containingClass == null) { - return false; - } - final String qualifiedName = containingClass.getQualifiedName(); - for (String className : classNames) { - if (className.equals(qualifiedName)) { - return true; - } - } - return false; + private boolean isCallToMethodIn(PsiMethodCallExpression methodCallExpression, String... classNames) { + final PsiMethod method = methodCallExpression.resolveMethod(); + if (method == null) { + return false; + } + final PsiClass containingClass = method.getContainingClass(); + if (containingClass == null) { + return false; + } + final String qualifiedName = containingClass.getQualifiedName(); + for (String className : classNames) { + if (className.equals(qualifiedName)) { + return true; + } + } + return false; + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedFieldAccessInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedFieldAccessInspection.java index e3907c451..a172c37e0 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedFieldAccessInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedFieldAccessInspection.java @@ -23,64 +23,64 @@ 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 UnqualifiedFieldAccessInspection extends BaseInspection { + @Nonnull + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unqualifiedFieldAccessDisplayName(); + } - @Override - @Nonnull - public String getDisplayName() { - return InspectionGadgetsLocalize.unqualifiedFieldAccessDisplayName().get(); - } - - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnqualifiedFieldAccessVisitor(); - } + @Override + public BaseInspectionVisitor buildVisitor() { + return new UnqualifiedFieldAccessVisitor(); + } - @Override - @Nonnull - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unqualifiedFieldAccessProblemDescriptor().get(); - } + @Override + @Nonnull + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unqualifiedFieldAccessProblemDescriptor().get(); + } - @Override - public InspectionGadgetsFix buildFix(Object... infos) { - return new AddThisQualifierFix(); - } + @Override + public InspectionGadgetsFix buildFix(Object... infos) { + return new AddThisQualifierFix(); + } - private static class UnqualifiedFieldAccessVisitor extends BaseInspectionVisitor { + private static class UnqualifiedFieldAccessVisitor extends BaseInspectionVisitor { - @Override - public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) { - super.visitReferenceExpression(expression); - final PsiExpression qualifierExpression = expression.getQualifierExpression(); - if (qualifierExpression != null) { - return; - } - final PsiReferenceParameterList parameterList = expression.getParameterList(); - if (parameterList == null) { - return; - } - if (parameterList.getTypeArguments().length > 0) { - // optimization: reference with type arguments are - // definitely not references to fields. - return; - } - final PsiElement element = expression.resolve(); - if (!(element instanceof PsiField)) { - return; - } - final PsiField field = (PsiField)element; - if (field.hasModifierProperty(PsiModifier.STATIC)) { - return; - } - final PsiClass containingClass = field.getContainingClass(); - if (containingClass instanceof PsiAnonymousClass) { - return; - } - registerError(expression); + @Override + public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) { + super.visitReferenceExpression(expression); + final PsiExpression qualifierExpression = expression.getQualifierExpression(); + if (qualifierExpression != null) { + return; + } + final PsiReferenceParameterList parameterList = expression.getParameterList(); + if (parameterList == null) { + return; + } + if (parameterList.getTypeArguments().length > 0) { + // optimization: reference with type arguments are + // definitely not references to fields. + return; + } + final PsiElement element = expression.resolve(); + if (!(element instanceof PsiField)) { + return; + } + final PsiField field = (PsiField) element; + if (field.hasModifierProperty(PsiModifier.STATIC)) { + return; + } + final PsiClass containingClass = field.getContainingClass(); + if (containingClass instanceof PsiAnonymousClass) { + return; + } + registerError(expression); + } } - } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedInnerClassAccessInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedInnerClassAccessInspection.java index f6cb989de..d10db4df4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedInnerClassAccessInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/UnqualifiedInnerClassAccessInspection.java @@ -39,260 +39,260 @@ @ExtensionImpl public class UnqualifiedInnerClassAccessInspection extends BaseInspection { - - @SuppressWarnings({"PublicField"}) - public boolean ignoreReferencesToLocalInnerClasses = false; - - @Nls - @Nonnull - @Override - public String getDisplayName() { - return InspectionGadgetsLocalize.unqualifiedInnerClassAccessDisplayName().get(); - } - - @Nonnull - @Override - protected String buildErrorString(Object... infos) { - return InspectionGadgetsLocalize.unqualifiedInnerClassAccessProblemDescriptor().get(); - } - - @Override - public JComponent createOptionsPanel() { - LocalizeValue message = InspectionGadgetsLocalize.unqualifiedInnerClassAccessOption(); - return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreReferencesToLocalInnerClasses"); - } - - @Override - protected InspectionGadgetsFix buildFix(Object... infos) { - return new UnqualifiedInnerClassAccessFix(); - } - - private static class UnqualifiedInnerClassAccessFix extends InspectionGadgetsFix { + @SuppressWarnings({"PublicField"}) + public boolean ignoreReferencesToLocalInnerClasses = false; @Nonnull - public String getName() { - return InspectionGadgetsLocalize.unqualifiedInnerClassAccessQuickfix().get(); + @Override + public LocalizeValue getDisplayName() { + return InspectionGadgetsLocalize.unqualifiedInnerClassAccessDisplayName(); } + @Nonnull @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - if (!(element instanceof PsiJavaCodeReferenceElement)) { - return; - } - final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)element; - final PsiElement target = referenceElement.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - final PsiClass containingClass = aClass.getContainingClass(); - if (containingClass == null) { - return; - } - final String qualifiedName = containingClass.getQualifiedName(); - if (qualifiedName == null) { - return; - } - final PsiFile containingFile = referenceElement.getContainingFile(); - if (!(containingFile instanceof PsiJavaFile)) { - return; - } - final PsiJavaFile javaFile = (PsiJavaFile)containingFile; - final String innerClassName = aClass.getQualifiedName(); - if (innerClassName == null) { - return; - } - final PsiImportList importList = javaFile.getImportList(); - if (importList == null) { - return; - } - final PsiImportStatement[] importStatements = importList.getImportStatements(); - final int importStatementsLength = importStatements.length; - boolean onDemand = false; - PsiImportStatement referenceImportStatement = null; - for (int i = importStatementsLength - 1; i >= 0; i--) { - final PsiImportStatement importStatement = importStatements[i]; - final String importString = importStatement.getQualifiedName(); - if (importStatement.isOnDemand()) { - if (qualifiedName.equals(importString)) { - referenceImportStatement = importStatement; - onDemand = true; - break; - } - } - else { - if (innerClassName.equals(importString)) { - referenceImportStatement = importStatement; - break; - } - } - } - final ReferenceCollector referenceCollector; - if (onDemand) { - referenceCollector = new ReferenceCollector(qualifiedName, onDemand); - } - else { - referenceCollector = new ReferenceCollector(innerClassName, onDemand); - } - final PsiClass[] classes = javaFile.getClasses(); - for (PsiClass psiClass : classes) { - psiClass.accept(referenceCollector); - } - final Collection references = referenceCollector.getReferences(); - final SmartPointerManager pointerManager = SmartPointerManager.getInstance(project); - final List pointers = new ArrayList(); - for (PsiJavaCodeReferenceElement reference : references) { - final SmartPsiElementPointer pointer = pointerManager.createSmartPsiElementPointer(reference); - pointers.add(pointer); - } - if (referenceImportStatement != null) { - referenceImportStatement.delete(); - } - ImportUtils.addImportIfNeeded(containingClass, referenceElement); - final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project); - final Document document = documentManager.getDocument(containingFile); - if (document == null) { - return; - } - documentManager.doPostponedOperationsAndUnblockDocument(document); - final String text = buildNewText(javaFile, references, containingClass, new StringBuilder()).toString(); - document.replaceString(0, document.getTextLength(), text); - documentManager.commitDocument(document); - if (pointers.size() > 1) { - final List elements = new ArrayList(); - for (SmartPsiElementPointer pointer : pointers) { - elements.add(pointer.getElement()); - } - HighlightUtils.highlightElements(elements); - } + protected String buildErrorString(Object... infos) { + return InspectionGadgetsLocalize.unqualifiedInnerClassAccessProblemDescriptor().get(); } - private static StringBuilder buildNewText(PsiElement element, Collection references, - PsiClass aClass, StringBuilder out) { - if (element == null) { - return out; - } - //noinspection SuspiciousMethodCalls - if (references.contains(element)) { - final String shortClassName = aClass.getName(); - if (isReferenceToTargetClass(shortClassName, aClass, element)) { - out.append(shortClassName); - } - else { - out.append(aClass.getQualifiedName()); - } - out.append('.'); - return out.append(element.getText()); - } - final PsiElement[] children = element.getChildren(); - if (children.length == 0) { - return out.append(element.getText()); - } - for (PsiElement child : children) { - buildNewText(child, references, aClass, out); - } - return out; + @Override + public JComponent createOptionsPanel() { + LocalizeValue message = InspectionGadgetsLocalize.unqualifiedInnerClassAccessOption(); + return new SingleCheckboxOptionsPanel(message.get(), this, "ignoreReferencesToLocalInnerClasses"); } - private static boolean isReferenceToTargetClass(String referenceText, PsiClass targetClass, PsiElement context) { - final PsiManager manager = targetClass.getManager(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); - final PsiResolveHelper resolveHelper = facade.getResolveHelper(); - final PsiClass referencedClass = resolveHelper.resolveReferencedClass(referenceText, context); - if (referencedClass == null) { - return true; - } - return manager.areElementsEquivalent(targetClass, referencedClass); + @Override + protected InspectionGadgetsFix buildFix(Object... infos) { + return new UnqualifiedInnerClassAccessFix(); } - } - private static class ReferenceCollector extends JavaRecursiveElementVisitor { - - private final String name; - private final boolean onDemand; - private final Set references = new HashSet(); + private static class UnqualifiedInnerClassAccessFix extends InspectionGadgetsFix { + @Nonnull + @Override + public LocalizeValue getName() { + return InspectionGadgetsLocalize.unqualifiedInnerClassAccessQuickfix(); + } - ReferenceCollector(String name, boolean onDemand) { - this.name = name; - this.onDemand = onDemand; - } + @Override + protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + final PsiElement element = descriptor.getPsiElement(); + if (!(element instanceof PsiJavaCodeReferenceElement)) { + return; + } + final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) element; + final PsiElement target = referenceElement.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + final PsiClass containingClass = aClass.getContainingClass(); + if (containingClass == null) { + return; + } + final String qualifiedName = containingClass.getQualifiedName(); + if (qualifiedName == null) { + return; + } + final PsiFile containingFile = referenceElement.getContainingFile(); + if (!(containingFile instanceof PsiJavaFile)) { + return; + } + final PsiJavaFile javaFile = (PsiJavaFile) containingFile; + final String innerClassName = aClass.getQualifiedName(); + if (innerClassName == null) { + return; + } + final PsiImportList importList = javaFile.getImportList(); + if (importList == null) { + return; + } + final PsiImportStatement[] importStatements = importList.getImportStatements(); + final int importStatementsLength = importStatements.length; + boolean onDemand = false; + PsiImportStatement referenceImportStatement = null; + for (int i = importStatementsLength - 1; i >= 0; i--) { + final PsiImportStatement importStatement = importStatements[i]; + final String importString = importStatement.getQualifiedName(); + if (importStatement.isOnDemand()) { + if (qualifiedName.equals(importString)) { + referenceImportStatement = importStatement; + onDemand = true; + break; + } + } + else { + if (innerClassName.equals(importString)) { + referenceImportStatement = importStatement; + break; + } + } + } + final ReferenceCollector referenceCollector; + if (onDemand) { + referenceCollector = new ReferenceCollector(qualifiedName, onDemand); + } + else { + referenceCollector = new ReferenceCollector(innerClassName, onDemand); + } + final PsiClass[] classes = javaFile.getClasses(); + for (PsiClass psiClass : classes) { + psiClass.accept(referenceCollector); + } + final Collection references = referenceCollector.getReferences(); + final SmartPointerManager pointerManager = SmartPointerManager.getInstance(project); + final List pointers = new ArrayList(); + for (PsiJavaCodeReferenceElement reference : references) { + final SmartPsiElementPointer pointer = pointerManager.createSmartPsiElementPointer(reference); + pointers.add(pointer); + } + if (referenceImportStatement != null) { + referenceImportStatement.delete(); + } + ImportUtils.addImportIfNeeded(containingClass, referenceElement); + final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project); + final Document document = documentManager.getDocument(containingFile); + if (document == null) { + return; + } + documentManager.doPostponedOperationsAndUnblockDocument(document); + final String text = buildNewText(javaFile, references, containingClass, new StringBuilder()).toString(); + document.replaceString(0, document.getTextLength(), text); + documentManager.commitDocument(document); + if (pointers.size() > 1) { + final List elements = new ArrayList(); + for (SmartPsiElementPointer pointer : pointers) { + elements.add(pointer.getElement()); + } + HighlightUtils.highlightElements(elements); + } + } - @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - if (reference.isQualified()) { - return; - } - final PsiElement target = reference.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - if (!onDemand) { - final String qualifiedName = aClass.getQualifiedName(); - if (name.equals(qualifiedName)) { - references.add(reference); + private static StringBuilder buildNewText( + PsiElement element, + Collection references, + PsiClass aClass, + StringBuilder out + ) { + if (element == null) { + return out; + } + //noinspection SuspiciousMethodCalls + if (references.contains(element)) { + final String shortClassName = aClass.getName(); + if (isReferenceToTargetClass(shortClassName, aClass, element)) { + out.append(shortClassName); + } + else { + out.append(aClass.getQualifiedName()); + } + out.append('.'); + return out.append(element.getText()); + } + final PsiElement[] children = element.getChildren(); + if (children.length == 0) { + return out.append(element.getText()); + } + for (PsiElement child : children) { + buildNewText(child, references, aClass, out); + } + return out; } - return; - } - final PsiClass containingClass = aClass.getContainingClass(); - if (containingClass == null) { - return; - } - final String qualifiedName = containingClass.getQualifiedName(); - if (name.equals(qualifiedName)) { - references.add(reference); - } - } - @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { - visitReferenceElement(expression); + private static boolean isReferenceToTargetClass(String referenceText, PsiClass targetClass, PsiElement context) { + final PsiManager manager = targetClass.getManager(); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); + final PsiResolveHelper resolveHelper = facade.getResolveHelper(); + final PsiClass referencedClass = resolveHelper.resolveReferencedClass(referenceText, context); + if (referencedClass == null) { + return true; + } + return manager.areElementsEquivalent(targetClass, referencedClass); + } } - public Collection getReferences() { - return references; - } - } + private static class ReferenceCollector extends JavaRecursiveElementVisitor { + private final String name; + private final boolean onDemand; + private final Set references = new HashSet(); - @Override - public BaseInspectionVisitor buildVisitor() { - return new UnqualifiedInnerClassAccessVisitor(); - } + ReferenceCollector(String name, boolean onDemand) { + this.name = name; + this.onDemand = onDemand; + } - private class UnqualifiedInnerClassAccessVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + super.visitReferenceElement(reference); + if (reference.isQualified()) { + return; + } + final PsiElement target = reference.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + if (!onDemand) { + final String qualifiedName = aClass.getQualifiedName(); + if (name.equals(qualifiedName)) { + references.add(reference); + } + return; + } + final PsiClass containingClass = aClass.getContainingClass(); + if (containingClass == null) { + return; + } + final String qualifiedName = containingClass.getQualifiedName(); + if (name.equals(qualifiedName)) { + references.add(reference); + } + } - @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - if (reference.isQualified()) { - return; - } - final PsiElement target = reference.resolve(); - if (!(target instanceof PsiClass)) { - return; - } - final PsiClass aClass = (PsiClass)target; - final PsiClass containingClass = aClass.getContainingClass(); - if (containingClass == null) { - return; - } - if (ignoreReferencesToLocalInnerClasses) { - if (PsiTreeUtil.isAncestor(containingClass, reference, true)) { - return; + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + visitReferenceElement(expression); } - final PsiClass referenceClass = PsiTreeUtil.getParentOfType(reference, PsiClass.class); - if (referenceClass != null && referenceClass.isInheritor(containingClass, true)) { - return; + + public Collection getReferences() { + return references; } - } - registerError(reference, containingClass.getName()); } @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { - visitReferenceElement(expression); + public BaseInspectionVisitor buildVisitor() { + return new UnqualifiedInnerClassAccessVisitor(); + } + + private class UnqualifiedInnerClassAccessVisitor extends BaseInspectionVisitor { + @Override + public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { + super.visitReferenceElement(reference); + if (reference.isQualified()) { + return; + } + final PsiElement target = reference.resolve(); + if (!(target instanceof PsiClass)) { + return; + } + final PsiClass aClass = (PsiClass) target; + final PsiClass containingClass = aClass.getContainingClass(); + if (containingClass == null) { + return; + } + if (ignoreReferencesToLocalInnerClasses) { + if (PsiTreeUtil.isAncestor(containingClass, reference, true)) { + return; + } + final PsiClass referenceClass = PsiTreeUtil.getParentOfType(reference, PsiClass.class); + if (referenceClass != null && referenceClass.isInheritor(containingClass, true)) { + return; + } + } + registerError(reference, containingClass.getName()); + } + + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + visitReferenceElement(expression); + } } - } }