Java AnnotationUtil类代码示例

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@Nullable
private static Set<PsiAnnotation.TargetType> targetTypesForDefault(PsiAnnotation annotation) {
    PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement();
    PsiElement declaration = element == null ? null : element.resolve();

    if (!(declaration instanceof PsiClass)) {
        return Collections.emptySet();
    }

    PsiClass classDeclaration = (PsiClass) declaration;
    PsiAnnotation tqDefault = AnnotationUtil.findAnnotation(classDeclaration, true, TYPE_QUALIFIER_DEFAULT);

    if (tqDefault == null) {
        return Collections.emptySet();
    }

    return extractRequiredAnnotationTargets(tqDefault.findAttributeValue(null));
}
 

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 static void addSuppressAnnotation(@NotNull Project project,
                                         final PsiElement container,
                                         final PsiModifierListOwner modifierOwner,
                                         @NotNull String id) throws IncorrectOperationException {
  PsiAnnotation annotation = AnnotationUtil.findAnnotation(modifierOwner, SUPPRESS_INSPECTIONS_ANNOTATION_NAME);
  final PsiAnnotation newAnnotation = createNewAnnotation(project, container, annotation, id);
  if (newAnnotation != null) {
    if (annotation != null && annotation.isPhysical()) {
      annotation.replace(newAnnotation);
    }
    else {
      final PsiNameValuePair[] attributes = newAnnotation.getParameterList().getAttributes();
      new AddAnnotationPsiFix(SUPPRESS_INSPECTIONS_ANNOTATION_NAME, modifierOwner, attributes).applyFix();
    }
  }
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@NotNull
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
  return new JavaElementVisitor() {
    final String annotationName = Configuration.getProjectInstance(holder.getProject()).getAdvancedConfiguration().getPatternAnnotationClass();

    @Override
    public void visitAnnotation(PsiAnnotation annotation) {
      final String name = annotation.getQualifiedName();
      if (annotationName.equals(name)) {
        checkAnnotation(annotation, holder);
      }
      else if (name != null) {
        final PsiClass psiClass = JavaPsiFacade.getInstance(annotation.getProject()).findClass(name, annotation.getResolveScope());
        if (psiClass != null && AnnotationUtil.isAnnotated(psiClass, annotationName, false, false)) {
          checkAnnotation(annotation, holder);
        }
      }
    }
  };
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
private static boolean checkNonStandardAnnotations(PsiField field,
                                                   Annotated annotated,
                                                   NullableNotNullManager manager, String anno, @NotNull ProblemsHolder holder) {
  if (!AnnotationUtil.isAnnotatingApplicable(field, anno)) {
    final PsiAnnotation notNull = AnnotationUtil.findAnnotation(field, manager.getNotNulls());
    final PsiAnnotation nullable = AnnotationUtil.findAnnotation(field, manager.getNullables());
    final PsiAnnotation annotation;
    String message = "Not \'";
    if (annotated.isDeclaredNullable) {
      message += nullable.getQualifiedName();
      annotation = nullable;
    } else {
      message += notNull.getQualifiedName();
      annotation = notNull;
    }
    message += "\' but \'" + anno + "\' would be used for code generation.";
    final PsiJavaCodeReferenceElement annotationNameReferenceElement = annotation.getNameReferenceElement();
    holder.registerProblem(annotationNameReferenceElement != null && annotationNameReferenceElement.isPhysical() ? annotationNameReferenceElement : field.getNameIdentifier(),
                           message,
                           ProblemHighlightType.WEAK_WARNING,
                           new ChangeNullableDefaultsFix(notNull, nullable, manager));
    return false;
  }
  return true;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@NotNull
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
  return new JavaElementVisitor() {
    final String annotationName = Configuration.getProjectInstance(holder.getProject()).getAdvancedConfiguration().getLanguageAnnotationClass();

    @Override
    public void visitAnnotation(PsiAnnotation annotation) {
      final String name = annotation.getQualifiedName();
      if (annotationName.equals(name)) {
        checkAnnotation(annotation, holder);
      }
      else if (name != null) {
        final PsiClass psiClass = JavaPsiFacade.getInstance(annotation.getProject()).findClass(name, annotation.getResolveScope());
        if (psiClass != null && AnnotationUtil.isAnnotated(psiClass, annotationName, false, false)) {
          checkAnnotation(annotation, holder);
        }
      }
    }
  };
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@Nullable
static String findGuardForMember(PsiMember member) {
  final PsiAnnotation annotation = AnnotationUtil.findAnnotation(member, GUARDED_BY);
  if (annotation != null) {
    return getGuardValue(annotation);
  }
  if (member instanceof PsiCompiledElement) {
    member = (PsiMember)member.getNavigationElement();
    if (member == null || member instanceof PsiCompiledElement) {
      return null; // can't analyze compiled code
    }
  }
  final GuardedTagVisitor visitor = new GuardedTagVisitor();
  member.accept(visitor);
  return visitor.getGuardString();
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
private static boolean hasRuntimeAnnotations(PsiMethod method) {
  PsiAnnotation[] annotations = method.getModifierList().getAnnotations();
  for (PsiAnnotation annotation : annotations) {
    PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement();
    PsiElement target = ref != null ? ref.resolve() : null;
    if (target instanceof PsiClass) {
      final PsiAnnotation retentionAnno = AnnotationUtil.findAnnotation((PsiClass)target, Retention.class.getName());
      if (retentionAnno != null) {
        PsiAnnotationMemberValue value = retentionAnno.findAttributeValue("value");
        if (value instanceof PsiReferenceExpression) {
          final PsiElement resolved = ((PsiReferenceExpression)value).resolve();
          if (resolved instanceof PsiField && RetentionPolicy.RUNTIME.name().equals(((PsiField)resolved).getName())) {
            final PsiClass containingClass = ((PsiField)resolved).getContainingClass();
            if (containingClass != null && RetentionPolicy.class.getName().equals(containingClass.getQualifiedName())) {
              return true;
            }
          }
        }
      }
    }
  }
  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@Override
public void visitClass(PsiClass aClass) {
  super.visitClass(aClass);
  if (!aClass.isInterface() || AnnotationUtil.isAnnotated(aClass, "java.lang.FunctionalInterface", false)) {
    return;
  }
  if (LambdaHighlightingUtil.checkInterfaceFunctional(aClass) != null) {
    return;
  }
  final List<HierarchicalMethodSignature> candidates = LambdaUtil.findFunctionCandidates(aClass);
  if (candidates == null || candidates.size() != 1) {
    return;
  }
  final MethodSignature signature = candidates.get(0);
  if (signature.getTypeParameters().length > 0) {
    return;
  }
  registerClassError(aClass, aClass);
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
@Override
public boolean isAvailable(@NotNull Project project,
                           @NotNull PsiFile file,
                           @NotNull PsiElement startElement,
                           @NotNull PsiElement endElement) {
  if (!super.isAvailable(project, file, startElement, endElement)) {
    return false;
  }
  PsiModifierListOwner owner = getContainer(file, startElement.getTextRange().getStartOffset());
  if (owner == null || AnnotationUtil.isAnnotated(owner, getAnnotationsToRemove()[0], false, false)) {
    return false;
  }
  if (owner instanceof PsiMethod) {
    PsiType returnType = ((PsiMethod)owner).getReturnType();

    return returnType != null && !(returnType instanceof PsiPrimitiveType);
  }
  return true;
}
 

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包/类
private static void appendModifierList(@NotNull StringBuilder buffer, @NotNull PsiModifierListOwner owner) {
  int lastSize = buffer.length();
  Set<String> shownAnnotations = ContainerUtil.newHashSet();
  for (PsiAnnotation annotation : AnnotationUtil.getAllAnnotations(owner, false, null, !DumbService.isDumb(owner.getProject()))) {
    final PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement();
    if (element != null) {
      final PsiElement resolved = element.resolve();
      if (resolved instanceof PsiClass && !JavaDocInfoGenerator.isDocumentedAnnotationType(resolved)) {
        continue;
      }

      String referenceName = element.getReferenceName();
      if (shownAnnotations.add(referenceName) || JavaDocInfoGenerator.isRepeatableAnnotationType(resolved)) {
        if (lastSize != buffer.length()) buffer.append(" ");
        buffer.append("@").append(referenceName);
      }
    }
  }
  if (lastSize != buffer.length()) buffer.append(" ");
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
private static boolean isReturnedFromNonNlsMethod(final PsiLiteralExpression expression, final Set<PsiModifierListOwner> nonNlsTargets) {
  PsiElement parent = expression.getParent();
  PsiMethod method;
  if (parent instanceof PsiNameValuePair) {
    method = AnnotationUtil.getAnnotationMethod((PsiNameValuePair)parent);
  }
  else {
    final PsiElement returnStmt = PsiTreeUtil.getParentOfType(expression, PsiReturnStatement.class, PsiMethodCallExpression.class);
    if (!(returnStmt instanceof PsiReturnStatement)) {
      return false;
    }
    method = PsiTreeUtil.getParentOfType(expression, PsiMethod.class);
  }
  if (method == null) return false;

  if (AnnotationUtil.isAnnotated(method, AnnotationUtil.NON_NLS, true, false)) {
    return true;
  }
  nonNlsTargets.add(method);
  return false;
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
public static void setModifiers(PsiField field, Settings settings) {
  if (!settings.isIntroduceEnumConstant()) {
    if (settings.isDeclareStatic()) {
      PsiUtil.setModifierProperty(field, PsiModifier.STATIC, true);
    }
    if (settings.isDeclareFinal()) {
      PsiUtil.setModifierProperty(field, PsiModifier.FINAL, true);
    }
    if (settings.isAnnotateAsNonNls()) {
      PsiAnnotation annotation = JavaPsiFacade.getInstance(field.getProject()).getElementFactory()
        .createAnnotationFromText("@" + AnnotationUtil.NON_NLS, field);
      final PsiModifierList modifierList = field.getModifierList();
      LOG.assertTrue(modifierList != null);
      modifierList.addAfter(annotation, null);
    }
  }
  JavaCodeStyleManager.getInstance(field.getProject()).shortenClassReferences(field);
}
 

import com.intellij.codeInsight.AnnotationUtil; //导入依赖的package包/类
public void registerReferenceProviders(@NotNull final PsiReferenceRegistrar registrar) {

    final JavaClassListReferenceProvider classListProvider = new JavaClassListReferenceProvider();
    registrar.registerReferenceProvider(xmlAttributeValue(), classListProvider, PsiReferenceRegistrar.LOWER_PRIORITY);
    registrar.registerReferenceProvider(xmlTag(), classListProvider, PsiReferenceRegistrar.LOWER_PRIORITY);

    final PsiReferenceProvider filePathReferenceProvider = new FilePathReferenceProvider();
    registrar.registerReferenceProvider(PlatformPatterns.psiElement(PsiLiteralExpression.class).and(new FilterPattern(new ElementFilter() {
      public boolean isAcceptable(Object element, PsiElement context) {
        PsiLiteralExpression literalExpression = (PsiLiteralExpression) context;
        final Map<String, Object> annotationParams = new HashMap<String, Object>();
        annotationParams.put(AnnotationUtil.PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER, null);
        return !JavaI18nUtil.mustBePropertyKey(context.getProject(), literalExpression, annotationParams);
      }

      public boolean isClassAcceptable(Class hintClass) {
        return true;
      }
    })), filePathReferenceProvider);
    registrar.registerReferenceProvider(PlatformPatterns.psiElement(PsiDocToken.class),
                                        CommentsReferenceContributor.COMMENTS_REFERENCE_PROVIDER_TYPE.getProvider());
  }