com.intellij.psi.util.PsiTreeUtil#skipSiblingsForward ( )源码实例Demo

public SimpleDuplicatesFinder(@Nonnull final PsiElement statement1,
                              @Nonnull final PsiElement statement2,
                              Collection<String> variables,
                              AbstractVariableData[] variableData) {
  myOutputVariables = variables;
  myParameters = new HashSet<>();
  for (AbstractVariableData data : variableData) {
    myParameters.add(data.getOriginalName());
  }
  myPattern = new ArrayList<>();
  PsiElement sibling = statement1;

  do {
    myPattern.add(sibling);
    if (sibling == statement2) break;
    sibling = PsiTreeUtil.skipSiblingsForward(sibling, PsiWhiteSpace.class, PsiComment.class);
  } while (sibling != null);
}
 

@Nullable
protected SimpleMatch isDuplicateFragment(@Nonnull final PsiElement candidate) {
  if (!canReplace(myReplacement, candidate)) return null;
  for (PsiElement pattern : myPattern) {
    if (PsiTreeUtil.isAncestor(pattern, candidate, false)) return null;
  }
  PsiElement sibling = candidate;
  final ArrayList<PsiElement> candidates = new ArrayList<>();
  for (int i = 0; i != myPattern.size(); ++i) {
    if (sibling == null) return null;

    candidates.add(sibling);
    sibling = PsiTreeUtil.skipSiblingsForward(sibling, PsiWhiteSpace.class, PsiComment.class);
  }
  if (myPattern.size() != candidates.size()) return null;
  if (candidates.size() <= 0) return null;
  final SimpleMatch match = new SimpleMatch(candidates.get(0), candidates.get(candidates.size() - 1));
  for (int i = 0; i < myPattern.size(); i++) {
    if (!matchPattern(myPattern.get(i), candidates.get(i), match)) return null;
  }
  return match;
}
 

static void deleteElement(PsiElement element, Document document) {
  ASTNode atParamNode = element.getNode();
  PsiElement nextMeaningfulNode = PsiTreeUtil
      .skipSiblingsForward(element, PsiWhiteSpace.class);
  nextMeaningfulNode = nextMeaningfulNode == null ? null
      : WhitespaceUtils.getFirstNonWhitespaceChild(nextMeaningfulNode);
  TextRange rangeToDelete = computeRangeToDelete(element, atParamNode, nextMeaningfulNode);
  document.deleteString(rangeToDelete.getStartOffset(), rangeToDelete.getEndOffset());
}
 

private static PsiElement skipOverDocComments(PsiElement startElement) {
    PsiElement elt = startElement.getNextSibling();
    if (elt == null) {
        return startElement;
    } else if (elt instanceof PsiComment) {
        IElementType commentType = ((PsiComment) elt).getTokenType();
        if (commentType == START_DOC_COMMENT) {
            return PsiTreeUtil.skipSiblingsForward(elt, PsiComment.class);
        }
    }

    return elt;
}
 

private static void addRangeDuplicates(final PsiElement scope,
                                       final PsiElement first,
                                       final PsiElement last,
                                       final PairConsumer<PsiElement, PsiElement> result) {
  final PsiElement[] children = getFilteredChildren(scope, null, true);
  NextChild:
  for (int i = 0; i < children.length;) {
    PsiElement child = children[i];
    if (child != first) {
      int j = i;
      PsiElement next = first;
      do {
        if (!areElementsEquivalent(children[j], next)) break;
        j++;
        if (next == last) {
          result.consume(child, children[j - 1]);
          i = j + 1;
          continue NextChild;
        }
        next = PsiTreeUtil.skipSiblingsForward(next, PsiWhiteSpace.class);
      }
      while (true);

      if (i == j) {
        addRangeDuplicates(child, first, last, result);
      }
    }

    i++;
  }
}
 

@Nullable
public static PsiElement getNextNonWhitespaceSibling(PsiElement element) {
  return PsiTreeUtil.skipSiblingsForward(element, PsiWhiteSpace.class);
}
 

@Nullable
public static PsiElement getNextMeaningSibling(PsiElement element) {
  return PsiTreeUtil.skipSiblingsForward(element, PsiWhiteSpace.class, PsiComment.class);
}