Java AnnotationUtil.isAnnotated方法代码示例

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static boolean isNullabilityAnnotationForTypeQualifierDefault(PsiAnnotation annotation,
                                                                      boolean nullable,
                                                                      PsiAnnotation.TargetType[] targetTypes) {
    PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement();
    PsiElement declaration = element == null ? null : element.resolve();
    if (!(declaration instanceof PsiClass)) {
        return false;
    }

    String fqn = nullable ? JAVAX_ANNOTATION_NULLABLE : JAVAX_ANNOTATION_NONNULL;
    PsiClass classDeclaration = (PsiClass) declaration;
    if (!AnnotationUtil.isAnnotated(classDeclaration, fqn, false, true)) {
        return false;
    }

    PsiAnnotation tqDefault = AnnotationUtil.findAnnotation(classDeclaration, true, TYPE_QUALIFIER_DEFAULT);
    if (tqDefault == null) {
        return false;
    }

    Set<PsiAnnotation.TargetType> required = extractRequiredAnnotationTargets(tqDefault.findAttributeValue(null));
    return required != null
            && (required.isEmpty() || ContainerUtil.intersects(required, Arrays.asList(targetTypes)));
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
public boolean satisfiedBy(PsiElement element) {
  final PsiElement parent = element.getParent();
  if (!(parent instanceof PsiClass)) {
    return false;
  }
  final PsiClass aClass = (PsiClass)parent;
  if (!aClass.isInterface() || aClass.isAnnotationType()) {
    return false;
  }
  final PsiElement leftBrace = aClass.getLBrace();
  final int offsetInParent = element.getStartOffsetInParent();
  if (leftBrace == null ||
      offsetInParent >= leftBrace.getStartOffsetInParent()) {
    return false;
  }
  final SearchScope useScope = aClass.getUseScope();
  for (PsiClass inheritor :
    ClassInheritorsSearch.search(aClass, useScope, true)) {
    if (inheritor.isInterface()) {
      return false;
    }
  }
  return !AnnotationUtil.isAnnotated(aClass, CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, false, true);
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static boolean isSetterNonNls(final Project project, final GlobalSearchScope searchScope,
                                      final String componentClassName, final String propertyName) {
  PsiClass componentClass = JavaPsiFacade.getInstance(project).findClass(componentClassName, searchScope);
  if (componentClass == null) {
    return false;
  }
  PsiMethod setter = PropertyUtil.findPropertySetter(componentClass, propertyName, false, true);
  if (setter != null) {
    PsiParameter[] parameters = setter.getParameterList().getParameters();
    if (parameters.length == 1 &&
        "java.lang.String".equals(parameters[0].getType().getCanonicalText()) &&
        AnnotationUtil.isAnnotated(parameters [0], AnnotationUtil.NON_NLS, false, true)) {
      return true;
    }
  }

  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
public static boolean isTestAnnotated(final PsiMethod method) {
  if (AnnotationUtil.isAnnotated(method, TEST_ANNOTATION, false) || JUnitRecognizer.willBeAnnotatedAfterCompilation(method)) {
    final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(method.getContainingClass(), Collections.singleton(RUN_WITH));
    if (annotation != null) {
      final PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes();
      for (PsiNameValuePair attribute : attributes) {
        final PsiAnnotationMemberValue value = attribute.getValue();
        if (value instanceof PsiClassObjectAccessExpression ) {
          final PsiTypeElement typeElement = ((PsiClassObjectAccessExpression)value).getOperand();
          if (typeElement.getType().getCanonicalText().equals(PARAMETERIZED_CLASS_NAME)) {
            return false;
          }
        }
      }
    }
    return true;
  }
  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@Override
@Nullable
public ProblemDescriptor[] checkField(@NotNull PsiField field, @NotNull InspectionManager manager, boolean isOnTheFly) {
  PsiClass containingClass = field.getContainingClass();
  if (containingClass == null || isClassNonNls(containingClass)) {
    return null;
  }
  if (AnnotationUtil.isAnnotated(field, AnnotationUtil.NON_NLS, false, false)) {
    return null;
  }
  final PsiExpression initializer = field.getInitializer();
  if (initializer != null) return checkElement(initializer, manager, isOnTheFly);

  if (field instanceof PsiEnumConstant) {
    return checkElement(((PsiEnumConstant)field).getArgumentList(), manager, isOnTheFly);
  }
  return null;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@Override
public BaseInspectionVisitor buildVisitor() {
  return new BaseInspectionVisitor() {
    @Override
    public void visitField(PsiField field) {
      final boolean ruleAnnotated = REPORT_RULE_PROBLEMS && AnnotationUtil.isAnnotated(field, RULE_FQN, false);
      final boolean classRuleAnnotated = REPORT_CLASS_RULE_PROBLEMS && AnnotationUtil.isAnnotated(field, CLASS_RULE_FQN, false);
      if (ruleAnnotated || classRuleAnnotated) {
        String annotation = ruleAnnotated ? RULE_FQN : CLASS_RULE_FQN;
        String errorMessage = getPublicStaticErrorMessage(field, ruleAnnotated, classRuleAnnotated);
        if (errorMessage != null) {
          registerError(field.getNameIdentifier(), InspectionGadgetsBundle.message("junit.rule.problem.descriptor", annotation, errorMessage), "Make field " + errorMessage, annotation);
        }
        if (!InheritanceUtil.isInheritor(PsiUtil.resolveClassInClassTypeOnly(field.getType()), false, "org.junit.rules.TestRule")) {
          registerError(field.getNameIdentifier(), InspectionGadgetsBundle.message("junit.rule.type.problem.descriptor"));
        }
      }
    }
  };
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static boolean isUtilityMethod(@NotNull PsiMethod method, @NotNull PsiClass psiClass, @NotNull TestFramework framework) {
  if (method == framework.findSetUpMethod(psiClass) || method == framework.findTearDownMethod(psiClass)) {
    return true;
  }

  // JUnit3
  if (framework.getClass().getName().contains("JUnit3")) {
    return !method.getName().startsWith("test");
  }

  // JUnit4
  else if (framework.getClass().getName().contains("JUnit4")) {
    return !AnnotationUtil.isAnnotated(method, "org.junit.Test", false);
  }
  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  //don't call super, to prevent drilldown
  if (FileTypeUtils.isInServerPageFile(aClass.getContainingFile())) {
    return;
  }
  if (aClass.isInterface() || aClass.isEnum() || aClass.isAnnotationType()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  final PsiMethod[] constructors = aClass.getConstructors();
  if (constructors.length > 0) {
    return;
  }
  final PsiMethod[] methods = aClass.getMethods();
  if (methods.length > 0) {
    return;
  }
  final PsiField[] fields = aClass.getFields();
  if (fields.length > 0) {
    return;
  }
  final PsiClassInitializer[] initializers = aClass.getInitializers();
  if (initializers.length > 0) {
    return;
  }
  if (ignoreClassWithParameterization && isSuperParametrization(aClass)) {
    return;
  }
  if (AnnotationUtil.isAnnotated(aClass, ignorableAnnotations)) {
    return;
  }
  if (ignoreThrowables && InheritanceUtil.isInheritor(aClass, "java.lang.Throwable")) {
    return;
  }
  registerClassError(aClass, aClass);
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@Override
@NotNull
protected String buildErrorString(Object... infos) {
  if (AnnotationUtil.isAnnotated((PsiMethod)infos[1], IGNORE, false)) {
    return InspectionGadgetsBundle.message("ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor");
  }
  return InspectionGadgetsBundle.message("junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor");
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
public static boolean isTestClass(@NotNull PsiClass psiClass, boolean checkAbstract, boolean checkForTestCaseInheritance) {
  if (psiClass.getQualifiedName() == null) return false;
  final PsiClass topLevelClass = PsiTreeUtil.getTopmostParentOfType(psiClass, PsiClass.class);
  if (topLevelClass != null) {
    final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(topLevelClass, Collections.singleton(RUN_WITH));
    if (annotation != null) {
      final PsiAnnotationMemberValue attributeValue = annotation.findAttributeValue("value");
      if (attributeValue instanceof PsiClassObjectAccessExpression) {
        final String runnerName = ((PsiClassObjectAccessExpression)attributeValue).getOperand().getType().getCanonicalText();
        if (!(PARAMETERIZED_CLASS_NAME.equals(runnerName) || SUITE_CLASS_NAME.equals(runnerName))) {
          return true;
        }
      }
    }
  }
  if (!PsiClassUtil.isRunnableClass(psiClass, true, checkAbstract)) return false;
  if (checkForTestCaseInheritance && isTestCaseInheritor(psiClass)) return true;
  final PsiModifierList modifierList = psiClass.getModifierList();
  if (modifierList == null) return false;
  if (AnnotationUtil.isAnnotated(psiClass, RUN_WITH, true)) return true;

  for (final PsiMethod method : psiClass.getAllMethods()) {
    ProgressManager.checkCanceled();
    if (isSuiteMethod(method)) return true;
    if (isTestAnnotated(method)) return true;
  }

  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static boolean isJUnit4TestClass(final PsiClass psiClass, boolean checkAbstract) {
  if (!PsiClassUtil.isRunnableClass(psiClass, true, checkAbstract)) return false;

  final PsiModifierList modifierList = psiClass.getModifierList();
  if (modifierList == null) return false;
  if (AnnotationUtil.isAnnotated(psiClass, RUN_WITH, true)) return true;
  for (final PsiMethod method : psiClass.getAllMethods()) {
    ProgressManager.checkCanceled();
    if (isTestAnnotated(method)) return true;
  }

  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@Nullable
@Override
protected PsiMethod findSetUpMethod(@NotNull PsiClass clazz) {
  for (PsiMethod each : clazz.getMethods()) {
    if (AnnotationUtil.isAnnotated(each, JUnitUtil.BEFORE_ANNOTATION_NAME, false)) return each;
  }
  return null;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static PsiMethod getTestMethod(ConfigurationContext context) {
  PsiElement psi = context.getPsiLocation();
  if (psi instanceof PsiMethod
      && AnnotationUtil.isAnnotated((PsiMethod) psi, JUnitUtil.TEST_ANNOTATION, false)) {
    return (PsiMethod) psi;
  }
  List<PsiMethod> selectedMethods = TestMethodSelectionUtil.getSelectedMethods(context);
  return selectedMethods != null && selectedMethods.size() == 1 ? selectedMethods.get(0) : null;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
private static void checkClassMethods(String methodName,
                                      PsiClass containingClass,
                                      Set<PsiMember> alreadyMarkedToBeChecked,
                                      Set<PsiMember> membersToCheckNow,
                                      Map<PsiClass, Map<PsiMethod, List<String>>> results) {
  final PsiMethod[] psiMethods = containingClass.findMethodsByName(methodName, true);
  for (PsiMethod method : psiMethods) {
    if (AnnotationUtil.isAnnotated(method, TestNGUtil.TEST_ANNOTATION_FQN, false) &&
        appendMember(method, alreadyMarkedToBeChecked, results)) {
      membersToCheckNow.add(method);
    }
  }
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入方法依赖的package包/类
@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);
}