Java Code Examples for com.intellij.psi.PsiElement#equals()

@Override
public PsiElement bindToElement(PsiElement element) throws IncorrectOperationException {
  if (!(element instanceof BuildFile)) {
    return super.bindToElement(element);
  }
  if (element.equals(resolve())) {
    return myElement;
  }
  Label newPackageLabel = ((BuildFile) element).getPackageLabel();
  if (newPackageLabel == null) {
    return myElement;
  }
  String newPath = newPackageLabel.blazePackage().toString();
  String labelString = myElement.getStringContents();
  int colonIndex = labelString.indexOf(':');
  if (colonIndex != -1) {
    return handleRename("//" + newPath + labelString.substring(colonIndex));
  }
  // need to assume there's an implicit rule name
  return handleRename("//" + newPath + ":" + PathUtil.getFileName(labelString));
}
 

private static <T extends XQueryPsiElement, U extends XQueryPsiElement>boolean processChildrenIfPlaceIsNotPartOfSameBinding(T module,
        @NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent,
        @NotNull PsiElement place, Class<T> bindingClass, Class<U>... childClassesToSkip) {
    PsiElement commonParent = PsiTreeUtil.findCommonParent(place, module);
    T parentBinding = PsiTreeUtil.getParentOfType(place, bindingClass, true);
    XQueryExprSingle expressionInModule = PsiTreeUtil.getChildOfType(module, XQueryExprSingle.class);
    boolean inSameBinding = commonParent != null && commonParent.equals(module) && parentBinding != null && parentBinding.equals(module);
    Collection<T> childBindings = PsiTreeUtil.findChildrenOfType(expressionInModule, bindingClass);
    boolean partOfExpressionInBinding = childBindings.contains(parentBinding);
    if (inSameBinding || partOfExpressionInBinding) {
        return processor.execute(module, state);
    } else {
        if (!processor.execute(module, state)) {
            return false;
        } else {
            return ResolveUtil.processChildren(module, processor, state, lastParent, place, childClassesToSkip);
        }
    }
}
 

private void moveElementToEnd(PsiElement define, PsiElement parameter, PsiElement lastDefine, PsiElement lastParameter, DefineStatement defineStatement)
{
    if(lastDefine.equals(define))
    {
        return;
    }

    PsiElement ignoreComment = AMDPsiUtil.getIgnoreCommentAfterLiteral(define);
    PsiElement newElement = moveImportToEnd(defineStatement.getArguments(), defineStatement.getFunction().getParameterList(), define.getText(), parameter.getText(), lastDefine, lastParameter);

    if(ignoreComment != null)
    {
        defineStatement.getArguments().addAfter(ignoreComment, newElement);
    }

    AMDPsiUtil.removeSingleImport(new AMDImport((JSElement) define, (JSElement)parameter));
}
 

@SuppressWarnings("ConstantConditions")
@Nullable
private static TextRange getFileHeader(PsiElement file) {
    PsiElement first = file.getFirstChild();
    if (first instanceof PsiWhiteSpace) first = first.getNextSibling();
    PsiElement element = first;
    while (isComment(element)) {
        element = element.getNextSibling();
        if (element instanceof PsiWhiteSpace) {
            element = element.getNextSibling();
        } else {
            break;
        }
    }
    if (element == null) return null;
    if (element.getPrevSibling() instanceof PsiWhiteSpace) element = element.getPrevSibling();
    if (element == null || element.equals(first)) return null;
    return new UnfairTextRange(first.getTextOffset(), element.getTextOffset());
}
 

private void executeUpdateParameterInfo(PsiElement elementForUpdating, MyUpdateParameterInfoContext context, Runnable continuation) {
  PsiElement parameterOwner = context.getParameterOwner();
  if (parameterOwner != null && !parameterOwner.equals(elementForUpdating)) {
    context.removeHint();
    return;
  }

  runTask(myProject, ReadAction.nonBlocking(() -> {
    try {
      myHandler.updateParameterInfo(elementForUpdating, context);
      return elementForUpdating;
    }
    catch (IndexNotReadyException e) {
      DumbService.getInstance(myProject).showDumbModeNotification(CodeInsightBundle.message("parameter.info.indexing.mode.not.supported"));
    }
    return null;
  }).withDocumentsCommitted(myProject).expireWhen(() -> !myKeepOnHintHidden && !myHint.isVisible() && !ApplicationManager.getApplication().isHeadlessEnvironment() ||
                                                        getCurrentOffset() != context.getOffset() ||
                                                        !elementForUpdating.isValid()).expireWith(this), element -> {
    if (element != null && continuation != null) {
      context.applyUIChanges();
      continuation.run();
    }
  }, null, myEditor);
}
 

/**
 * Returns {@code true} if {@code child} is a descendant of the {@code parent}, {@code false} otherwise.
 */
private static boolean isChildOfParent(@NotNull PsiElement child, @NotNull PsiElement parent) {
  List<PsiElement> childElements = Lists.newArrayList(parent);
  while (!childElements.isEmpty()) {
    PsiElement element = childElements.remove(0);
    if (element.equals(child)) {
      return true;
    }
    childElements.addAll(Arrays.asList(element.getChildren()));
  }
  return false;
}
 

@Override
public boolean equals(final PsiElement o1, final PsiElement o2) {
  if (o1 instanceof PsiNamedElement && o2 instanceof PsiNamedElement) {
    return Comparing.equal(((PsiNamedElement)o1).getName(), ((PsiNamedElement)o2).getName());
  }
  return o1.equals(o2);
}
 

@Override
public boolean execute(@NotNull PsiElement element, ResolveState state) {
    boolean elementIsGoodCandidate = !element.equals(myElement) && element instanceof XQueryVarName &&
            !(element.getParent() instanceof XQueryVarRef);
    if (elementIsGoodCandidate) {
        XQueryQName<XQueryVarName> source = aXQueryQName(myElement.getVarName()).build();
        XQueryQName<XQueryVarName> checkedQName = aXQueryQName((XQueryVarName) element).build();
        if (source.equals(checkedQName)) {
            result = checkedQName.getNamedObject();
            return false;
        }
    }
    return true;
}
 

@SuppressWarnings("SimplifiableIfStatement")
@Override
protected boolean isRegionCollapsedByDefault(@NotNull ASTNode node) {
    final PsiElement element = SourceTreeToPsiMap.treeElementToPsi(node);
    if (element == null) return false;

    ANTLRv4FoldingSettings settings = ANTLRv4FoldingSettings.getInstance();

    if (RULE_BLOCKS.contains(node.getElementType())) return settings.isCollapseRuleBlocks();
    if (node.getElementType() == TOKENSSPEC) return settings.isCollapseTokens();

    if (element instanceof AtAction) return settings.isCollapseActions();

    if (element instanceof ANTLRv4FileRoot) {
        return settings.isCollapseFileHeader();
    }
    if (node.getElementType() == DOC_COMMENT_TOKEN) {

        PsiElement parent = element.getParent();

        if (parent instanceof ANTLRv4FileRoot) {
            PsiElement firstChild = parent.getFirstChild();
            if (firstChild instanceof PsiWhiteSpace) {
                firstChild = firstChild.getNextSibling();
            }
            if (element.equals(firstChild)) {
                return settings.isCollapseFileHeader();
            }
        }
        return settings.isCollapseDocComments();
    }
    if (isComment(element)) {
        return settings.isCollapseComments();
    }
    return false;

}
 

@Nullable
private PsiElement resolveAsIdentifier(Project project, BuckIdentifier buckIdentifier) {
  String text = buckIdentifier.getIdentifierToken().getText();
  BuckFunctionDefinition functionDefinition =
      PsiTreeUtil.getParentOfType(buckIdentifier, BuckFunctionDefinition.class);
  PsiElement resolved = null;
  while (functionDefinition != null) {
    resolved = BuckPsiUtils.findSymbolInPsiTree(functionDefinition.getParameterList(), text);
    if (resolved == null) {
      resolved = BuckPsiUtils.findSymbolInPsiTree(functionDefinition.getSuite(), text);
    }
    // back out one level of scoping and try again
    functionDefinition =
        PsiTreeUtil.getParentOfType(functionDefinition, BuckFunctionDefinition.class);
  }
  if (resolved == null) {
    resolved = BuckPsiUtils.findSymbolInPsiTree(buckIdentifier.getContainingFile(), text);
  }
  resolved =
      Optional.ofNullable(resolved)
          .map(e -> PsiTreeUtil.getParentOfType(e, BuckLoadArgument.class))
          .flatMap(
              buckLoadArgument ->
                  Optional.ofNullable(buckIdentifier.getContainingFile().getVirtualFile())
                      .map(
                          sourceFile ->
                              resolveAsLoadArgument(project, sourceFile, buckLoadArgument)))
          .orElse(resolved);
  if (resolved != null && !resolved.equals(buckIdentifier)) {
    return resolved;
  } else {
    return null;
  }
}
 

private static DefaultMutableTreeNode getNodeForElement(Object root, TreeModel model, PsiElement element) {
  if (root instanceof DefaultMutableTreeNode) {
    Object userObject = ((DefaultMutableTreeNode)root).getUserObject();
    if (userObject instanceof AbstractTreeNode) {
      AbstractTreeNode treeNode = (AbstractTreeNode)userObject;
      if (element.equals(treeNode.getValue())) return (DefaultMutableTreeNode)root;
      for (int i = 0; i < model.getChildCount(root); i++) {
        DefaultMutableTreeNode nodeForChild = getNodeForElement(model.getChild(root, i), model, element);
        if (nodeForChild != null) return nodeForChild;
      }
    }
  }
  return null;
}
 

@Nullable
public Instruction findInstructionByElement(final PsiElement element) {
  for (int i = instructions.size() - 1; i >= 0; i--) {
    final Instruction instruction = instructions.get(i);
    if (element.equals(instruction.getElement())) {
      return instruction;
    }
  }
  return null;
}
 

private static boolean isElement(@Nonnull PsiElement element, @Nullable TreePath path) {
  return element.equals(StructureViewComponent.unwrapValue(TreeUtil.getLastUserObject(FilteringTreeStructure.FilteringNode.class, path)));
}
 

private static String checkPsiEquivalence(@Nonnull PsiElement existing, @Nonnull PsiElement fresh) {
  if (!existing.equals(fresh) && !existing.isEquivalentTo(fresh) && !fresh.isEquivalentTo(existing) && (seemsToBeResolveTarget(existing) || seemsToBeResolveTarget(fresh))) {
    return reportProblem(existing, fresh);
  }
  return null;
}
 

private static boolean doesContain(final PsiElement container, PsiElement element) {
  while ((element = element.getParent()) != null) {
    if (container.equals(element)) return true;
  }
  return false;
}
 

private boolean isBeforeQueryBody(PsiElement topmostElement) {
    PsiElement previousQueryBody = PsiTreeUtil.getPrevSiblingOfType(topmostElement, XQueryQueryBody.class);
    return previousQueryBody == null && (!(topmostElement instanceof PsiErrorElement) || !topmostElement.equals(getLastChild(topmostElement)));
}
 

@Override
public boolean isReferenceTo(PsiElement element) {
	PsiElement resolvedElement = resolve();
	return resolvedElement != null
		&& resolvedElement.equals(element);
}