Java PsiImplUtil类代码示例

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@NotNull
public TypeInfo applyAnnotations(@NotNull StubBase<?> owner) {
  PsiModifierListStub modifierList = (PsiModifierListStub)owner.findChildStubByType(JavaStubElementTypes.MODIFIER_LIST);
  if (modifierList == null) return this;

  List<PsiAnnotationStub> annotationStubs = null;
  for (StubElement child : modifierList.getChildrenStubs()) {
    if (!(child instanceof PsiAnnotationStub)) continue;
    PsiAnnotationStub annotationStub = (PsiAnnotationStub)child;
    if (PsiImplUtil.isTypeAnnotation(annotationStub.getPsiElement())) {
      if (annotationStubs == null) annotationStubs = new SmartList<PsiAnnotationStub>();
      annotationStubs.add(annotationStub);
    }
  }

  PsiAnnotationStub[] stubArray = PsiAnnotationStub.EMPTY_ARRAY;
  if (annotationStubs != null) stubArray = annotationStubs.toArray(new PsiAnnotationStub[annotationStubs.size()]);
  return new TypeInfo(text, arrayCount, isEllipsis, stubArray);
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public void deleteChildInternal(@NotNull ASTNode child) {
  if (child.getElementType() == JAVA_CODE_REFERENCE){
    ASTNode next = PsiImplUtil.skipWhitespaceAndComments(child.getTreeNext());
    if (next != null && next.getElementType() == AND){
      deleteChildInternal(next);
    }
    else{
      ASTNode prev = PsiImplUtil.skipWhitespaceAndCommentsBack(child.getTreePrev());
      if (prev != null){
        if (prev.getElementType() == AND || prev.getElementType() == EXTENDS_KEYWORD){
          deleteChildInternal(prev);
        }
      }
    }
  }
  super.deleteChildInternal(child);
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public ASTNode findChildByRole(int role){
  LOG.assertTrue(ChildRole.isUnique(role));
  switch(role){
    default:
      return null;

    case ChildRole.WHILE_KEYWORD:
      return findChildByType(WHILE_KEYWORD);

    case ChildRole.LPARENTH:
      return findChildByType(LPARENTH);

    case ChildRole.CONDITION:
      return findChildByType(EXPRESSION_BIT_SET);

    case ChildRole.RPARENTH:
      return findChildByType(RPARENTH);

    case ChildRole.LOOP_BODY:
      return PsiImplUtil.findStatementChild(this);
  }
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Nullable
public ASTNode findEnumConstantListDelimiterPlace() {
  final ASTNode first = findChildByRole(ChildRole.LBRACE);
  if (first == null) return null;
  for (ASTNode child = first.getTreeNext(); child != null; child = child.getTreeNext()) {
    final IElementType childType = child.getElementType();
    if (PsiImplUtil.isWhitespaceOrComment(child) || childType == ERROR_ELEMENT || childType == ENUM_CONSTANT) {
    }
    else if (childType == COMMA) {
    }
    else if (childType == SEMICOLON) {
      return child;
    }
    else {
      return PsiImplUtil.skipWhitespaceAndCommentsBack(child.getTreePrev());
    }
  }

  return null;
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Nullable
private static PsiElement getNext(@NotNull PsiElement current, PsiElement elementUnderLabel, PsiElement elementAfterLabel) {
  PsiElement e = current;

  do {
    if (e == elementUnderLabel) {
      e = elementAfterLabel;
    }
    else {
      e = e.getNextSibling();
    }
  } while (PsiImplUtil.isLeafElementOfType(e, TokenSets.WHITE_SPACES_OR_COMMENTS));

  if (e instanceof GrLabeledStatement) return null;

  return e;
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public ASTNode findChildByRole(int role){
  LOG.assertTrue(ChildRole.isUnique(role));
  switch(role){
    default:
      return null;

    case ChildRole.DOC_COMMENT:
      return PsiImplUtil.findDocComment(this);

    case ChildRole.NAME:
      return findChildByType(JavaTokenType.IDENTIFIER);

    case ChildRole.ARGUMENT_LIST:
      return findChildByType(EXPRESSION_LIST);

    case ChildRole.ANONYMOUS_CLASS:
      return findChildByType(ENUM_CONSTANT_INITIALIZER);

    case ChildRole.MODIFIER_LIST:
      return findChildByType(JavaElementType.MODIFIER_LIST);
  }
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public void deleteChildInternal(@NotNull ASTNode child) {
  if (child.getElementType() == JavaElementType.JAVA_CODE_REFERENCE){
    ASTNode next = PsiImplUtil.skipWhitespaceAndComments(child.getTreeNext());
    if (next != null && next.getElementType() == JavaTokenType.COMMA){
      deleteChildInternal(next);
    }
    else{
      ASTNode prev = PsiImplUtil.skipWhitespaceAndCommentsBack(child.getTreePrev());
      if (prev != null){
        if (prev.getElementType() == JavaTokenType.COMMA
            || prev.getElementType() == getKeywordType()
            ){
          deleteChildInternal(prev);
        }
      }
    }
  }
  super.deleteChildInternal(child);
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public ASTNode findChildByRole(int role) {
  LOG.assertTrue(ChildRole.isUnique(role));
  switch(role){
    default:
      return null;

    case ChildRole.STATEMENT:
      return PsiImplUtil.findStatementChild(this);

    case ChildRole.COLON:
      return findChildByType(COLON);

    case ChildRole.LABEL_NAME:
      return getFirstChildNode();
  }
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
private void addTypeUseAnnotations(List<PsiAnnotation> list) {
  PsiElement parent = this;
  while (parent instanceof PsiTypeElement) {
    PsiElement left = PsiTreeUtil.skipSiblingsBackward(parent, PsiComment.class, PsiWhiteSpace.class, PsiAnnotation.class);

    if (left instanceof PsiModifierList) {
      List<PsiAnnotation> annotations = PsiImplUtil.getTypeUseAnnotations((PsiModifierList)left);
      if (annotations != null && !annotations.isEmpty()) {
        list.addAll(annotations);
      }
      break;
    }

    if (left != null) break;

    parent = parent.getParent();
  }
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
  PsiMember member = (PsiMember)element;
  if (!isInteresting(element)) return true;
  if (myPsiClass.isInterface() && isObjectMember(element)) return true;
  if (!myAllMembers.contains(member) && isVisible(member, myPsiClass)) {
    if (member instanceof PsiMethod) {
      PsiMethod psiMethod = (PsiMethod)member;
      if (shouldAdd(psiMethod)) {
        mapMethodBySignature(psiMethod);
        myAllMembers.add(PsiImplUtil.handleMirror(psiMethod));
      }
    }
    else {
      myAllMembers.add(PsiImplUtil.handleMirror(member));
    }
  }
  return true;
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Nullable
public static RetentionPolicy getRetentionPolicy(@NotNull PsiClass annotation) {
  PsiModifierList modifierList = annotation.getModifierList();
  if (modifierList != null) {
    PsiAnnotation retentionAnno = modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION);
    if (retentionAnno == null) return RetentionPolicy.CLASS;

    PsiAnnotationMemberValue policyRef = PsiImplUtil.findAttributeValue(retentionAnno, null);
    if (policyRef instanceof PsiReference) {
      PsiElement field = ((PsiReference)policyRef).resolve();
      if (field instanceof PsiEnumConstant) {
        String name = ((PsiEnumConstant)field).getName();
        try {
          return Enum.valueOf(RetentionPolicy.class, name);
        }
        catch (Exception e) {
          LOG.warn("Unknown policy: " + name);
        }
      }
    }
  }

  return null;
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
private static boolean isAnnotated(ASTNode element) {
  PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement)element.getPsi();

  PsiElement qualifier = ref.getQualifier();
  if (qualifier instanceof PsiJavaCodeReferenceElement) {
    if (((PsiJavaCodeReferenceElement)qualifier).resolve() instanceof PsiPackage) {
      return false;
    }
    if (PsiTreeUtil.getChildOfType(qualifier, PsiAnnotation.class) != null) {
      return true;
    }
  }

  PsiModifierList modifierList = PsiImplUtil.findNeighbourModifierList(ref);
  if (modifierList != null) {
    for (PsiAnnotation annotation : modifierList.getAnnotations()) {
      if (PsiImplUtil.findApplicableTarget(annotation, PsiAnnotation.TargetType.TYPE_USE) != null) {
        return true;
      }
    }
  }

  return false;
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
@Nullable
public PsiAnnotationMemberValue findDeclaredAttributeValue(@NonNls final String attributeName) {
  final GrAnnotationStub stub = getStub();
  if (stub != null) {
    final GrAnnotation stubbedPsi = stub.getPsiElement();
    final PsiAnnotationMemberValue value = PsiImplUtil.findDeclaredAttributeValue(stubbedPsi, attributeName);
    if (value == null) {
      return null;
    }
  }
  return PsiImplUtil.findDeclaredAttributeValue(this, attributeName);
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
@Override
public boolean isDeprecated() {
  final GrFieldStub stub = getStub();
  if (stub != null) {
    return stub.isDeprecatedByDocTag() || PsiImplUtil.isDeprecatedByAnnotation(this);
  }

  return PsiImplUtil.isDeprecatedByDocTag(this) || PsiImplUtil.isDeprecatedByAnnotation(this);
}
 

import com.intellij.psi.impl.PsiImplUtil; //导入依赖的package包/类
public void registerReturnTypeConstraints(PsiType returnType, PsiType targetType) {
  returnType = substituteWithInferenceVariables(returnType);
  final InferenceVariable inferenceVariable = shouldResolveAndInstantiate(returnType, targetType);
  if (inferenceVariable != null) {
    final PsiSubstitutor substitutor = resolveSubset(Collections.singletonList(inferenceVariable), mySiteSubstitutor);
    final PsiType substitutedReturnType = substitutor.substitute(inferenceVariable.getParameter());
    if (substitutedReturnType != null) {
      addConstraint(new TypeCompatibilityConstraint(targetType, PsiImplUtil.normalizeWildcardTypeByPosition(substitutedReturnType, (PsiExpression)myContext)));
    }
  } 
  else {
    if (FunctionalInterfaceParameterizationUtil.isWildcardParameterized(returnType)) {
      final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(returnType);
      final PsiClass psiClass = resolveResult.getElement();
      if (psiClass != null) {
        LOG.assertTrue(returnType instanceof PsiClassType);
        final PsiTypeParameter[] typeParameters = psiClass.getTypeParameters();
        InferenceVariable[] copy = initBounds(null, typeParameters);
        final PsiType substitutedCapture = PsiImplUtil.normalizeWildcardTypeByPosition(returnType, (PsiExpression)myContext);
        myIncorporationPhase.addCapture(copy, (PsiClassType)substituteWithInferenceVariables(returnType));
        addConstraint(new TypeCompatibilityConstraint(targetType, substitutedCapture));
      }
    } else {
      addConstraint(new TypeCompatibilityConstraint(targetType, myErased ? TypeConversionUtil.erasure(returnType) : returnType));
    }
  }
}