(no message)

2026-09-27 10:03:11 +07:00 · 2005-02-17 23:25:07 +03:00
parent 11189187a4
commit efe3fafe44
9 changed files with 535 additions and 0 deletions
@@ -43,6 +43,7 @@ import com.siyeh.ig.style.*;
 import com.siyeh.ig.threading.*;
 import com.siyeh.ig.verbose.*;
 import com.siyeh.ig.visibility.*;
+import com.siyeh.ig.jdk.*;

 import java.io.*;
 import java.util.ArrayList;
@@ -0,0 +1,43 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.ClassInspection;
+import com.siyeh.ig.GroupNames;
+
+public class AnnotationClassInspection extends ClassInspection {
+
+    public String getDisplayName() {
+        return "Annotation class";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Annotation class '#ref' #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new AnnotationClassVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class AnnotationClassVisitor extends BaseInspectionVisitor {
+        private AnnotationClassVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitClass(PsiClass aClass) {
+            if (!aClass.isAnnotationType()) {
+                return;
+            }
+            registerClassError(aClass);
+        }
+
+    }
+
+}
@@ -0,0 +1,67 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.psi.*;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.GroupNames;
+
+public class AnnotationInspection extends BaseInspection {
+
+    public String getDisplayName() {
+        return "Annotation";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public ProblemDescriptor[] checkClass(PsiClass aClass, InspectionManager mgr, boolean isOnTheFly) {
+        if (!aClass.isPhysical()) {
+            return super.checkClass(aClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        aClass.accept(visitor);
+
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkMethod(PsiMethod method, InspectionManager mgr, boolean isOnTheFly) {
+        if (!method.isPhysical()) {
+            return super.checkMethod(method, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        method.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkField(PsiField field, InspectionManager mgr, boolean isOnTheFly) {
+        if (!field.isPhysical()) {
+            return super.checkField(field, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        field.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Annotation '#ref' #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new UnnecessaryInterfaceModifierVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class UnnecessaryInterfaceModifierVisitor extends BaseInspectionVisitor {
+
+        private UnnecessaryInterfaceModifierVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitAnnotation(PsiAnnotation annotation) {
+            super.visitAnnotation(annotation);
+            registerError(annotation);
+        }
+    }
+}
@@ -0,0 +1,123 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.psi.*;
+import com.siyeh.ig.*;
+import com.siyeh.ig.fixes.RenameFix;
+
+public class AssertAsNameInspection extends BaseInspection {
+    private final RenameFix fix = new RenameFix();
+
+    public String getDisplayName() {
+        return "Use of 'assert' as identifier";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Use of '#ref' as identifier #loc";
+    }
+
+    protected InspectionGadgetsFix buildFix(PsiElement location) {
+        return fix;
+    }
+
+    public ProblemDescriptor[] checkClass(PsiClass aClass, InspectionManager mgr, boolean isOnTheFly) {
+        if (aClass instanceof PsiAnonymousClass) {
+            return super.checkClass(aClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        aClass.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkMethod(PsiMethod method, InspectionManager mgr, boolean isOnTheFly) {
+        final PsiClass containingClass = method.getContainingClass();
+        if (containingClass == null) {
+            return super.checkMethod(method, mgr, isOnTheFly);
+        }
+        if (!containingClass.isPhysical()) {
+            return super.checkMethod(method, mgr, isOnTheFly);
+        }
+
+        if (containingClass instanceof PsiAnonymousClass) {
+            return super.checkClass(containingClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        method.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkField(PsiField field, InspectionManager mgr, boolean isOnTheFly) {
+        final PsiClass containingClass = field.getContainingClass();
+        if (containingClass == null) {
+            return super.checkField(field, mgr, isOnTheFly);
+        }
+        if (!containingClass.isPhysical()) {
+            return super.checkField(field, mgr, isOnTheFly);
+        }
+        if (containingClass instanceof PsiAnonymousClass) {
+            return super.checkClass(containingClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        field.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new AssertAsNameVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class AssertAsNameVisitor extends BaseInspectionVisitor {
+        private static final String ASSERT_STRING = "assert";
+
+        private AssertAsNameVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitVariable(PsiVariable variable) {
+            super.visitVariable(variable);
+            final String variableName = variable.getName();
+            if (!ASSERT_STRING.equals(variableName)) {
+                return;
+            }
+            registerVariableError(variable);
+        }
+
+        public void visitMethod(PsiMethod method) {
+            super.visitMethod(method);
+            final String name = method.getName();
+            if (!ASSERT_STRING.equals(name)) {
+                return;
+            }
+            registerMethodError(method);
+        }
+
+        public void visitClass(PsiClass aClass) {
+            //note: no call to super, to avoid drill-down
+            final String name = aClass.getName();
+            if (!ASSERT_STRING.equals(name)) {
+                return;
+            }
+            final PsiTypeParameterList params = aClass.getTypeParameterList();
+            if (params != null) {
+                params.accept(this);
+            }
+            registerClassError(aClass);
+        }
+
+
+        public void visitTypeParameter(PsiTypeParameter parameter) {
+            super.visitTypeParameter(parameter);
+            final String name = parameter.getName();
+            if (!ASSERT_STRING.equals(name)) {
+                return;
+            }
+            registerTypeParameterError(parameter);
+        }
+    }
+
+}
@@ -0,0 +1,41 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.psi.PsiAssertStatement;
+import com.intellij.psi.PsiElement;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.GroupNames;
+import com.siyeh.ig.StatementInspection;
+
+public class AssertStatementInspection extends StatementInspection {
+
+    public String getDisplayName() {
+        return "'assert' statement";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "'#ref' statement #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new AssertStatementVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class AssertStatementVisitor extends BaseInspectionVisitor {
+        private AssertStatementVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitAssertStatement(PsiAssertStatement statement) {
+            super.visitAssertStatement(statement);
+            registerStatementError(statement);
+        }
+
+    }
+
+}
@@ -0,0 +1,124 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.psi.*;
+import com.siyeh.ig.*;
+import com.siyeh.ig.fixes.RenameFix;
+
+public class EnumAsNameInspection extends BaseInspection {
+    private static final String ENUM_STRING = "enum";
+
+    private final RenameFix fix = new RenameFix();
+
+    public String getDisplayName() {
+        return "Use of 'enum' as identifier";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Use of '#ref' as identifier #loc";
+    }
+
+    protected InspectionGadgetsFix buildFix(PsiElement location) {
+        return fix;
+    }
+
+    public ProblemDescriptor[] checkClass(PsiClass aClass, InspectionManager mgr, boolean isOnTheFly) {
+        if (aClass instanceof PsiAnonymousClass) {
+            return super.checkClass(aClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        aClass.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkMethod(PsiMethod method, InspectionManager mgr, boolean isOnTheFly) {
+        final PsiClass containingClass = method.getContainingClass();
+        if (containingClass == null) {
+            return super.checkMethod(method, mgr, isOnTheFly);
+        }
+        if (!containingClass.isPhysical()) {
+            return super.checkMethod(method, mgr, isOnTheFly);
+        }
+
+        if (containingClass instanceof PsiAnonymousClass) {
+            return super.checkClass(containingClass, mgr, isOnTheFly);
+        }
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        method.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public ProblemDescriptor[] checkField(PsiField field, InspectionManager mgr, boolean isOnTheFly) {
+        final PsiClass containingClass = field.getContainingClass();
+        if (containingClass == null) {
+            return super.checkField(field, mgr, isOnTheFly);
+        }
+        if (!containingClass.isPhysical()) {
+            return super.checkField(field, mgr, isOnTheFly);
+        }
+        if (containingClass instanceof PsiAnonymousClass) {
+            return super.checkClass(containingClass, mgr, isOnTheFly);
+        }
+
+        final BaseInspectionVisitor visitor = createVisitor(mgr, isOnTheFly);
+        field.accept(visitor);
+        return visitor.getErrors();
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new EnumAsNameVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class EnumAsNameVisitor extends BaseInspectionVisitor {
+
+        private EnumAsNameVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitVariable(PsiVariable variable) {
+            super.visitVariable(variable);
+            final String variableName = variable.getName();
+            if (!ENUM_STRING.equals(variableName)) {
+                return;
+            }
+            registerVariableError(variable);
+        }
+
+        public void visitMethod(PsiMethod method) {
+            super.visitMethod(method);
+            final String name = method.getName();
+            if (!ENUM_STRING.equals(name)) {
+                return;
+            }
+            registerMethodError(method);
+        }
+
+        public void visitClass(PsiClass aClass) {
+            //note: no call to super, to avoid drill-down
+            final String name = aClass.getName();
+            if (!ENUM_STRING.equals(name)) {
+                return;
+            }
+            final PsiTypeParameterList params = aClass.getTypeParameterList();
+            if (params != null) {
+                params.accept(this);
+            }
+            registerClassError(aClass);
+        }
+
+        public void visitTypeParameter(PsiTypeParameter parameter) {
+            super.visitTypeParameter(parameter);
+            final String name = parameter.getName();
+            if (!ENUM_STRING.equals(name)) {
+                return;
+            }
+            registerTypeParameterError(parameter);
+        }
+    }
+
+}
@@ -0,0 +1,43 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.ClassInspection;
+import com.siyeh.ig.GroupNames;
+
+public class EnumClassInspection extends ClassInspection {
+
+    public String getDisplayName() {
+        return "Enumerated class";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Enumerated class '#ref' #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new EnumClassVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class EnumClassVisitor extends BaseInspectionVisitor {
+        private EnumClassVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitClass(PsiClass aClass) {
+            if (!aClass.isEnum()) {
+                return;
+            }
+            registerClassError(aClass);
+        }
+
+    }
+
+}
@@ -0,0 +1,39 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiForeachStatement;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.GroupNames;
+import com.siyeh.ig.StatementInspection;
+
+public class ForeachStatementInspection extends StatementInspection {
+
+    public String getDisplayName() {
+        return "Extended 'for' statement";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "'Extended #ref' statement #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new ForeachStatementVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class ForeachStatementVisitor extends BaseInspectionVisitor {
+        private ForeachStatementVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitForeachStatement(PsiForeachStatement statement) {
+            super.visitForeachStatement(statement);
+            registerStatementError(statement);
+        }
+    }
+}
@@ -0,0 +1,54 @@
+package com.siyeh.ig.jdk;
+
+import com.intellij.codeInspection.InspectionManager;
+import com.intellij.psi.*;
+import com.siyeh.ig.BaseInspection;
+import com.siyeh.ig.BaseInspectionVisitor;
+import com.siyeh.ig.GroupNames;
+import com.siyeh.ig.StatementInspection;
+
+public class VarargParameterInspection extends StatementInspection {
+
+    public String getDisplayName() {
+        return "Variable argument method";
+    }
+
+    public String getGroupDisplayName() {
+        return GroupNames.JDK_GROUP_NAME;
+    }
+
+    public String buildErrorString(PsiElement location) {
+        return "Variable argument method '#ref' #loc";
+    }
+
+    public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) {
+        return new VarargParameterVisitor(this, inspectionManager, onTheFly);
+    }
+
+    private static class VarargParameterVisitor extends BaseInspectionVisitor {
+        private VarargParameterVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) {
+            super(inspection, inspectionManager, isOnTheFly);
+        }
+
+        public void visitMethod(PsiMethod method) {
+            super.visitMethod(method);
+            final PsiParameterList parameterList = method.getParameterList();
+            if (parameterList == null) {
+                return;
+            }
+            final PsiParameter[] parameters = parameterList.getParameters();
+            if (parameters == null) {
+                return;
+            }
+            for (int i = 0; i < parameters.length; i++) {
+                final PsiParameter parameter = parameters[i];
+                if (parameter.isVarArgs()) {
+                    registerMethodError(method);
+                    return;
+                }
+            }
+        }
+
+    }
+
+}