本文整理汇总了Java中com.intellij.psi.impl.PsiImplUtil类的典型用法代码示例。如果您正苦于以下问题:Java PsiImplUtil类的具体用法?Java PsiImplUtil怎么用?Java PsiImplUtil使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
PsiImplUtil类属于com.intellij.psi.impl包,在下文中一共展示了PsiImplUtil类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: applyAnnotations
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);
}
示例2: deleteChildInternal
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);
}
示例3: findChildByRole
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);
}
}
示例4: findEnumConstantListDelimiterPlace
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;
}
示例5: getNext
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;
}
示例6: findChildByRole
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);
}
}
示例7: deleteChildInternal
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);
}
示例8: findChildByRole
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();
}
}
示例9: addTypeUseAnnotations
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();
}
}
示例10: execute
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;
}
示例11: getRetentionPolicy
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;
}
示例12: isAnnotated
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;
}
示例13: findDeclaredAttributeValue
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);
}
示例14: isDeprecated
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);
}
示例15: registerReturnTypeConstraints
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));
}
}
}