private static void annotateWithNullableStuff( final PsiModifierListOwner field, final PsiElementFactory factory, final PsiModifierListOwner listOwner) throws IncorrectOperationException { if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NOT_NULL, false)) { annotate(factory, listOwner, AnnotationUtil.NOT_NULL); } else if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NULLABLE, false)) { annotate(factory, listOwner, AnnotationUtil.NULLABLE); } }
@Override public void visitMethod(@NotNull PsiMethod method) { super.visitMethod(method); final PsiCodeBlock body = method.getBody(); if (body == null) { return; } if (method.getNameIdentifier() == null) { return; } final PsiMethod leastConcreteSuperMethod = getLeastConcreteSuperMethod(method); if (leastConcreteSuperMethod == null) { return; } final PsiClass objectClass = ClassUtils.findObjectClass(method); final PsiMethod[] superMethods = method.findSuperMethods(objectClass); if (superMethods.length > 0) { return; } if (ignoreEmptySuperMethods) { final PsiMethod superMethod = (PsiMethod) leastConcreteSuperMethod.getNavigationElement(); if (MethodUtils.isTrivial(superMethod, true)) { return; } } if (onlyReportWhenAnnotated) { if (!AnnotationUtil.isAnnotated(leastConcreteSuperMethod, annotations)) { return; } } if (containsSuperCall(body, leastConcreteSuperMethod)) { return; } registerMethodError(method); }
public static String getConfigAnnotation(PsiMethod method) { if (method != null) { for (String fqn : CONFIG_ANNOTATIONS_FQN) { if (AnnotationUtil.isAnnotated(method, fqn, false)) return fqn; } } return null; }
@Override public boolean isAvailable( @NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { if (!startElement.isValid()) return false; if (!PsiUtil.isLanguageLevel5OrHigher(startElement)) return false; final PsiModifierListOwner myModifierListOwner = (PsiModifierListOwner) startElement; return !AnnotationUtil.isAnnotated(myModifierListOwner, myAnnotation, false); }
private static boolean isConfigMethod(PsiMethod method, String[] configAnnotationsFqn) { for (String fqn : configAnnotationsFqn) { if (AnnotationUtil.isAnnotated(method, fqn, false)) return true; } if (hasDocTagsSupport) { final PsiDocComment comment = method.getDocComment(); if (comment != null) { for (String javadocTag : CONFIG_JAVADOC_TAGS) { if (comment.findTagByName(javadocTag) != null) return true; } } } return false; }
@Override public boolean isAvailable( @NotNull final Project project, final Editor editor, @NotNull final PsiElement element) { if (!super.isAvailable(project, editor, element)) { return false; } PsiModifierListOwner owner = getContainer(element); if (owner == null || AnnotationUtil.isAnnotated(owner, getAnnotationsToRemove()[0], false)) { return false; } if (owner instanceof PsiMethod) { PsiType returnType = ((PsiMethod) owner).getReturnType(); return returnType != null && !(returnType instanceof PsiPrimitiveType); } return true; }
public static boolean isJUnitTestMethod(PsiMethod method) { //noinspection HardCodedStringLiteral if (AnnotationUtil.isAnnotated(method, "org.junit.Test", true)) { return true; } final PsiType returnType = method.getReturnType(); if (!PsiType.VOID.equals(returnType)) { return false; } if (!method.hasModifierProperty(PsiModifier.PUBLIC)) { return false; } @NonNls final String methodName = method.getName(); if (!methodName.startsWith("test")) { return false; } final PsiClass containingClass = method.getContainingClass(); return containingClass != null && isJUnitTestCase(containingClass); }
public static boolean isJUnitTestCase(PsiClass aClass) { final Project project = aClass.getProject(); final GlobalSearchScope scope = GlobalSearchScope.allScope(project); final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); final PsiClass testCase = psiFacade.findClass("junit.framework.TestCase", scope); if (testCase == null) { return false; } if (aClass.isInheritor(testCase, true)) { return true; } final PsiMethod[] methods = aClass.getMethods(); for (PsiMethod method : methods) { //noinspection HardCodedStringLiteral if (AnnotationUtil.isAnnotated(method, "org.junit.Test", true)) { return true; } } return false; }
@Override public void visitLiteralExpression(@NotNull PsiLiteralExpression value) { super.visitLiteralExpression(value); final String text = value.getText(); if (!PsiKeyword.NULL.equals(text)) { return; } PsiElement parent = value.getParent(); while (parent instanceof PsiParenthesizedExpression || parent instanceof PsiConditionalExpression || parent instanceof PsiTypeCastExpression) { parent = parent.getParent(); } if (parent == null || !(parent instanceof PsiReturnStatement)) { return; } final PsiMethod method = PsiTreeUtil.getParentOfType(value, PsiMethod.class); if (method == null) { return; } final PsiType returnType = method.getReturnType(); if (returnType == null) { return; } final boolean isArray = returnType.getArrayDimensions() > 0; if (AnnotationUtil.isAnnotated(method, AnnotationUtil.NULLABLE, false)) { return; } if (m_reportCollectionMethods && CollectionUtils.isCollectionClassOrInterface(returnType)) { registerError(value, value); } else if (m_reportArrayMethods && isArray) { registerError(value, value); } else if (m_reportObjectMethods && !isArray) { registerError(value, value); } }
private static boolean isAnnotatedAsTestOnly(@Nullable PsiMethod m) { if (m == null) return false; return AnnotationUtil.isAnnotated(m, AnnotationUtil.TEST_ONLY, false, false) || AnnotationUtil.isAnnotated( m, "com.google.common.annotations.VisibleForTesting", false, false); }
public static boolean containsJunitAnnotions(PsiMethod method) { return method != null && AnnotationUtil.isAnnotated(method, JUNIT_ANNOTATIONS); }
public static boolean hasTest( PsiModifierListOwner element, boolean checkHierarchy, boolean checkDisabled, boolean checkJavadoc) { // LanguageLevel effectiveLanguageLevel = element.getManager().getEffectiveLanguageLevel(); // boolean is15 = effectiveLanguageLevel != LanguageLevel.JDK_1_4 && effectiveLanguageLevel != // LanguageLevel.JDK_1_3; boolean hasAnnotation = AnnotationUtil.isAnnotated(element, TEST_ANNOTATION_FQN, checkHierarchy, true); if (hasAnnotation) { if (checkDisabled) { PsiAnnotation annotation = AnnotationUtil.findAnnotation(element, true, TEST_ANNOTATION_FQN); if (annotation != null) { if (isDisabled(annotation)) return false; } } return true; } if (element instanceof PsiDocCommentOwner && checkJavadoc && getTextJavaDoc((PsiDocCommentOwner) element) != null) return true; // now we check all methods for the test annotation if (element instanceof PsiClass) { PsiClass psiClass = (PsiClass) element; for (PsiMethod method : psiClass.getAllMethods()) { PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, true, TEST_ANNOTATION_FQN); if (annotation != null) { if (checkDisabled) { if (isDisabled(annotation)) continue; } return true; } if (AnnotationUtil.isAnnotated(method, FACTORY_ANNOTATION_FQN, false, true)) return true; if (checkJavadoc && getTextJavaDoc(method) != null) return true; } return false; } else if (element instanceof PsiMethod) { // even if it has a global test, we ignore private and static methods if (element.hasModifierProperty(PsiModifier.PRIVATE) || element.hasModifierProperty(PsiModifier.STATIC)) { return false; } // if it's a method, we check if the class it's in has a global @Test annotation PsiClass psiClass = ((PsiMethod) element).getContainingClass(); if (psiClass != null) { final PsiAnnotation annotation = checkHierarchy ? AnnotationUtil.findAnnotationInHierarchy( psiClass, Collections.singleton(TEST_ANNOTATION_FQN)) : AnnotationUtil.findAnnotation(psiClass, true, TEST_ANNOTATION_FQN); if (annotation != null) { if (checkDisabled && isDisabled(annotation)) return false; return !hasConfig(element); } else if (checkJavadoc && getTextJavaDoc(psiClass) != null) return true; } } return false; }