Java PsiUtil.isJavaToken方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void delete() throws IncorrectOperationException {
  final PsiElement next = PsiTreeUtil.skipSiblingsForward(this, PsiWhiteSpace.class, PsiComment.class);
  if (PsiUtil.isJavaToken(next, JavaTokenType.SEMICOLON)) {
    getParent().deleteChildRange(this, next);
    return;
  }

  final PsiElement prev = PsiTreeUtil.skipSiblingsBackward(this, PsiWhiteSpace.class, PsiComment.class);
  if (PsiUtil.isJavaToken(prev, JavaTokenType.SEMICOLON)) {
    getParent().deleteChildRange(prev, this);
    return;
  }

  super.delete();
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException {
  final PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
  if (element != null && PsiUtil.isJavaToken(element, JavaTokenType.CHARACTER_LITERAL)) {
    final String text = StringUtil.unescapeStringCharacters(element.getText());
    final int length = text.length();
    if (length > 1 && text.charAt(0) == '\'' && text.charAt(length - 1) == '\'') {
      final String value = StringUtil.escapeStringCharacters(text.substring(1, length - 1));
      final PsiExpression expression = JavaPsiFacade.getElementFactory(project).createExpressionFromText('"' + value + '"', null);
      final PsiElement literal = expression.getFirstChild();
      if (literal != null && PsiUtil.isJavaToken(literal, JavaTokenType.STRING_LITERAL)) {
        element.replace(literal);
      }
    }
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static List<PsiAnnotation[]> collectAnnotations(PsiElement anchor, PsiAnnotation stopAt) {
  List<PsiAnnotation[]> annotations = ContainerUtil.newSmartList();

  List<PsiAnnotation> current = null;
  boolean found = (stopAt == null), stop = false;
  for (PsiElement child = anchor.getNextSibling(); child != null; child = child.getNextSibling()) {
    if (child instanceof PsiComment || child instanceof PsiWhiteSpace) continue;

    if (child instanceof PsiAnnotation) {
      if (current == null) current = ContainerUtil.newSmartList();
      current.add((PsiAnnotation)child);
      if (child == stopAt) found = stop = true;
      continue;
    }

    if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET)) {
      annotations.add(ContainerUtil.toArray(current, PsiAnnotation.ARRAY_FACTORY));
      current = null;
      if (stop) return annotations;
    }
    else if (!PsiUtil.isJavaToken(child, JavaTokenType.RBRACKET)) {
      break;
    }
  }

  // annotation is misplaced (either located before the anchor or has no following brackets)
  return !found || stop ? null : annotations;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void visitAnnotationArrayInitializer(final PsiArrayInitializerMemberValue initializer) {
  if (PsiUtil.isLanguageLevel7OrHigher(initializer)) return;
  final PsiElement lastElement = PsiTreeUtil.skipSiblingsBackward(initializer.getLastChild(), PsiWhiteSpace.class, PsiComment.class);
  if (lastElement != null && PsiUtil.isJavaToken(lastElement, JavaTokenType.COMMA)) {
    final String message = InspectionsBundle.message("inspection.compiler.javac.quirks.anno.array.comma.problem");
    final String fixName = InspectionsBundle.message("inspection.compiler.javac.quirks.anno.array.comma.fix");
    myHolder.registerProblem(lastElement, message, new RemoveElementQuickFix(fixName));
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private void findTopLevelSemicolons(PsiElement element) {
  for (PsiElement sibling = element.getFirstChild(); sibling != null; sibling = skipForwardWhiteSpacesAndComments(sibling)) {
    if (PsiUtil.isJavaToken(sibling, JavaTokenType.SEMICOLON)) {
      registerError(sibling, ProblemHighlightType.LIKE_UNUSED_SYMBOL);
    }
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
public boolean match(PsiElement patternNode, PsiElement matchedNode, MatchContext context) {
  if (patternNode instanceof PsiComment) {
      return myCommentHandler.match(patternNode, matchedNode, context);
  }

  if (!super.match(patternNode,matchedNode,context)) return false;
  final PsiDeclarationStatement dcl = (PsiDeclarationStatement)patternNode;
  if (matchedNode instanceof PsiDeclarationStatement) {
    return GlobalMatchingVisitor.continueMatchingSequentially(
      new SsrFilteringNodeIterator(patternNode.getFirstChild()),
      new SsrFilteringNodeIterator(matchedNode.getFirstChild()),
      context
    );
  }
  final PsiElement[] declared = dcl.getDeclaredElements();

  // declaration statement could wrap class or dcl
  if (declared.length > 0 && !(matchedNode.getParent() instanceof PsiDeclarationStatement) /* skip twice matching for child*/) {
    if (!(matchedNode instanceof PsiField)) {
      return GlobalMatchingVisitor.continueMatchingSequentially(
        new ArrayBackedNodeIterator(declared),
        new CountingNodeIterator(declared.length, new SsrFilteringNodeIterator(matchedNode)),
        context
      );
    }

    // special handling for multiple fields in single declaration
    final PsiElement sibling = PsiTreeUtil.skipSiblingsBackward(matchedNode, PsiWhiteSpace.class);
    if (PsiUtil.isJavaToken(sibling, JavaTokenType.COMMA)) {
      return false;
    }
    final List<PsiElement> matchNodes = new ArrayList<PsiElement>();
    matchNodes.add(matchedNode);
    PsiElement node = matchedNode;
    node = PsiTreeUtil.skipSiblingsForward(node, PsiWhiteSpace.class);
    while (PsiUtil.isJavaToken(node, JavaTokenType.COMMA)) {
      node = PsiTreeUtil.skipSiblingsForward(node, PsiWhiteSpace.class);
      if (node != null) {
        matchNodes.add(node);
      }
      node = PsiTreeUtil.skipSiblingsForward(node, PsiWhiteSpace.class);
    }
    boolean result = GlobalMatchingVisitor.continueMatchingSequentially(
      new ArrayBackedNodeIterator(declared),
      new ArrayBackedNodeIterator(matchNodes.toArray(new PsiElement[matchNodes.size()])),
      context
    );

    if (result && declared[0] instanceof PsiVariable) {
      // we may have comments behind to match!

      final PsiElement lastChild = dcl.getLastChild();
      if (lastChild instanceof PsiComment) {
        final PsiElement[] fieldChildren = matchedNode.getChildren();

        result = context.getPattern().getHandler(lastChild).match(
          lastChild,
          fieldChildren[fieldChildren.length-1],
          context
        );
      }
    }
    return result;
  }
  return false;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public boolean isAvailable(@NotNull final Project project, final Editor editor, final PsiFile file) {
  final PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
  return PsiUtil.isJavaToken(element, JavaTokenType.CHARACTER_LITERAL);
}