Java Code Examples for com.intellij.psi.util.PsiTreeUtil#findCommonParent()

private static Template buildTemplate(@NotNull XmlAttribute attr, List<XmlTag> refs) {
        //XmlFile containingFile = (XmlFile)attr.getContainingFile();
        PsiElement commonParent = PsiTreeUtil.findCommonParent(refs);
        TemplateBuilderImpl builder = new TemplateBuilderImpl(attr);

        XmlAttributeValue attrValue = attr.getValueElement();
        PsiElement valuePsi = attrValue.getFirstChild().getNextSibling();

        String flowNameValue = new String(attrValue.getValue());
        builder.replaceElement(valuePsi,"PrimaryVariable", new TextExpression(flowNameValue), true);
/*

        for (XmlTag ref : refs) {
            if (ref.getContainingFile().equals(attr.getContainingFile())) {
                XmlAttribute nextAttr = ref.getAttribute(MuleConfigConstants.NAME_ATTRIBUTE);
                XmlAttributeValue nextValue = nextAttr.getValueElement();
                PsiElement nextValuePsi = nextValue.getFirstChild().getNextSibling();
                builder.replaceElement(nextValuePsi, "OtherVariable", "PrimaryVariable",false);
            }
        }
*/

        return builder.buildInlineTemplate();
    }
 

@NotNull
public PsiElement[] getElementsToSurround(PsiFile psiFile, int i, int i1) {
  PsiElement psiElement = psiFile.findElementAt(i);
  PsiElement psiElement2 = psiFile.findElementAt(i1 - 1);
  PsiElement commonParent = PsiTreeUtil.findCommonParent(psiElement, psiElement2);

  PsiElement firstStatementStart = findStamentNodeFromParent(psiElement, commonParent);
  PsiElement lastStatementStart = findStamentNodeFromParent(psiElement2, commonParent);
  if (firstStatementStart != null && lastStatementStart != null) {

    List<PsiElement> result = new ArrayList<PsiElement>();
    for(PsiElement e = firstStatementStart; e != null ; e = e.getNextSibling()) {
      result.add(e);
      if (e == lastStatementStart) break;
    }

    if (result.get(result.size() - 1) == lastStatementStart) {
      return result.toArray(new PsiElement[result.size()]);
    }
  }

  System.out.println(firstStatementStart);
  return new PsiElement[] {commonParent};
}
 

@Nullable
public UsageInfo getUsageInfo() {
  if (myElementAnchors.length == 1) {
    final PsiElement element = myElementAnchors[0].retrieve();
    if (element == null || !element.isValid()) return null;
    return new UsageInfo(element);
  }

  PsiElement parent = PsiTreeUtil.findCommonParent(getElements());
  if (parent == null) return null;
  int offs = parent.getTextRange().getStartOffset();

  final int startOffsetInParent = getStartOffset() - offs;
  final int endOffsetInParent = getEndOffset() - offs;
  if (startOffsetInParent < 0) return null;
  if (endOffsetInParent < startOffsetInParent) return null;
  return new UsageInfo(parent, startOffsetInParent, endOffsetInParent);
}
 

@Nullable
static ASTNode findContainingNode(@Nonnull PsiFile file, @Nullable TextRange range) {
  Language language = file.getLanguage();
  if (range == null) return null;
  final FileViewProvider viewProvider = file.getViewProvider();
  final PsiElement startElement = viewProvider.findElementAt(range.getStartOffset(), language);
  final PsiElement endElement = viewProvider.findElementAt(range.getEndOffset() - 1, language);
  final PsiElement commonParent = startElement != null && endElement != null ? PsiTreeUtil.findCommonParent(startElement, endElement) : null;
  ASTNode node = null;
  if (commonParent != null) {
    node = commonParent.getNode();
    // Find the topmost parent with the same range.
    ASTNode parent = node.getTreeParent();
    while (parent != null && parent.getTextRange().equals(commonParent.getTextRange())) {
      node = parent;
      parent = parent.getTreeParent();
    }
  }
  if (node == null) {
    node = file.getNode();
  }
  return node;
}
 

@Nullable
@RequiredUIAccess
private static PsiElement[] getElementList(@Nonnull PsiFile file, int rangeStart, int rangeEnd) {
  PsiElement startElement = file.findElementAt(rangeStart);
  if (startElement == null) return null;
  PsiElement endElement = rangeEnd > rangeStart ? file.findElementAt(rangeEnd - 1) : startElement;
  if (endElement == null) return null;
  PsiElement element = PsiTreeUtil.findCommonParent(startElement, endElement);
  while (element != null) {
    List<MoveElementLeftRightHandler> handlers = MoveElementLeftRightHandler.EXTENSION.allForLanguage(element.getLanguage());
    for (MoveElementLeftRightHandler handler : handlers) {
      PsiElement[] elementList = handler.getMovableSubElements(element);
      if (elementList.length > 1) {
        Arrays.sort(elementList, BY_OFFSET);
        PsiElement first = elementList[0];
        PsiElement last = elementList[elementList.length - 1];
        if (rangeStart >= first.getTextRange().getStartOffset() && rangeEnd <= last.getTextRange().getEndOffset() &&
            (rangeStart >= first.getTextRange().getEndOffset() || rangeEnd <= last.getTextRange().getStartOffset())) {
          return elementList;
        }
      }
    }
    element = element.getParent();
  }
  return null;
}
 

@Nullable
public static PsiElement findCommonParent(final PsiElement root, final int startOffset, final int endOffset) {
  if (startOffset == endOffset) return null;
  final PsiElement left = findElementAtInRoot(root, startOffset);
  PsiElement right = findElementAtInRoot(root, endOffset - 1);
  if (left == null || right == null) return null;

  PsiElement commonParent = PsiTreeUtil.findCommonParent(left, right);
  if (commonParent == null) {
    LOG.error("No common parent for "+left+" and "+right+"; root: "+root+"; startOffset: "+startOffset+"; endOffset: "+endOffset);
  }
  LOG.assertTrue(commonParent.getTextRange() != null, commonParent);

  PsiElement parent = commonParent.getParent();
  while (parent != null && commonParent.getTextRange().equals(parent.getTextRange())) {
    commonParent = parent;
    parent = parent.getParent();
  }
  return commonParent;
}
 

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);
        }
    }
}
 

@Nullable
public static DotNetExpression getSelectedExpression(@Nonnull final Project project,
		@Nonnull PsiFile file,
		@Nonnull final PsiElement element1,
		@Nonnull final PsiElement element2)
{
	PsiElement parent = PsiTreeUtil.findCommonParent(element1, element2);
	if(parent == null)
	{
		return null;
	}
	if(parent instanceof DotNetExpression)
	{
		return (DotNetExpression) parent;
	}
	return PsiTreeUtil.getParentOfType(parent, DotNetExpression.class);
}
 

public boolean shouldHighlightErrorElement(@NotNull PsiErrorElement element) {
	PsiFile templateLanguageFile = PsiUtilCore.getTemplateLanguageFile(element.getContainingFile());
	if (templateLanguageFile == null) {
		return true;
	}
	Language language = templateLanguageFile.getLanguage();
	if (language != LatteLanguage.INSTANCE) {
		return true;
	}
	if (element.getParent() instanceof XmlElement || element.getParent() instanceof CssElement) {
		return false;
	}
	if (element.getParent().getLanguage() == LatteLanguage.INSTANCE) {
		return true;
	}
	PsiElement nextSibling;
	for (nextSibling = PsiTreeUtil.nextLeaf(element); nextSibling instanceof PsiWhiteSpace; nextSibling = nextSibling.getNextSibling());

	PsiElement psiElement = nextSibling == null ? null : PsiTreeUtil.findCommonParent(nextSibling, element);
	boolean nextIsOuterLanguageElement = nextSibling instanceof OuterLanguageElement || nextSibling instanceof LatteMacroClassic;
	return !nextIsOuterLanguageElement || psiElement == null || psiElement instanceof PsiFile;
}
 

@Nullable
public static HaxeExpression getSelectedExpression(@NotNull final Project project,
                                                   @NotNull PsiFile file,
                                                   @NotNull final PsiElement element1,
                                                   @NotNull final PsiElement element2) {
  PsiElement parent = PsiTreeUtil.findCommonParent(element1, element2);
  if (parent == null) {
    return null;
  }
  if (parent instanceof HaxeExpression) {
    return (HaxeExpression)parent;
  }
  return PsiTreeUtil.getParentOfType(parent, HaxeExpression.class);
}
 

public static <T extends XQueryPsiElement> boolean processChildren(PsiElement element, PsiScopeProcessor processor,
        ResolveState substitutor, PsiElement lastParent, PsiElement place, Class<T>... childClassesToSkip) {
    PsiElement run = lastParent == null ? element.getLastChild() : lastParent.getPrevSibling();
    while (run != null) {
        if (!isAnyOf(run, childClassesToSkip) &&PsiTreeUtil.findCommonParent(place, run) != run && !run.processDeclarations(processor, substitutor,
                null, place)) {
            return false;
        }
        run = run.getPrevSibling();
    }

    return true;
}
 

@RequiredReadAction
@Override
public PsiElement getPsiElement() {
  PsiElement startElement = getStartElement();
  if (myEndSmartPointer == null) {
    return startElement;
  }
  PsiElement endElement = getEndElement();
  if (startElement == endElement) {
    return startElement;
  }
  if (startElement == null || endElement == null) return null;
  return PsiTreeUtil.findCommonParent(startElement, endElement);
}
 

private static PsiElement scopeElementsUnion(PsiElement element1, PsiElement element2) {
  if (PsiTreeUtil.isAncestor(element1, element2, false)) return element1;
  if (PsiTreeUtil.isAncestor(element2, element1, false)) return element2;
  PsiElement commonParent = PsiTreeUtil.findCommonParent(element1, element2);
  if (commonParent == null) return null;
  return commonParent;
}
 

@RequiredReadAction
private static <T extends PsiElement> T findElementInRange(@Nonnull PsiFile file,
                                                           int startOffset,
                                                           int endOffset,
                                                           @Nonnull Class<T> klass,
                                                           @Nonnull Language language,
                                                           @Nullable PsiElement initialElement) {
  PsiElement element1 = file.getViewProvider().findElementAt(startOffset, language);
  PsiElement element2 = file.getViewProvider().findElementAt(endOffset - 1, language);
  if (element1 instanceof PsiWhiteSpace) {
    startOffset = element1.getTextRange().getEndOffset();
    element1 = file.getViewProvider().findElementAt(startOffset, language);
  }
  if (element2 instanceof PsiWhiteSpace) {
    endOffset = element2.getTextRange().getStartOffset();
    element2 = file.getViewProvider().findElementAt(endOffset - 1, language);
  }
  if (element2 == null || element1 == null) return null;
  final PsiElement commonParent = PsiTreeUtil.findCommonParent(element1, element2);
  final T element =
          ReflectionUtil.isAssignable(klass, commonParent.getClass())
          ? (T)commonParent : PsiTreeUtil.getParentOfType(commonParent, klass);

  if (element == initialElement) {
    return element;
  }

  if (element == null || element.getTextRange().getStartOffset() != startOffset || element.getTextRange().getEndOffset() != endOffset) {
    return null;
  }
  return element;
}
 

@RequiredReadAction
private static LineRange expandLineRangeToCoverPsiElements(final LineRange range, Editor editor, final PsiFile file)
{
	Pair<PsiElement, PsiElement> psiRange = getElementRange(editor, file, range);
	if(psiRange == null)
	{
		return null;
	}
	final PsiElement parent = PsiTreeUtil.findCommonParent(psiRange.getFirst(), psiRange.getSecond());
	Pair<PsiElement, PsiElement> elementRange = getElementRange(parent, psiRange.getFirst(), psiRange.getSecond());
	if(elementRange == null)
	{
		return null;
	}
	int endOffset = elementRange.getSecond().getTextRange().getEndOffset();
	Document document = editor.getDocument();
	if(endOffset > document.getTextLength())
	{
		LOG.assertTrue(!PsiDocumentManager.getInstance(file.getProject()).isUncommited(document));
		LOG.assertTrue(PsiDocumentManagerImpl.checkConsistency(file, document));
	}
	int endLine;
	if(endOffset == document.getTextLength())
	{
		endLine = document.getLineCount();
	}
	else
	{
		endLine = editor.offsetToLogicalPosition(endOffset).line + 1;
		endLine = Math.min(endLine, document.getLineCount());
	}
	int startLine = Math.min(range.startLine, editor.offsetToLogicalPosition(elementRange.getFirst().getTextOffset()).line);
	endLine = Math.max(endLine, range.endLine);
	return new LineRange(startLine, endLine);
}
 

@Nonnull
private static String getCommandText(@Nonnull Project project, @Nonnull Editor editor) {
  TextRange selectedRange = EditorUtil.getSelectionInAnyMode(editor);
  Document document = editor.getDocument();
  if (selectedRange.isEmpty()) {
    int line = document.getLineNumber(selectedRange.getStartOffset());
    selectedRange = TextRange.create(document.getLineStartOffset(line), document.getLineEndOffset(line));

    // try detect a non-trivial composite PSI element if there's a PSI file
    PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
    if (file != null && file.getFirstChild() != null && file.getFirstChild() != file.getLastChild()) {
      PsiElement e1 = file.findElementAt(selectedRange.getStartOffset());
      PsiElement e2 = file.findElementAt(selectedRange.getEndOffset());
      while (e1 != e2 && (e1 instanceof PsiWhiteSpace || e1 != null && StringUtil.isEmptyOrSpaces(e1.getText()))) {
        e1 = ObjectUtils.chooseNotNull(e1.getNextSibling(), PsiTreeUtil.getDeepestFirst(e1.getParent()));
      }
      while (e1 != e2 && (e2 instanceof PsiWhiteSpace || e2 != null && StringUtil.isEmptyOrSpaces(e2.getText()))) {
        e2 = ObjectUtils.chooseNotNull(e2.getPrevSibling(), PsiTreeUtil.getDeepestLast(e2.getParent()));
      }
      if (e1 instanceof LeafPsiElement) e1 = e1.getParent();
      if (e2 instanceof LeafPsiElement) e2 = e2.getParent();
      PsiElement parent = e1 == null ? e2 : e2 == null ? e1 : PsiTreeUtil.findCommonParent(e1, e2);
      if (parent != null && parent != file) {
        selectedRange = parent.getTextRange();
      }
    }
  }
  return document.getText(selectedRange);
}
 

@Nullable
protected PsiElement checkLocalScope() {
  final SearchScope searchScope = PsiSearchHelper.SERVICE.getInstance(myElementToRename.getProject()).getUseScope(myElementToRename);
  if (searchScope instanceof LocalSearchScope) {
    final PsiElement[] elements = ((LocalSearchScope)searchScope).getScope();
    return PsiTreeUtil.findCommonParent(elements);
  }

  return null;
}
 

@Override
public void update(AnActionEvent anActionEvent)
{
    //final VirtualFile file = CommonDataKeys.VIRTUAL_FILE.getData(anActionEvent.getDataContext());
    final PsiFile psiFile = anActionEvent.getData(CommonDataKeys.PSI_FILE);
    final Editor editor = anActionEvent.getData(CommonDataKeys.EDITOR);

    boolean inMuleFlow = false;

    if (psiFile != null)
    {
        PsiElement muleFlowTagElement = null;
        XmlTag muleFlowTag = null;

        if (editor != null && editor.getSelectionModel() != null && editor.getSelectionModel().hasSelection()) {
            PsiElement startPsi = psiFile.findElementAt(editor.getSelectionModel().getSelectionStart());
            PsiElement endPsi = psiFile.findElementAt(editor.getSelectionModel().getSelectionEnd());

            muleFlowTagElement = PsiTreeUtil.findCommonParent(startPsi, endPsi);
        } else {//Just find element under the caret
            muleFlowTagElement = anActionEvent.getData(LangDataKeys.PSI_ELEMENT);
        }

        if (muleFlowTagElement != null && muleFlowTagElement instanceof XmlTag) {
            muleFlowTag = (XmlTag)muleFlowTagElement;
        } else {
            muleFlowTag = PsiTreeUtil.getParentOfType(muleFlowTagElement, XmlTag.class);
        }

        inMuleFlow = MuleConfigUtils.isInTopLevelTag(muleFlowTag);
    }

    anActionEvent.getPresentation().setEnabled(inMuleFlow);
    anActionEvent.getPresentation().setVisible(inMuleFlow);
}
 

public static PsiElement[] findStatementsInRange(PsiFile file, int startOffset, int endOffset)
{
	PsiElement element1 = file.findElementAt(startOffset);
	PsiElement element2 = file.findElementAt(endOffset - 1);
	if(element1 instanceof PsiWhiteSpace)
	{
		startOffset = element1.getTextRange().getEndOffset();
		element1 = file.findElementAt(startOffset);
	}
	if(element2 instanceof PsiWhiteSpace)
	{
		endOffset = element2.getTextRange().getStartOffset();
		element2 = file.findElementAt(endOffset - 1);
	}

	if(element1 != null && element2 != null)
	{
		PsiElement commonParent = PsiTreeUtil.findCommonParent(element1, element2);
		if(commonParent instanceof DotNetExpression)
		{
			return new PsiElement[]{commonParent};
		}
	}

	final DotNetStatement statements = PsiTreeUtil.getParentOfType(element1, DotNetStatement.class);
	if(statements == null || element1 == null || element2 == null || !PsiTreeUtil.isAncestor(statements, element2, true))
	{
		return PsiElement.EMPTY_ARRAY;
	}

	// don't forget about leafs (ex. ';')
	final ASTNode[] astResult = UsefulPsiTreeUtil.findChildrenRange(statements.getNode().getChildren(null), startOffset, endOffset);
	return ContainerUtil.map2Array(astResult, PsiElement.class, new Function<ASTNode, PsiElement>()
	{
		@Override
		public PsiElement fun(ASTNode node)
		{
			return node.getPsi();
		}
	});
}
 

@Override
@RequiredReadAction
public boolean checkAvailable(@Nonnull final Editor editor, @Nonnull final PsiFile file, @Nonnull final MoveInfo info, final boolean down)
{
	if(!(file instanceof CSharpFile))
	{
		return false;
	}

	boolean available = super.checkAvailable(editor, file, info, down);
	if(!available)
	{
		return false;
	}

	LineRange oldRange = info.toMove;
	final Pair<PsiElement, PsiElement> psiRange = getElementRange(editor, file, oldRange);
	if(psiRange == null)
	{
		return false;
	}

	final DotNetNamedElement firstMember = PsiTreeUtil.getParentOfType(psiRange.getFirst(), DotNetNamedElement.class, false);
	final DotNetNamedElement lastMember = PsiTreeUtil.getParentOfType(psiRange.getSecond(), DotNetNamedElement.class, false);
	if(firstMember == null || lastMember == null)
	{
		return false;
	}

	LineRange range;
	if(firstMember == lastMember)
	{
		range = memberRange(firstMember, editor, oldRange);
		if(range == null)
		{
			return false;
		}
		range.firstElement = range.lastElement = firstMember;
	}
	else
	{
		final PsiElement parent = PsiTreeUtil.findCommonParent(firstMember, lastMember);
		if(parent == null)
		{
			return false;
		}

		final Pair<PsiElement, PsiElement> combinedRange = getElementRange(parent, firstMember, lastMember);
		if(combinedRange == null)
		{
			return false;
		}
		final LineRange lineRange1 = memberRange(combinedRange.getFirst(), editor, oldRange);
		if(lineRange1 == null)
		{
			return false;
		}
		final LineRange lineRange2 = memberRange(combinedRange.getSecond(), editor, oldRange);
		if(lineRange2 == null)
		{
			return false;
		}
		range = new LineRange(lineRange1.startLine, lineRange2.endLine);
		range.firstElement = combinedRange.getFirst();
		range.lastElement = combinedRange.getSecond();
	}
	Document document = editor.getDocument();

	PsiElement sibling = down ? range.lastElement.getNextSibling() : range.firstElement.getPrevSibling();
	if(sibling == null)
	{
		return false;
	}
	sibling = firstNonWhiteElement(sibling, down);
	final boolean areWeMovingClass = range.firstElement instanceof CSharpTypeDeclaration;
	info.toMove = range;
	try
	{
		LineRange intraClassRange = moveInsideOutsideClassPosition(editor, sibling, down, areWeMovingClass);
		if(intraClassRange == null)
		{
			info.toMove2 = new LineRange(sibling, sibling, document);
			if(down && sibling.getNextSibling() == null)
			{
				return false;
			}
		}
		else
		{
			info.toMove2 = intraClassRange;
		}
	}
	catch(IllegalMoveException e)
	{
		info.toMove2 = null;
	}
	return true;
}