下面列出了怎么用com.intellij.psi.PsiAnnotation的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public final void visit(final UAnnotation node) {
final PsiAnnotation nodePsi = node.getJavaPsi();
if (nodePsi == null || !ConfigElementsUtils.isJsonConfigAnnotation(nodePsi)) {
return;
}
final PsiClass jsonType = ConfigElementsUtils.getJsonTypeAttribute(nodePsi);
if (jsonType == null) {
return;
}
final int genericTypesCount = ConfigElementsUtils.getGenericTypesCount(nodePsi);
visitJsonConfigAnnotation(node, jsonType, genericTypesCount);
}
public static Set<String> getQualifierAnnotations(PsiElement element) {
Set<String> qualifiedClasses = new HashSet<String>();
if (element instanceof PsiModifierListOwner) {
PsiModifierListOwner listOwner = (PsiModifierListOwner) element;
PsiModifierList modifierList = listOwner.getModifierList();
if (modifierList != null) {
for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) {
if (psiAnnotation != null && psiAnnotation.getQualifiedName() != null) {
JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(element.getProject());
PsiClass psiClass = psiFacade.findClass(psiAnnotation.getQualifiedName(),
GlobalSearchScope.projectScope(element.getProject()));
if (hasAnnotation(psiClass, CLASS_QUALIFIER)) {
qualifiedClasses.add(psiAnnotation.getQualifiedName());
}
}
}
}
}
return qualifiedClasses;
}
@Override
public ProblemDescriptor[] checkClass( @NotNull PsiClass psiClass,
@NotNull InspectionManager manager,
boolean isOnTheFly )
{
PsiAnnotation mixinsAnnotation = getMixinsAnnotation( psiClass );
if( mixinsAnnotation == null )
{
return null;
}
if( psiClass.isInterface() )
{
return null;
}
String message = message( "mixins.annotation.declared.on.mixin.type.error.declared.on.class" );
RemoveInvalidMixinClassReferenceFix fix = new RemoveInvalidMixinClassReferenceFix( mixinsAnnotation );
ProblemDescriptor problemDescriptor = manager.createProblemDescriptor( mixinsAnnotation, message, fix,
GENERIC_ERROR_OR_WARNING );
return new ProblemDescriptor[]{ problemDescriptor };
}
@Nullable
public static TestSize getTestSize(PsiClass psiClass) {
PsiModifierList psiModifierList = psiClass.getModifierList();
if (psiModifierList == null) {
return null;
}
PsiAnnotation[] annotations = psiModifierList.getAnnotations();
TestSize testSize = getTestSize(annotations);
if (testSize != null) {
return testSize;
}
String fullText = psiModifierList.getText();
return CATEGORY_ANNOTATION_HEURISTIC
.entrySet()
.stream()
.filter(e -> fullText.contains(e.getKey()))
.map(Map.Entry::getValue)
.findFirst()
.orElse(null);
}
static PsiAnnotation findAnnotation(PsiElement element, String annotationName) {
if (element instanceof PsiModifierListOwner) {
PsiModifierListOwner listOwner = (PsiModifierListOwner) element;
PsiModifierList modifierList = listOwner.getModifierList();
if (modifierList != null) {
for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) {
if (annotationName.equals(psiAnnotation.getQualifiedName())) {
return psiAnnotation;
}
}
}
}
return null;
}
private Object invoke(Method method, Object[] args) throws IllegalAccessException {
Class<?> returnType = method.getReturnType();
if (returnType.isEnum()) {
PsiAnnotation currentAnnotation =
AnnotationUtil.findAnnotationInHierarchy(
mListOwner, Collections.singleton(mAnnotationClass.getCanonicalName()));
PsiReferenceExpression declaredValue =
(PsiReferenceExpression) currentAnnotation.findAttributeValue(method.getName());
if (declaredValue == null) {
return method.getDefaultValue();
}
PsiIdentifier identifier = PsiTreeUtil.getChildOfType(declaredValue, PsiIdentifier.class);
return Enum.valueOf((Class<Enum>) returnType, identifier.getText());
}
try {
if (args == null) {
return method.invoke(mStubbed);
}
return method.invoke(mStubbed, args);
} catch (InvocationTargetException e) {
return method.getDefaultValue();
}
}
@Nullable
@Override
public LineMarkerInfo getLineMarkerInfo(@NotNull PsiElement psiElement) {
try {
PsiAnnotation psiAnnotation = this.getPsiAnnotation(psiElement);
if (psiAnnotation != null) {
PsiLiteralExpression literalExpression = (PsiLiteralExpression) psiAnnotation.findAttributeValue("value");
String value = String.valueOf(literalExpression.getValue());
if (value.startsWith(JSON_PREFIX)) {
return new LineMarkerInfo<>(psiAnnotation, psiAnnotation.getTextRange(), NutzCons.NUTZ,
new FunctionTooltip("快速配置"),
new OkJsonUpdateNavigationHandler(value),
GutterIconRenderer.Alignment.LEFT);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public void visitAnnotation(PsiAnnotation annotation) {
super.visitAnnotation(annotation);
final String qualifiedName = annotation.getQualifiedName();
if (StringUtils.isNotBlank(qualifiedName) && allProblemHandlers.containsKey(qualifiedName)) {
final Collection<SqliteMagicProblem> problems = new HashSet<SqliteMagicProblem>();
for (Processor inspector : allProblemHandlers.get(qualifiedName)) {
problems.addAll(inspector.verifyAnnotation(annotation));
}
for (SqliteMagicProblem problem : problems) {
holder.registerProblem(annotation, problem.getMessage(), problem.getHighlightType(), problem.getQuickFixes());
}
}
}
/**
* If element at this location specifies a reference to a bean (e.g. a BeanInject annotation, bean property reference,
* etc.), returns the expected type of that bean
*/
public PsiType findExpectedBeanTypeAt(PsiElement location) {
PsiAnnotation annotation = PsiTreeUtil.getParentOfType(location, PsiAnnotation.class);
if (annotation != null) {
return IdeaUtils.getService().findAnnotatedElementType(annotation);
}
return Optional.ofNullable(PsiTreeUtil.getParentOfType(location, XmlAttributeValue.class, false))
.filter(e -> Arrays.stream(e.getReferences()).anyMatch(ref -> ref instanceof BeanReference))
.map(e -> PsiTreeUtil.getParentOfType(e, XmlTag.class))
.map(this::findPropertyNameReference)
.map(PropertyNameReference::resolve)
.map(target -> {
if (target instanceof PsiField) {
return ((PsiField) target).getType();
} else if (target instanceof PsiMethod) {
return ((PsiMethod) target).getParameterList().getParameters()[0].getType();
} else {
return null;
}
})
.orElse(null);
}
@Override
protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {
SuperBuilderHandler builderHandler = getBuilderHandler();
final String builderClassName = builderHandler.getBuilderClassName(psiClass);
Optional<PsiClass> builderClass = PsiClassUtil.getInnerClassInternByName(psiClass, builderClassName);
if (!builderClass.isPresent()) {
final PsiClass createdBuilderClass = builderHandler.createBuilderBaseClass(psiClass, psiAnnotation);
target.add(createdBuilderClass);
builderClass = Optional.of(createdBuilderClass);
}
// skip generation of BuilderImpl class, if class is abstract
if (!psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
final String builderImplClassName = builderHandler.getBuilderImplClassName(psiClass);
if (!PsiClassUtil.getInnerClassInternByName(psiClass, builderImplClassName).isPresent()) {
target.add(builderHandler.createBuilderImplClass(psiClass, builderClass.get(), psiAnnotation));
}
}
}
private boolean hasCyclicDefaultValueConfigReference(final PsiField configField, final ArrayList<PsiField> visitedFields) {
if (!ConfigElementsUtils.hasDefaultConfigAnnotation(configField)) {
return false;
}
final PsiAnnotation defaultConfigAnnotation = ConfigElementsUtils.getDefaultConfigAnnotation(configField);
final PsiElement defaultValueAttribute = defaultConfigAnnotation.findAttributeValue(null);
final PsiField referencedDefaultConfigValue = ElementUtils.getReferencedField(defaultValueAttribute);
if (visitedFields.contains(referencedDefaultConfigValue)) {
return true;
}
visitedFields.add(referencedDefaultConfigValue);
return hasCyclicDefaultValueConfigReference(referencedDefaultConfigValue, visitedFields);
}
@NotNull
@Override
public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
List<? super PsiElement> result = Collections.emptyList();
PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClasses());
if (null != psiAnnotation) {
if (supportAnnotationVariant(psiAnnotation) && validate(psiAnnotation, psiClass, ProblemEmptyBuilder.getInstance())) {
result = new ArrayList<>();
generatePsiElements(psiClass, psiAnnotation, result);
}
}
return result;
}
@Override
protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
final String typeName = FieldNameConstantsHandler.getTypeName(psiClass, psiAnnotation);
Optional<PsiClass> innerClass = PsiClassUtil.getInnerClassInternByName(psiClass, typeName);
if (innerClass.isPresent()) {
final boolean asEnum = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "asEnum", false);
if (innerClass.get().isEnum() != asEnum) {
builder.addError("@FieldNameConstants inner type already exists, but asEnum=" + asEnum + " does not match existing type");
return false;
}
}
return true;
}
private static boolean isConfigAnnotation(PsiAnnotation annotation) {
for (Class<? extends Annotation> configClass : Configs.ALL) {
if (ElementUtils.isOfType(annotation, configClass)) {
return true;
}
}
return isGroupAnnotation(annotation) || isCustomConfigAnnotation(annotation);
}
@NotNull
public Collection<PsiAnnotation> collectProcessedAnnotations(@NotNull PsiClass psiClass) {
Collection<PsiAnnotation> result = new ArrayList<>();
PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClasses());
if (null != psiAnnotation) {
result.add(psiAnnotation);
}
return result;
}
@Override
public boolean isConsumerEndpoint(PsiElement element) {
if (getIdeaUtils().isFromJavaMethodCall(element, true, CONSUMER_ENDPOINT)) {
return true;
}
// annotation
PsiAnnotation annotation = PsiTreeUtil.getParentOfType(element, PsiAnnotation.class);
if (annotation != null && annotation.getQualifiedName() != null) {
return annotation.getQualifiedName().equals("org.apache.camel.Consume");
}
return false;
}
@NotNull
@Override
public Collection<LombokProblem> verifyAnnotation(@NotNull PsiAnnotation psiAnnotation) {
Collection<LombokProblem> result = Collections.emptyList();
PsiField psiField = PsiTreeUtil.getParentOfType(psiAnnotation, PsiField.class);
if (null != psiField) {
ProblemNewBuilder problemNewBuilder = new ProblemNewBuilder();
validate(psiAnnotation, psiField, problemNewBuilder);
result = problemNewBuilder.getProblems();
}
return result;
}
@Nullable
private static TestSize getTestSize(PsiAnnotation[] annotations) {
for (PsiAnnotation annotation : annotations) {
String qualifiedName = annotation.getQualifiedName();
TestSize testSize = ANNOTATION_TO_TEST_SIZE.get(qualifiedName);
if (testSize != null) {
return testSize;
}
}
return null;
}
@Nullable
public static SubscriberMetadata getSubscriberMetadata(PsiMethod method) {
for (SubscriberMetadata info : subscribers) {
PsiAnnotation annotation = PsiConsultantImpl.findAnnotationOnMethod(method,
info.getSubscriberAnnotationClassName());
if (annotation != null) {
return info;
}
}
return null;
}
/**
* Searching for the specific bean name and annotation to find it's {@link PsiClass}
* @param beanName - Name of the bean to search for.
* @param annotation - Type of bean annotation to filter on.
* @param project - Project reference to narrow the search inside.
* @return the {@link PsiClass} matching the bean name and annotation.
*/
public Optional<PsiClass> findBeanClassByName(String beanName, String annotation, Project project) {
for (PsiClass psiClass : getClassesAnnotatedWith(project, annotation)) {
final PsiAnnotation classAnnotation = psiClass.getAnnotation(annotation);
PsiAnnotationMemberValue attribute = classAnnotation.findAttributeValue("value");
if (attribute != null) {
if (attribute instanceof PsiReferenceExpressionImpl) {
//if the attribute value is field reference eg @bean(value = MyClass.BEAN_NAME)
final PsiField psiField = (PsiField) attribute.getReference().resolve();
String staticBeanName = StringUtils.stripDoubleQuotes(PsiTreeUtil.getChildOfAnyType(psiField, PsiLiteralExpression.class).getText());
if (beanName.equals(staticBeanName)) {
return Optional.of(psiClass);
}
} else {
final String value = attribute.getText();
if (beanName.equals(StringUtils.stripDoubleQuotes(value))) {
return Optional.of(psiClass);
}
}
} else {
if (Introspector.decapitalize(psiClass.getName()).equalsIgnoreCase(StringUtils.stripDoubleQuotes(beanName))) {
return Optional.of(psiClass);
}
}
}
return Optional.empty();
}
@Nullable
@Override
public PsiAnnotation addAnnotation(@NotNull @NonNls String qualifiedName) {
mModifierStatusMap.put(qualifiedName, Boolean.TRUE.toString());
// XXX: implement when needed
// translate String to PsiAnnotation
// return the newly constructed PsiAnnotation object
return null;
}
private String getFamilyFromPackageInfo(final PsiPackage psiPackage, final Module module) {
return of(FilenameIndex
.getFilesByName(psiPackage.getProject(), "package-info.java", GlobalSearchScope.moduleScope(module)))
.map(psiFile -> {
if (!PsiJavaFile.class
.cast(psiFile)
.getPackageName()
.equals(psiPackage.getQualifiedName())) {
return null;
}
final String[] family = { null };
PsiJavaFile.class.cast(psiFile).accept(new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitAnnotation(final PsiAnnotation annotation) {
super.visitAnnotation(annotation);
if (!COMPONENTS.equals(annotation.getQualifiedName())) {
return;
}
final PsiAnnotationMemberValue familyAttribute =
annotation.findAttributeValue("family");
if (familyAttribute == null) {
return;
}
family[0] = removeQuotes(familyAttribute.getText());
}
});
return family[0];
})
.filter(Objects::nonNull)
.findFirst()
.orElseGet(() -> {
final PsiPackage parent = psiPackage.getParentPackage();
if (parent == null) {
return null;
}
return getFamilyFromPackageInfo(parent, module);
});
}
protected Collection<? extends PsiElement> generatePsiElements(@NotNull PsiClass psiParentClass, @Nullable PsiMethod psiParentMethod, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiBuilderClass) {
final Collection<PsiMethod> result = new ArrayList<>();
final Collection<String> existedMethodNames = PsiClassUtil.collectClassMethodsIntern(psiBuilderClass).stream()
.filter(psiMethod -> PsiAnnotationSearchUtil.isNotAnnotatedWith(psiMethod, Tolerate.class))
.map(PsiMethod::getName).collect(Collectors.toSet());
BuilderHandler builderHandler = getBuilderHandler();
final List<BuilderInfo> builderInfos = builderHandler.createBuilderInfos(psiAnnotation, psiParentClass, psiParentMethod, psiBuilderClass);
//create constructor
result.addAll(builderHandler.createConstructors(psiBuilderClass, psiAnnotation));
// create builder methods
builderInfos.stream()
.filter(info -> info.notAlreadyExistingMethod(existedMethodNames))
.map(BuilderInfo::renderBuilderMethods)
.forEach(result::addAll);
// create 'build' method
final String buildMethodName = builderHandler.getBuildMethodName(psiAnnotation);
if (!existedMethodNames.contains(buildMethodName)) {
result.add(builderHandler.createBuildMethod(psiAnnotation, psiParentClass, psiParentMethod, psiBuilderClass, buildMethodName, builderInfos));
}
// create 'toString' method
if (!existedMethodNames.contains(ToStringProcessor.METHOD_NAME)) {
result.add(builderHandler.createToStringMethod(psiAnnotation, psiBuilderClass));
}
return result;
}
void validateOfParam(PsiClass psiClass, ProblemBuilder builder, PsiAnnotation psiAnnotation, Collection<String> ofProperty) {
for (String fieldName : ofProperty) {
if (!StringUtil.isEmptyOrSpaces(fieldName)) {
PsiField fieldByName = psiClass.findFieldByName(fieldName, false);
if (null == fieldByName) {
final String newPropertyValue = calcNewPropertyValue(ofProperty, fieldName);
builder.addWarning(String.format("The field '%s' does not exist", fieldName),
PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "of", newPropertyValue));
}
}
}
}
public static boolean hasAnnotation(final PsiModifierListOwner field, Class<? extends Annotation> annotationClass) {
for (PsiAnnotation psiAnnotation : field.getAnnotations()) {
if (isOfType(psiAnnotation, annotationClass)) {
return true;
}
}
return false;
}
@NotNull
public static BuilderElementHandler getHandlerFor(@NotNull PsiVariable psiVariable, @Nullable PsiAnnotation singularAnnotation) {
if (null == singularAnnotation) {
return new NonSingularHandler();
}
final PsiType psiType = psiVariable.getType();
final String qualifiedName = PsiTypeUtil.getQualifiedName(psiType);
if (!isInvalidSingularType(qualifiedName)) {
if (COLLECTION_TYPES.contains(qualifiedName)) {
return new SingularCollectionHandler(qualifiedName);
}
if (MAP_TYPES.contains(qualifiedName)) {
return new SingularMapHandler(qualifiedName);
}
if (GUAVA_COLLECTION_TYPES.contains(qualifiedName)) {
return new SingularGuavaCollectionHandler(qualifiedName, qualifiedName.contains("Sorted"));
}
if (GUAVA_MAP_TYPES.contains(qualifiedName)) {
return new SingularGuavaMapHandler(qualifiedName, qualifiedName.contains("Sorted"));
}
if (GUAVA_TABLE_TYPES.contains(qualifiedName)) {
return new SingularGuavaTableHandler(qualifiedName, false);
}
}
return new EmptyBuilderElementHandler();
}
static PsiAnnotation findAnnotation(PsiElement element, String annotationName) {
if (element instanceof PsiModifierListOwner) {
PsiModifierListOwner listOwner = (PsiModifierListOwner) element;
PsiModifierList modifierList = listOwner.getModifierList();
if (modifierList != null) {
for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) {
if (annotationName.equals(psiAnnotation.getQualifiedName())) {
return psiAnnotation;
}
}
}
}
return null;
}
@Override
public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) {
final PsiClass containingClass = psiField.getContainingClass();
if (null != containingClass) {
final boolean forceConstructorWithJavaDefaults = isForceConstructor(psiAnnotation);
final Collection<PsiField> params = getConstructorFields(containingClass, forceConstructorWithJavaDefaults);
if (PsiClassUtil.getNames(params).contains(psiField.getName())) {
return LombokPsiElementUsage.WRITE;
}
}
return LombokPsiElementUsage.NONE;
}
@NotNull
@Override
public Collection<PsiAnnotation> collectProcessedAnnotations(@NotNull PsiClass psiClass) {
final Collection<PsiAnnotation> result = super.collectProcessedAnnotations(psiClass);
addFieldsAnnotation(result, psiClass, FIELD_NAME_CONSTANTS_INCLUDE, FIELD_NAME_CONSTANTS_EXCLUDE);
return result;
}
private static String getPrefixFromAnnotation(PsiAnnotation configPropertiesAnnotation) {
String value = getAnnotationMemberValue(configPropertiesAnnotation, "prefix");
if (value == null) {
return null;
}
if (ConfigProperties.UNSET_PREFIX.equals(value) || value.isEmpty()) {
return null;
}
return value;
}