类com.intellij.psi.PsiAnnotation源码实例Demo

下面列出了怎么用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 };

}
 
源代码4 项目: intellij   文件: TestSizeFinder.java
@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);
}
 
源代码5 项目: here-be-dragons   文件: AnnotationDetector.java
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;
}
 
源代码6 项目: litho   文件: PsiAnnotationProxyUtils.java
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;
}
 
源代码8 项目: sqlitemagic   文件: SqliteMagicInspection.java
@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());
    }
  }
}
 
源代码9 项目: camel-idea-plugin   文件: BeanUtils.java
/**
 * 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));
    }
  }
}
 
源代码11 项目: aircon   文件: CyclicDefaultValueConfigDetector.java
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;
}
 
源代码14 项目: aircon   文件: ConfigElementsUtils.java
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;
}
 
源代码16 项目: camel-idea-plugin   文件: JavaCamelIdeaUtils.java
@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;
}
 
源代码18 项目: intellij   文件: TestSizeFinder.java
@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;
}
 
源代码19 项目: otto-intellij-plugin   文件: SubscriberMetadata.java
@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;
}
 
源代码20 项目: camel-idea-plugin   文件: JavaClassUtils.java
/**
 * 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;
}
 
源代码22 项目: component-runtime   文件: SuggestionServiceImpl.java
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));
      }
    }
  }
}
 
源代码25 项目: aircon   文件: ElementUtils.java
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();
}
 
源代码27 项目: dagger-intellij-plugin   文件: PsiConsultantImpl.java
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;
}
 
 类所在包
 同包方法