diff options
Diffstat (limited to 'plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com')
17 files changed, 455 insertions, 154 deletions
diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/InspectionGadgetsBundle.properties b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/InspectionGadgetsBundle.properties index 1dfdfb9eb50a..1df72421fd4d 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/InspectionGadgetsBundle.properties +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/InspectionGadgetsBundle.properties @@ -1741,6 +1741,7 @@ ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor=JUnit 3 ignore.test.method.in.class.extending.junit3.testcase.quickfix=Remove ''@Ignore'' and rename method to ''{0}'' convert.junit3.test.class.quickfix=Convert JUnit 3 class ''{0}'' to JUnit 4 remove.junit4.test.annotation.quickfix=Remove '@Test' annotation +remove.junit4.test.annotation.and.rename.quickfix=Remove '@Test' annotation and rename to ''{0}'' equals.called.on.enum.constant.display.name='equals()' called on Enum value equals.called.on.enum.constant.problem.descriptor=<code>#ref()</code> called on Enum value #loc equals.called.on.enum.constant.quickfix=Replace 'equals()' with '==' @@ -2100,3 +2101,13 @@ assignment.to.lambda.parameter.problem.descriptor=Assignment to lambda parameter class.with.only.private.constructors.display.name=Class with only 'private' constructors should be declared 'final' class.with.only.private.constructors.problem.descriptor=Class <code>#ref</code> with only 'private' constructors should be declared 'final' property.value.set.to.itself.display.name=Property value set to itself +equals.with.itself.display.name='equals()' called on itself +equals.with.itself.problem.descriptor=Identical qualifier and argument to <code>#ref()</code> call +junit4.method.naming.convention.display.name=JUnit 4 test method naming convention +junit4.method.naming.convention.problem.descriptor.short=JUnit 4 test method name <code>#ref</code> is too short ({0} < {1}) #loc +junit4.method.naming.convention.problem.descriptor.long=JUnit 4 test method name <code>#ref</code> is too long ({0} > {1}) #loc +junit4.method.naming.convention.problem.descriptor.regex.mismatch=JUnit 4 test method name <code>#ref</code> doesn''t match regex ''{0}'' #loc +junit3.method.naming.convention.display.name=JUnit 3 test method naming convention +junit3.method.naming.convention.problem.descriptor.short=JUnit 3 test method name <code>#ref</code> is too short ({0} < {1}) #loc +junit3.method.naming.convention.problem.descriptor.long=JUnit 3 test method name <code>#ref</code> is too long ({0} > {1}) #loc +junit3.method.naming.convention.problem.descriptor.regex.mismatch=JUnit 3 test method name <code>#ref</code> doesn''t match regex ''{0}'' #loc diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/TypeMayBeWeakenedInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/TypeMayBeWeakenedInspection.java index bf23939f2c86..2787f34e4dcf 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/TypeMayBeWeakenedInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/TypeMayBeWeakenedInspection.java @@ -21,7 +21,6 @@ import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.util.Query; import com.siyeh.InspectionGadgetsBundle; @@ -64,9 +63,9 @@ public class TypeMayBeWeakenedInspection extends BaseInspection { @NonNls final StringBuilder builder = new StringBuilder(); final Iterator<PsiClass> iterator = weakerClasses.iterator(); if (iterator.hasNext()) { - builder.append('\'').append(iterator.next().getQualifiedName()).append('\''); + builder.append('\'').append(getClassName(iterator.next())).append('\''); while (iterator.hasNext()) { - builder.append(", '").append(iterator.next().getQualifiedName()).append('\''); + builder.append(", '").append(getClassName(iterator.next())).append('\''); } } final Object info = infos[0]; @@ -85,6 +84,14 @@ public class TypeMayBeWeakenedInspection extends BaseInspection { return InspectionGadgetsBundle.message("type.may.be.weakened.problem.descriptor", builder.toString()); } + private static String getClassName(PsiClass aClass) { + final String qualifiedName = aClass.getQualifiedName(); + if (qualifiedName == null) { + return aClass.getName(); + } + return qualifiedName; + } + @Override @Nullable public JComponent createOptionsPanel() { @@ -106,11 +113,11 @@ public class TypeMayBeWeakenedInspection extends BaseInspection { final Iterable<PsiClass> weakerClasses = (Iterable<PsiClass>)infos[1]; final Collection<InspectionGadgetsFix> fixes = new ArrayList(); for (PsiClass weakestClass : weakerClasses) { - final String qualifiedName = weakestClass.getQualifiedName(); - if (qualifiedName == null) { + final String className = getClassName(weakestClass); + if (className == null) { continue; } - fixes.add(new TypeMayBeWeakenedFix(qualifiedName)); + fixes.add(new TypeMayBeWeakenedFix(className)); } return fixes.toArray(new InspectionGadgetsFix[fixes.size()]); } @@ -162,31 +169,30 @@ public class TypeMayBeWeakenedInspection extends BaseInspection { if (!(oldType instanceof PsiClassType)) { return; } - final PsiClassType classType = (PsiClassType)oldType; - final PsiType[] parameterTypes = classType.getParameters(); - final GlobalSearchScope scope = element.getResolveScope(); + final PsiClassType oldClassType = (PsiClassType)oldType; + final PsiType[] parameterTypes = oldClassType.getParameters(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass aClass = facade.findClass(fqClassName, scope); - if (aClass == null) { + final PsiElementFactory factory = facade.getElementFactory(); + final PsiType type = factory.createTypeFromText(fqClassName, element); + if (!(type instanceof PsiClassType)) { return; } - final PsiTypeParameter[] typeParameters = aClass.getTypeParameters(); - final PsiElementFactory factory = facade.getElementFactory(); - final PsiClassType type; - if (typeParameters.length != 0 && typeParameters.length == parameterTypes.length) { - final Map<PsiTypeParameter, PsiType> typeParameterMap = new HashMap(); - for (int i = 0; i < typeParameters.length; i++) { - final PsiTypeParameter typeParameter = typeParameters[i]; - final PsiType parameterType = parameterTypes[i]; - typeParameterMap.put(typeParameter, parameterType); + PsiClassType classType = (PsiClassType)type; + final PsiClass aClass = classType.resolve(); + if (aClass != null) { + final PsiTypeParameter[] typeParameters = aClass.getTypeParameters(); + if (typeParameters.length != 0 && typeParameters.length == parameterTypes.length) { + final Map<PsiTypeParameter, PsiType> typeParameterMap = new HashMap(); + for (int i = 0; i < typeParameters.length; i++) { + final PsiTypeParameter typeParameter = typeParameters[i]; + final PsiType parameterType = parameterTypes[i]; + typeParameterMap.put(typeParameter, parameterType); + } + final PsiSubstitutor substitutor = factory.createSubstitutor(typeParameterMap); + classType = factory.createType(aClass, substitutor); } - final PsiSubstitutor substitutor = factory.createSubstitutor(typeParameterMap); - type = factory.createType(aClass, substitutor); - } - else { - type = factory.createTypeByFQClassName(fqClassName, scope); } - final PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType(type); + final PsiJavaCodeReferenceElement referenceElement = factory.createReferenceElementByType(classType); final PsiElement replacement = componentReferenceElement.replace(referenceElement); final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); javaCodeStyleManager.shortenClassReferences(replacement); diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/EqualsWithItselfInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/EqualsWithItselfInspection.java new file mode 100644 index 000000000000..698ace189a6b --- /dev/null +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/EqualsWithItselfInspection.java @@ -0,0 +1,78 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.siyeh.ig.bugs; + +import com.intellij.psi.PsiExpression; +import com.intellij.psi.PsiExpressionList; +import com.intellij.psi.PsiMethodCallExpression; +import com.intellij.psi.PsiReferenceExpression; +import com.siyeh.InspectionGadgetsBundle;import com.siyeh.ig.BaseInspection; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.psiutils.EquivalenceChecker; +import com.siyeh.ig.psiutils.MethodCallUtils; +import com.siyeh.ig.psiutils.SideEffectChecker; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; + +/** + * @author Bas Leijdekkers + */ +public class EqualsWithItselfInspection extends BaseInspection { + @Nls + @NotNull + @Override + public String getDisplayName() { + return InspectionGadgetsBundle.message("equals.with.itself.display.name"); + } + + @NotNull + @Override + protected String buildErrorString(Object... infos) { + return InspectionGadgetsBundle.message("equals.with.itself.problem.descriptor"); + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new EqualsWithIfSelfVisitor(); + } + + private static class EqualsWithIfSelfVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethodCallExpression(PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + if (!MethodCallUtils.isEqualsCall(expression)) { + return; + } + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier == null) { + return; + } + final PsiExpressionList argumentList = expression.getArgumentList(); + final PsiExpression[] arguments = argumentList.getExpressions(); + if (arguments.length != 1) { + return; + } + final PsiExpression argument = arguments[0]; + if (!EquivalenceChecker.expressionsAreEquivalent(qualifier, argument) || + SideEffectChecker.mayHaveSideEffects(qualifier)) { + return; + } + registerMethodCallError(expression); + } + } +} diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/StaticInheritanceFix.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/StaticInheritanceFix.java index 1289bbdbe694..c24de84ba1ea 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/StaticInheritanceFix.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/StaticInheritanceFix.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,6 +30,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Computable; import com.intellij.psi.*; import com.intellij.psi.impl.DebugUtil; +import com.intellij.psi.search.SearchScope; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.PsiTreeUtil; @@ -91,7 +92,13 @@ class StaticInheritanceFix extends InspectionGadgetsFix { @Override public void run(@NotNull ProgressIndicator indicator) { for (final PsiField field : allFields) { - final Query<PsiReference> search = ReferencesSearch.search(field, implementingClass.getUseScope(), false); + SearchScope scope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() { + @Override + public SearchScope compute() { + return implementingClass.getUseScope(); + } + }); + final Query<PsiReference> search = ReferencesSearch.search(field, scope, false); for (PsiReference reference : search) { if (!(reference instanceof PsiReferenceExpression)) { continue; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3MethodNamingConventionInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3MethodNamingConventionInspectionBase.java new file mode 100644 index 000000000000..8f27342d8d2b --- /dev/null +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3MethodNamingConventionInspectionBase.java @@ -0,0 +1,102 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.siyeh.ig.junit; + +import com.intellij.psi.PsiIdentifier; +import com.intellij.psi.PsiMethod; +import com.siyeh.InspectionGadgetsBundle; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.naming.ConventionInspection; +import com.siyeh.ig.psiutils.LibraryUtil; +import com.siyeh.ig.psiutils.MethodUtils; +import com.siyeh.ig.psiutils.TestUtils; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; + +/** + * @author Bas Leijdekkers + */ +public class JUnit3MethodNamingConventionInspectionBase extends ConventionInspection { + + @Nls + @NotNull + @Override + public String getDisplayName() { + return InspectionGadgetsBundle.message("junit3.method.naming.convention.display.name"); + } + + @Override + @NotNull + public String buildErrorString(Object... infos) { + final String methodName = (String)infos[0]; + final int length = methodName.length(); + if (length < getMinLength()) { + return InspectionGadgetsBundle.message("junit3.method.naming.convention.problem.descriptor.short", + Integer.valueOf(length), Integer.valueOf(getMinLength())); + } + else if (length > getMaxLength()) { + return InspectionGadgetsBundle.message("junit3.method.naming.convention.problem.descriptor.long", + Integer.valueOf(length), Integer.valueOf(getMaxLength())); + } + return InspectionGadgetsBundle.message("junit3.method.naming.convention.problem.descriptor.regex.mismatch", getRegex()); + } + + @Override + protected String getDefaultRegex() { + return "test[A-Za-z_\\d]*"; + } + + @Override + protected int getDefaultMinLength() { + return 8; + } + + @Override + protected int getDefaultMaxLength() { + return 64; + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new JUnit3MethodNamingConventionVisitor(); + } + + private class JUnit3MethodNamingConventionVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + if (!TestUtils.isJUnit3TestMethod(method) || !TestUtils.isRunnable(method)) { + return; + } + final PsiIdentifier nameIdentifier = method.getNameIdentifier(); + if (nameIdentifier == null) { + return; + } + final String name = method.getName(); + if (isValid(name)) { + return; + } + if (!isOnTheFly() && MethodUtils.hasSuper(method)) { + return; + } + if (LibraryUtil.isOverrideOfLibraryMethod(method)) { + return; + } + registerMethodError(method, name); + } + } +} diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3StyleTestMethodInJUnit4ClassInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3StyleTestMethodInJUnit4ClassInspection.java index 8a6ebeff68ce..c39865049e95 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3StyleTestMethodInJUnit4ClassInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit3StyleTestMethodInJUnit4ClassInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,6 +25,7 @@ import com.siyeh.ig.DelegatingFix; import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.psiutils.TestUtils; import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -71,70 +72,45 @@ public class JUnit3StyleTestMethodInJUnit4ClassInspection extends BaseInspection if (!name.startsWith("test")) { return; } - if (method.hasModifierProperty(PsiModifier.ABSTRACT) || !method.hasModifierProperty(PsiModifier.PUBLIC)) { + if (!TestUtils.isRunnable(method)) { return; } if (TestUtils.isJUnit4TestMethod(method)) { return; } - final PsiType returnType = method.getReturnType(); - if (returnType == null || !returnType.equals(PsiType.VOID)) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() != 0) { - return; - } final PsiClass containingClass = method.getContainingClass(); if (TestUtils.isJUnitTestClass(containingClass)) { return; } - if (!containsReferenceToClass(containingClass, "org.junit.Test")) { + if (!containsJUnit4Annotation(containingClass)) { return; } registerMethodError(method); } } - public static boolean containsReferenceToClass(PsiElement element, String fullyQualifiedName) { - final ClassReferenceVisitor visitor = new ClassReferenceVisitor(fullyQualifiedName); + public static boolean containsJUnit4Annotation(PsiElement element) { + final JUnit4AnnotationVisitor visitor = new JUnit4AnnotationVisitor(); element.accept(visitor); - return visitor.isReferenceFound(); + return visitor.isJUnit4AnnotationFound(); } - private static class ClassReferenceVisitor extends JavaRecursiveElementVisitor { - - private final String fullyQualifiedName; - private boolean referenceFound = false; + private static class JUnit4AnnotationVisitor extends JavaRecursiveElementWalkingVisitor { - private ClassReferenceVisitor(String fullyQualifiedName) { - this.fullyQualifiedName = fullyQualifiedName; - } + private boolean myJUnit4AnnotationFound = false; @Override - public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - if (referenceFound) { - return; - } - if (!(reference.getParent() instanceof PsiAnnotation)) { - // optimization - return; - } - final PsiElement element = reference.resolve(); - if (!(element instanceof PsiClass) || element instanceof PsiTypeParameter) { - return; - } - final PsiClass aClass = (PsiClass)element; - final String classQualifiedName = aClass.getQualifiedName(); - if (classQualifiedName == null || !classQualifiedName.equals(fullyQualifiedName)) { + public void visitAnnotation(PsiAnnotation annotation) { + super.visitAnnotation(annotation); + @NonNls final String qualifiedName = annotation.getQualifiedName(); + if (qualifiedName == null || !qualifiedName.startsWith("org.junit.")) { return; } - referenceFound = true; + myJUnit4AnnotationFound = true; } - public boolean isReferenceFound() { - return referenceFound; + public boolean isJUnit4AnnotationFound() { + return myJUnit4AnnotationFound; } } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit4MethodNamingConventionInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit4MethodNamingConventionInspectionBase.java new file mode 100644 index 000000000000..eb0f3d7b91c7 --- /dev/null +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/JUnit4MethodNamingConventionInspectionBase.java @@ -0,0 +1,102 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.siyeh.ig.junit; + +import com.intellij.psi.PsiIdentifier; +import com.intellij.psi.PsiMethod; +import com.siyeh.InspectionGadgetsBundle; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.naming.ConventionInspection; +import com.siyeh.ig.psiutils.LibraryUtil; +import com.siyeh.ig.psiutils.MethodUtils; +import com.siyeh.ig.psiutils.TestUtils; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; + +/** + * @author Bas Leijdekkers + */ +public class JUnit4MethodNamingConventionInspectionBase extends ConventionInspection { + + @Nls + @NotNull + @Override + public String getDisplayName() { + return InspectionGadgetsBundle.message("junit4.method.naming.convention.display.name"); + } + + @Override + @NotNull + public String buildErrorString(Object... infos) { + final String methodName = (String)infos[0]; + final int length = methodName.length(); + if (length < getMinLength()) { + return InspectionGadgetsBundle.message("junit4.method.naming.convention.problem.descriptor.short", + Integer.valueOf(length), Integer.valueOf(getMinLength())); + } + else if (length > getMaxLength()) { + return InspectionGadgetsBundle.message("junit4.method.naming.convention.problem.descriptor.long", + Integer.valueOf(length), Integer.valueOf(getMaxLength())); + } + return InspectionGadgetsBundle.message("junit4.method.naming.convention.problem.descriptor.regex.mismatch", getRegex()); + } + + @Override + protected String getDefaultRegex() { + return "[a-z][A-Za-z_\\d]*"; + } + + @Override + protected int getDefaultMinLength() { + return 4; + } + + @Override + protected int getDefaultMaxLength() { + return 64; + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new JUnit4MethodNamingConventionVisitor(); + } + + private class JUnit4MethodNamingConventionVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethod(PsiMethod method) { + super.visitMethod(method); + if (!TestUtils.isJUnit4TestMethod(method) || !TestUtils.isRunnable(method)) { + return; + } + final PsiIdentifier nameIdentifier = method.getNameIdentifier(); + if (nameIdentifier == null) { + return; + } + final String name = method.getName(); + if (isValid(name)) { + return; + } + if (!isOnTheFly() && MethodUtils.hasSuper(method)) { + return; + } + if (LibraryUtil.isOverrideOfLibraryMethod(method)) { + return; + } + registerMethodError(method, name); + } + } +} diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/TestMethodIsPublicVoidNoArgInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/TestMethodIsPublicVoidNoArgInspection.java index 02d8cd5b7c8e..4b9a794a143a 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/TestMethodIsPublicVoidNoArgInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/TestMethodIsPublicVoidNoArgInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2011 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,14 +15,14 @@ */ package com.siyeh.ig.junit; -import com.intellij.codeInsight.AnnotationUtil; -import com.intellij.psi.*; -import com.intellij.psi.util.InheritanceUtil; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiParameterList; +import com.intellij.psi.PsiType; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.psiutils.TestUtils; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; public class TestMethodIsPublicVoidNoArgInspection extends BaseInspection { @@ -70,23 +70,20 @@ public class TestMethodIsPublicVoidNoArgInspection extends BaseInspection { @Override public void visitMethod(@NotNull PsiMethod method) { //note: no call to super; - @NonNls final String methodName = method.getName(); - if (!methodName.startsWith("test") && - !TestUtils.isJUnit4TestMethod(method)) { + if (method.isConstructor()) { return; } - final PsiType returnType = method.getReturnType(); - if (returnType == null) { + if (!TestUtils.isJUnit3TestMethod(method) && !TestUtils.isJUnit4TestMethod(method)) { return; } + final PsiType returnType = method.getReturnType(); final PsiParameterList parameterList = method.getParameterList(); final boolean takesArguments; final boolean isStatic; if (parameterList.getParametersCount() == 0) { takesArguments = false; isStatic = method.hasModifierProperty(PsiModifier.STATIC); - if (!isStatic && returnType.equals(PsiType.VOID) && - method.hasModifierProperty(PsiModifier.PUBLIC)) { + if (!isStatic && PsiType.VOID.equals(returnType) && method.hasModifierProperty(PsiModifier.PUBLIC)) { return; } } @@ -94,14 +91,6 @@ public class TestMethodIsPublicVoidNoArgInspection extends BaseInspection { isStatic = false; takesArguments = true; } - final PsiClass targetClass = method.getContainingClass(); - if (!AnnotationUtil.isAnnotated(method, "org.junit.Test", true)) { - if (targetClass == null || - !InheritanceUtil.isInheritor(targetClass, - "junit.framework.TestCase")) { - return; - } - } registerMethodError(method, Boolean.valueOf(takesArguments), Boolean.valueOf(isStatic)); } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/InstanceMethodNamingConventionInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/InstanceMethodNamingConventionInspectionBase.java index 3ec38f55053c..964ce0b0aace 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/InstanceMethodNamingConventionInspectionBase.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/InstanceMethodNamingConventionInspectionBase.java @@ -15,25 +15,22 @@ */ package com.siyeh.ig.naming; +import com.intellij.openapi.extensions.Extensions; import com.intellij.psi.PsiIdentifier; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; -import com.intellij.util.ui.CheckBox; +import com.intellij.testIntegration.TestFramework; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.psiutils.LibraryUtil; import com.siyeh.ig.psiutils.MethodUtils; +import com.siyeh.ig.psiutils.TestUtils; import org.jetbrains.annotations.NotNull; -import javax.swing.*; - public class InstanceMethodNamingConventionInspectionBase extends ConventionInspection { private static final int DEFAULT_MIN_LENGTH = 4; private static final int DEFAULT_MAX_LENGTH = 32; - @SuppressWarnings("PublicField") - public boolean ignoreNativeMethods = true; - @Override @NotNull public String getDisplayName() { @@ -59,13 +56,6 @@ public class InstanceMethodNamingConventionInspectionBase extends ConventionInsp } @Override - public JComponent[] createExtraOptions() { - return new JComponent[] { - new CheckBox("ignore 'native' methods", this, "ignoreNativeMethods") - }; - } - - @Override protected String getDefaultRegex() { return "[a-z][A-Za-z\\d]*"; } @@ -80,6 +70,16 @@ public class InstanceMethodNamingConventionInspectionBase extends ConventionInsp return DEFAULT_MAX_LENGTH; } + private static boolean isTestNGTestMethod(PsiMethod method) { + final TestFramework[] testFrameworks = Extensions.getExtensions(TestFramework.EXTENSION_NAME); + for (TestFramework framework : testFrameworks) { + if ("TestNG".equals(framework.getName())) { + return framework.isTestMethod(method); + } + } + return false; + } + @Override public BaseInspectionVisitor buildVisitor() { return new NamingConventionsVisitor(); @@ -93,13 +93,24 @@ public class InstanceMethodNamingConventionInspectionBase extends ConventionInsp if (method.isConstructor() || method.hasModifierProperty(PsiModifier.STATIC)) { return; } - if (ignoreNativeMethods && method.hasModifierProperty(PsiModifier.NATIVE)) { + if (method.hasModifierProperty(PsiModifier.NATIVE) && isInspectionEnabled("NativeMethodNamingConvention", method)) { return; } final PsiIdentifier nameIdentifier = method.getNameIdentifier(); if (nameIdentifier == null) { return; } + if (TestUtils.isRunnable(method)) { + if (TestUtils.isJUnit4TestMethod(method) && isInspectionEnabled("JUnit4MethodNamingConvention", method)) { + return; + } + if (TestUtils.isJUnit3TestMethod(method) && isInspectionEnabled("JUnit3MethodNamingConvention", method)) { + return; + } + } + if (isTestNGTestMethod(method) && isInspectionEnabled("TestNGMethodNamingConvention", method)) { + return; + } final String name = method.getName(); if (isValid(name)) { return; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/NativeMethodNamingConventionInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/NativeMethodNamingConventionInspectionBase.java index a8ceb11a11b1..2231fa152678 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/NativeMethodNamingConventionInspectionBase.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/NativeMethodNamingConventionInspectionBase.java @@ -77,7 +77,7 @@ public class NativeMethodNamingConventionInspectionBase extends ConventionInspec @Override public void visitMethod(@NotNull PsiMethod method) { super.visitMethod(method); - if (method.isConstructor() || method.hasModifierProperty(PsiModifier.STATIC)) { + if (method.isConstructor()) { return; } if (!method.hasModifierProperty(PsiModifier.NATIVE)) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/StaticMethodNamingConventionInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/StaticMethodNamingConventionInspectionBase.java index 116d2208e452..3e0d08998ec0 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/StaticMethodNamingConventionInspectionBase.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/naming/StaticMethodNamingConventionInspectionBase.java @@ -17,20 +17,14 @@ package com.siyeh.ig.naming; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; -import com.intellij.util.ui.CheckBox; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspectionVisitor; import org.jetbrains.annotations.NotNull; -import javax.swing.*; - public class StaticMethodNamingConventionInspectionBase extends ConventionInspection { private static final int DEFAULT_MIN_LENGTH = 4; private static final int DEFAULT_MAX_LENGTH = 32; - @SuppressWarnings("PublicField") - public boolean ignoreNativeMethods = true; - @Override @NotNull public String getDisplayName() { @@ -61,13 +55,6 @@ public class StaticMethodNamingConventionInspectionBase extends ConventionInspec } @Override - public JComponent[] createExtraOptions() { - return new JComponent[]{ - new CheckBox("ignore 'native' methods", this, "ignoreNativeMethods") - }; - } - - @Override protected String getDefaultRegex() { return "[a-z][A-Za-z\\d]*"; } @@ -95,7 +82,7 @@ public class StaticMethodNamingConventionInspectionBase extends ConventionInspec if (!method.hasModifierProperty(PsiModifier.STATIC)) { return; } - if (ignoreNativeMethods && method.hasModifierProperty(PsiModifier.NATIVE)) { + if (method.hasModifierProperty(PsiModifier.NATIVE) && isInspectionEnabled("NativeMethodNamingConvention", method)) { return; } final String name = method.getName(); diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/PointlessArithmeticExpressionInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/PointlessArithmeticExpressionInspection.java index 023b4bc9f949..2dde6969545d 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/PointlessArithmeticExpressionInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/PointlessArithmeticExpressionInspection.java @@ -29,6 +29,7 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.ig.PsiReplacementUtil; import com.siyeh.ig.psiutils.EquivalenceChecker; import com.siyeh.ig.psiutils.ExpressionUtils; +import com.siyeh.ig.psiutils.SideEffectChecker; import gnu.trove.THashSet; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -232,7 +233,7 @@ public class PointlessArithmeticExpressionInspection for (int i = 0; i < expressions.length; i++) { PsiExpression expression = expressions[i]; if (previousExpression != null && - (isZero(expression) || i == 1 && EquivalenceChecker.expressionsAreEquivalent(previousExpression, expression))) { + (isZero(expression) || areExpressionsIdenticalWithoutSideEffects(previousExpression, expression, i))) { return true; } previousExpression = expression; @@ -260,9 +261,10 @@ public class PointlessArithmeticExpressionInspection private boolean divideExpressionIsPointless(PsiExpression[] expressions) { PsiExpression previousExpression = null; - for (PsiExpression expression : expressions) { + for (int i = 0; i < expressions.length; i++) { + final PsiExpression expression = expressions[i]; if (previousExpression != null && - (isOne(expression) || EquivalenceChecker.expressionsAreEquivalent(previousExpression, expression))) { + (isOne(expression) || areExpressionsIdenticalWithoutSideEffects(previousExpression, expression, i))) { return true; } previousExpression = expression; @@ -272,15 +274,21 @@ public class PointlessArithmeticExpressionInspection private boolean modExpressionIsPointless(PsiExpression[] expressions) { PsiExpression previousExpression = null; - for (PsiExpression expression : expressions) { + for (int i = 0; i < expressions.length; i++) { + final PsiExpression expression = expressions[i]; if (previousExpression != null && - (isOne(expression) || EquivalenceChecker.expressionsAreEquivalent(previousExpression, expression))) { + (isOne(expression) || areExpressionsIdenticalWithoutSideEffects(previousExpression, expression, i))) { return true; } previousExpression = expression; } return false; } + + private boolean areExpressionsIdenticalWithoutSideEffects(PsiExpression expression1, PsiExpression expression2, int index) { + return index == 1 && EquivalenceChecker.expressionsAreEquivalent(expression1, expression2) && + !SideEffectChecker.mayHaveSideEffects(expression1); + } } boolean isZero(PsiExpression expression) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java index 9b4a3a832913..7bfaae8cc722 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java @@ -67,6 +67,9 @@ public class ImportUtils { !hasDefaultImportConflict(qualifiedName, javaFile) && !hasOnDemandImportConflict(qualifiedName, javaFile)) { return; } + if (hasExactImportConflict(qualifiedName, javaFile)) { + return; + } final Project project = importList.getProject(); final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); final PsiElementFactory elementFactory = psiFacade.getElementFactory(); @@ -156,7 +159,7 @@ public class ImportUtils { return false; } - private static boolean hasExactImportConflict(String fqName, PsiJavaFile file) { + public static boolean hasExactImportConflict(String fqName, PsiJavaFile file) { final PsiImportList imports = file.getImportList(); if (imports == null) { return false; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InheritanceUtil.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InheritanceUtil.java index 9661ba10e4c4..faea625f1db5 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InheritanceUtil.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InheritanceUtil.java @@ -15,6 +15,7 @@ */ package com.siyeh.ig.psiutils; +import com.intellij.codeInspection.inheritance.ImplementedAtRuntimeCondition; import com.intellij.openapi.progress.ProgressManager; import com.intellij.psi.CommonClassNames; import com.intellij.psi.PsiClass; @@ -80,6 +81,11 @@ public class InheritanceUtil { public static boolean hasImplementation(@NotNull PsiClass aClass) { final SearchScope scope = GlobalSearchScope.projectScope(aClass.getProject()); if (aClass.isInterface() && FunctionalExpressionSearch.search(aClass, scope).findFirst() != null) return true; + for (ImplementedAtRuntimeCondition condition : ImplementedAtRuntimeCondition.EP_NAME.getExtensions()) { + if (condition.isImplementedAtRuntime(aClass)) { + return true; + } + } final Query<PsiClass> search = ClassInheritorsSearch.search(aClass, scope, true, true); return !search.forEach(new Processor<PsiClass>() { @Override diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/SideEffectChecker.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/SideEffectChecker.java index 5063ef7c2ea7..782b667469af 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/SideEffectChecker.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/SideEffectChecker.java @@ -17,6 +17,7 @@ package com.siyeh.ig.psiutils; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; +import com.intellij.psi.util.PropertyUtil; import org.jetbrains.annotations.NotNull; public class SideEffectChecker { @@ -59,6 +60,14 @@ public class SideEffectChecker { return; } super.visitMethodCallExpression(expression); + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final String methodName = methodExpression.getReferenceName(); + if ((methodName.startsWith("is") || methodName.startsWith("get")) && expression.getArgumentList().getExpressions().length == 0) { + final PsiMethod method = expression.resolveMethod(); + if (PropertyUtil.isSimpleGetter(method)) { + return; + } + } mayHaveSideEffects = true; } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TestUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TestUtils.java index cf2133299768..dcaf8390dc5d 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TestUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TestUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,8 +22,8 @@ import com.intellij.openapi.roots.ProjectFileIndex; import com.intellij.openapi.roots.ProjectRootManager; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.psi.util.*; import com.intellij.psi.util.InheritanceUtil; +import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -66,34 +66,37 @@ public class TestUtils { } public static boolean isJUnitTestMethod(@Nullable PsiMethod method) { + return isRunnable(method) && (isJUnit3TestMethod(method) || isJUnit4TestMethod(method)); + } + + public static boolean isRunnable(PsiMethod method) { if (method == null) { return false; } - if (isJUnit4TestMethod(method)) { - return true; - } - final String methodName = method.getName(); - @NonNls final String test = "test"; - if (!methodName.startsWith(test)) { - return false; - } if (method.hasModifierProperty(PsiModifier.ABSTRACT) || + method.hasModifierProperty(PsiModifier.STATIC) || !method.hasModifierProperty(PsiModifier.PUBLIC)) { return false; } final PsiType returnType = method.getReturnType(); - if (returnType == null) { + if (!PsiType.VOID.equals(returnType)) { return false; } - if (!returnType.equals(PsiType.VOID)) { + final PsiParameterList parameterList = method.getParameterList(); + return parameterList.getParametersCount() == 0; + } + + public static boolean isJUnit3TestMethod(@Nullable PsiMethod method) { + if (method == null) { return false; } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() != 0) { + final String methodName = method.getName(); + @NonNls final String test = "test"; + if (!methodName.startsWith(test)) { return false; } - final PsiClass targetClass = method.getContainingClass(); - return isJUnitTestClass(targetClass); + final PsiClass containingClass = method.getContainingClass(); + return isJUnitTestClass(containingClass); } public static boolean isJUnit4TestMethod(@Nullable PsiMethod method) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java index 78e32e5eee60..e449ad98fc8f 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarilyQualifiedInnerClassAccessInspection.java @@ -99,7 +99,10 @@ public class UnnecessarilyQualifiedInnerClassAccessInspection extends BaseInspec } final PsiClass aClass = (PsiClass)target; ImportUtils.addImportIfNeeded(aClass, element); - element.delete(); + final String shortName = aClass.getName(); + if (isReferenceToTarget(shortName, aClass, parent)) { + element.delete(); + } } } @@ -108,6 +111,20 @@ public class UnnecessarilyQualifiedInnerClassAccessInspection extends BaseInspec return new UnnecessarilyQualifiedInnerClassAccessVisitor(); } + private static boolean isReferenceToTarget(String referenceText, @NotNull PsiClass target, PsiElement context) { + final PsiJavaCodeReferenceElement reference = + JavaPsiFacade.getElementFactory(target.getProject()).createReferenceFromText(referenceText, context); + final JavaResolveResult[] results = reference.multiResolve(false); + if (results.length == 0) { + return true; + } + if (results.length > 1) { + return false; + } + final JavaResolveResult result = results[0]; + return result.isAccessible() && target.equals(result.getElement()); + } + private class UnnecessarilyQualifiedInnerClassAccessVisitor extends BaseInspectionVisitor { @@ -175,20 +192,6 @@ public class UnnecessarilyQualifiedInnerClassAccessInspection extends BaseInspec visitReferenceElement(expression); } - private boolean isReferenceToTarget(String referenceText, @NotNull PsiClass target, PsiElement context) { - final PsiJavaCodeReferenceElement reference = - JavaPsiFacade.getElementFactory(target.getProject()).createReferenceFromText(referenceText, context); - final JavaResolveResult[] results = reference.multiResolve(false); - if (results.length == 0) { - return true; - } - if (results.length > 1) { - return false; - } - final JavaResolveResult result = results[0]; - return result.isAccessible() && target.equals(result.getElement()); - } - private boolean isInImportOrPackage(PsiElement element) { while (element instanceof PsiJavaCodeReferenceElement) { element = element.getParent(); |