com.intellij.psi.PsiClass#getParent ( )源码实例Demo

private boolean isPsiMethodCamelLanguage(PsiMethod method) {
    PsiType type = method.getReturnType();
    if (type != null && type instanceof PsiClassReferenceType) {
        PsiClassReferenceType clazz = (PsiClassReferenceType) type;
        PsiClass resolved = clazz.resolve();
        if (resolved != null) {
            boolean language = getCamelIdeaUtils().isCamelExpressionOrLanguage(resolved);
            // try parent using some weird/nasty stub stuff which is how complex IDEA AST
            // is when its parsing the Camel route builder
            if (!language) {
                PsiElement elem = resolved.getParent();
                if (elem instanceof PsiTypeParameterList) {
                    elem = elem.getParent();
                }
                if (elem instanceof PsiClass) {
                    language = getCamelIdeaUtils().isCamelExpressionOrLanguage((PsiClass) elem);
                }
            }
            return language;
        }
    }

    return false;
}
 

@NotNull
@Override
public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
  if (psiClass.getParent() instanceof PsiClass) {
    PsiClass parentClass = (PsiClass) psiClass.getParent();
    PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(parentClass, getSupportedAnnotationClasses());
    if (null != psiAnnotation && supportAnnotationVariant(psiAnnotation)) {
      ProblemEmptyBuilder problemBuilder = ProblemEmptyBuilder.getInstance();
      if (super.validate(psiAnnotation, parentClass, problemBuilder)) {
        final String typeName = FieldNameConstantsHandler.getTypeName(parentClass, psiAnnotation);
        if (typeName.equals(psiClass.getName())) {
          if (validate(psiAnnotation, parentClass, problemBuilder)) {
            List<? super PsiElement> result = new ArrayList<>();
            generatePsiElements(parentClass, psiClass, psiAnnotation, result);
            return result;
          }
        }
      }
    }
  }
  return Collections.emptyList();
}
 

private boolean verifyLombokAnnotationPresent(@NotNull PsiClass psiClass) {
  if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiClass, registeredAnnotationNames)) {
    return true;
  }
  Collection<PsiField> psiFields = PsiClassUtil.collectClassFieldsIntern(psiClass);
  for (PsiField psiField : psiFields) {
    if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiField, registeredAnnotationNames)) {
      return true;
    }
  }
  Collection<PsiMethod> psiMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
  for (PsiMethod psiMethod : psiMethods) {
    if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiMethod, registeredAnnotationNames)) {
      return true;
    }
  }
  final PsiElement psiClassParent = psiClass.getParent();
  if (psiClassParent instanceof PsiClass) {
    return verifyLombokAnnotationPresent((PsiClass) psiClassParent);
  }

  return false;
}
 

public void testUtilityClassModifiersInnerClass() {
  PsiFile file = myFixture.configureByFile(getTestName(false) + ".java");
  PsiClass innerClass = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiClass.class);

  assertNotNull(innerClass);
  assertNotNull(innerClass.getModifierList());

  PsiElement parent = innerClass.getParent();

  assertNotNull(parent);
  assertTrue(parent instanceof PsiClass);

  PsiClass parentClass = (PsiClass) parent;

  assertNotNull(parentClass.getModifierList());
  assertTrue("@UtilityClass should make parent class final", ((PsiClass) innerClass.getParent()).getModifierList().hasModifierProperty(PsiModifier.FINAL));
  assertTrue("@UtilityClass should make inner class static", innerClass.getModifierList().hasModifierProperty(PsiModifier.STATIC));
}
 

protected Optional<PsiClass> getSupportedParentClass(@NotNull PsiClass psiClass) {
  final PsiElement parentElement = psiClass.getParent();
  if (parentElement instanceof PsiClass && !(parentElement instanceof LombokLightClassBuilder)) {
    return Optional.of((PsiClass) parentElement);
  }
  return Optional.empty();
}