Datasets:

Mlxa

/

java_methods

like 0

XmlTag (final String text, XmlTag tag) { final Ref<XmlTag> enumerationTag = new Ref<>(); Processor<XmlTag> processor = xmlTag -> { if (text.equals(xmlTag.getAttributeValue(XmlUtil.VALUE_ATTR_NAME))) { enumerationTag.set(xmlTag); } return true; }; XmlUtil.processEnumerationValues(tag, processor); if (enumerationTag.get() == null) { final XmlElementDescriptorImpl elementDescriptor = (XmlElementDescriptorImpl)XmlUtil.findXmlDescriptorByType( tag, null ); TypeDescriptor type = elementDescriptor != null ? elementDescriptor.getType():null; if (type instanceof ComplexTypeDescriptor) { XmlUtil.processEnumerationValues(((ComplexTypeDescriptor)type).getDeclaration(), processor); } } return enumerationTag.get(); }

findEnumerationValue

XmlTag (PsiElement element, PsiElement originalElement) { XmlElementDescriptor descriptor = element.getUserData(DESCRIPTOR_KEY); XmlTag contextTag = null; XmlAttribute contextAttribute; if (descriptor == null && originalElement != null && (contextAttribute = PsiTreeUtil.getParentOfType(originalElement, XmlAttribute.class)) != null) { final XmlAttributeDescriptor attributeDescriptor = contextAttribute.getDescriptor(); if (attributeDescriptor instanceof XmlAttributeDescriptorImpl) { final XmlElementDescriptorImpl elementDescriptor = (XmlElementDescriptorImpl)XmlUtil.findXmlDescriptorByType( (XmlTag)attributeDescriptor.getDeclaration(), contextAttribute.getParent() ); TypeDescriptor type = elementDescriptor != null ? elementDescriptor.getType(contextAttribute) : null; if (type instanceof ComplexTypeDescriptor) { return ((ComplexTypeDescriptor)type).getDeclaration(); } } } if (descriptor == null && originalElement != null && (contextTag = PsiTreeUtil.getParentOfType(originalElement, XmlTag.class)) != null) { descriptor = contextTag.getDescriptor(); } if (descriptor instanceof XmlElementDescriptorImpl) { TypeDescriptor type = ((XmlElementDescriptorImpl)descriptor).getType(contextTag); if (type instanceof ComplexTypeDescriptor) { return ((ComplexTypeDescriptor)type).getDeclaration(); } } return null; }

getComplexOrSimpleTypeDefinition

PsiElement (final PsiManager psiManager, Object object, PsiElement element) { if (object instanceof XmlExtension.TagInfo) { return ((XmlExtension.TagInfo)object).getDeclaration(); } final PsiElement originalElement = element; boolean isAttrCompletion = element instanceof XmlAttribute; if (!isAttrCompletion && element instanceof XmlToken) { final IElementType tokenType = ((XmlToken)element).getTokenType(); if (tokenType == XmlTokenType.XML_EMPTY_ELEMENT_END || tokenType == XmlTokenType.XML_TAG_END) { isAttrCompletion = true; } else if (element.getParent() instanceof XmlAttribute) { isAttrCompletion = true; } } else if (!isAttrCompletion && element instanceof PsiWhiteSpace) { PsiElement prevSibling = element.getPrevSibling(); if (prevSibling instanceof XmlTag && prevSibling.getLastChild() instanceof PsiErrorElement) { isAttrCompletion = true; element = prevSibling; } } element = PsiTreeUtil.getParentOfType(element, XmlTag.class, false); if (element != null) { XmlTag xmlTag = (XmlTag)element; XmlElementDescriptor elementDescriptor; if (isAttrCompletion && object instanceof String) { elementDescriptor = xmlTag.getDescriptor(); if (elementDescriptor != null) { final XmlAttributeDescriptor attributeDescriptor = elementDescriptor.getAttributeDescriptor((String)object, xmlTag); if (attributeDescriptor != null) { final PsiElement declaration = attributeDescriptor.getDeclaration(); if (declaration != null) return declaration; } } } if (object == null) return null; try { @NonNls StringBuilder tagText = new StringBuilder(object.toString()); String namespacePrefix = XmlUtil.findPrefixByQualifiedName(object.toString()); String namespace = xmlTag.getNamespaceByPrefix(namespacePrefix); if (namespace.length() > 0) { tagText.append(" xmlns"); if (namespacePrefix.length() > 0) tagText.append(":").append(namespacePrefix); tagText.append("=\"").append(namespace).append("\""); } XmlTag tagFromText = XmlElementFactory.getInstance(xmlTag.getProject()).createTagFromText("<" + tagText +"/>"); XmlElementDescriptor parentDescriptor = xmlTag.getDescriptor(); elementDescriptor = (parentDescriptor!=null)?parentDescriptor.getElementDescriptor(tagFromText, xmlTag):null; if (elementDescriptor==null) { PsiElement parent = xmlTag.getParent(); if (parent instanceof XmlTag) { parentDescriptor = ((XmlTag)parent).getDescriptor(); elementDescriptor = (parentDescriptor!=null)?parentDescriptor.getElementDescriptor(tagFromText, (XmlTag)parent):null; } } if (elementDescriptor instanceof AnyXmlElementDescriptor) { final XmlNSDescriptor nsDescriptor = xmlTag.getNSDescriptor(xmlTag.getNamespaceByPrefix(namespacePrefix), true); elementDescriptor = (nsDescriptor != null)?nsDescriptor.getElementDescriptor(tagFromText):null; } // The very special case of xml file final PsiFile containingFile = xmlTag.getContainingFile(); final XmlFile xmlFile = XmlUtil.getContainingFile(xmlTag); if (xmlFile != containingFile) { final XmlTag rootTag = xmlFile.getDocument().getRootTag(); if (rootTag != null) { final XmlNSDescriptor nsDescriptor = rootTag.getNSDescriptor(rootTag.getNamespaceByPrefix(namespacePrefix), true); elementDescriptor = (nsDescriptor != null) ? nsDescriptor.getElementDescriptor(tagFromText) : null; } } if (elementDescriptor != null) { PsiElement declaration = elementDescriptor.getDeclaration(); if (declaration!=null) declaration.putUserData(DESCRIPTOR_KEY,elementDescriptor); return declaration; } } catch (IncorrectOperationException e) { LOG.error(e); } } if (object instanceof String && originalElement != null) { PsiElement result = findDeclWithName((String)object, originalElement); if (result == null && element != null) { XmlAttribute attribute = PsiTreeUtil.getParentOfType(originalElement, XmlAttribute.class, false); if (attribute != null) { XmlAttributeDescriptor descriptor = attribute.getDescriptor(); if (descriptor != null && descriptor.getDeclaration() instanceof XmlTag) { result = findEnumerationValue((String)object, (XmlTag)descriptor.getDeclaration()); } } } return result; } if (object instanceof XmlElementDescriptor) { return ((XmlElementDescriptor)object).getDeclaration(); } return null; }

getDocumentationElementForLookupItem

PsiElement (final String name, final @NotNull PsiElement element) { final XmlFile containingXmlFile = XmlUtil.getContainingFile(element); final XmlTag nearestTag = PsiTreeUtil.getParentOfType(element, XmlTag.class, false); final XmlFile xmlFile = nearestTag != null && containingXmlFile != null ? XmlUtil.findDescriptorFile(nearestTag, containingXmlFile) : containingXmlFile; if (xmlFile != null) { final PsiElement[] result = new PsiElement[1]; XmlUtil.processXmlElements( xmlFile, new PsiElementProcessor() { @Override public boolean execute(final @NotNull PsiElement element) { if (element instanceof XmlEntityDecl) { final XmlEntityDecl entityDecl = (XmlEntityDecl)element; if (entityDecl.isInternalReference() && name.equals(entityDecl.getName())) { result[0] = entityDecl; return false; } } else if (element instanceof XmlElementDecl) { final XmlElementDecl entityDecl = (XmlElementDecl)element; if (name.equals(entityDecl.getName())) { result[0] = entityDecl; return false; } } return true; } }, true ); return result[0]; } return null; }

findDeclWithName

boolean (final @NotNull PsiElement element) { if (element instanceof XmlEntityDecl) { final XmlEntityDecl entityDecl = (XmlEntityDecl)element; if (entityDecl.isInternalReference() && name.equals(entityDecl.getName())) { result[0] = entityDecl; return false; } } else if (element instanceof XmlElementDecl) { final XmlElementDecl entityDecl = (XmlElementDecl)element; if (name.equals(entityDecl.getName())) { result[0] = entityDecl; return false; } } return true; }

execute

boolean (@NotNull PsiElement element) { if (element instanceof XmlTag tag && ((XmlTag)element).getLocalName().equals(DOCUMENTATION_ELEMENT_LOCAL_NAME) ) { result = tag.getValue().getText().trim(); boolean withCData = false; if (result.startsWith(CDATA_PREFIX)) { result = result.substring(CDATA_PREFIX.length()); withCData = true; } result = StringUtil.trimEnd(result, CDATA_SUFFIX); result = result.trim(); if (withCData) { result = escapeDocumentationTextText(result); } final @NonNls String s = tag.getAttributeValue("source"); if (s != null) { if (s.startsWith("http:")) url = s; else if ("version".equals(s)) { version = result; result = null; return true; } } return false; } return true; }

execute

String (@NotNull String result) { return StringUtil.escapeXmlEntities(result).replaceAll("&apos;", "'").replaceAll("\n", "<br>\n"); }

escapeDocumentationTextText

List<String> (PsiElement element, PsiElement originalElement) { String result = getUrlForHtml(element, originalElement); DocumentationProvider styleProvider = getStyleProvider(); if (result == null && styleProvider != null) { return styleProvider.getUrlFor(element, originalElement); } return result != null ? Collections.singletonList(result) : null; }

getUrlFor

PsiElement (PsiManager psiManager, Object object, PsiElement element) { if (object instanceof PsiElement) { MdnSymbolDocumentation documentation = getDocumentation((PsiElement)object, element); if (documentation != null) { return (PsiElement)object; } } PsiElement result = doIfNotNull(findDescriptor(psiManager, object.toString(), element), PsiMetaData::getDeclaration); DocumentationProvider styleProvider = getStyleProvider(); if (result == null && styleProvider != null) { result = styleProvider.getDocumentationElementForLookupItem(psiManager, object, element); } if (result == null) { DocumentationProvider scriptProvider = getScriptDocumentationProvider(); if (scriptProvider != null) { result = scriptProvider.getDocumentationElementForLookupItem(psiManager, object, element); } } if (result == null && object instanceof String && element != null) { result = XmlDocumentationProvider.findDeclWithName((String)object, element); } return result; }

getDocumentationElementForLookupItem

boolean (@Nullable DocumentationProvider provider) { if (provider == null) return false; if (provider instanceof CompositeDocumentationProvider && ContainerUtil.or(((CompositeDocumentationProvider)provider).getAllProviders(), p -> p instanceof HtmlDocumentationProvider)) { Logger.getInstance(HtmlDocumentationProvider.class) .error( "An 'HtmlDocumentationProvider' is most likely registered through 'com.intellij.documentationProvider' extension point instead of 'com.intellij.lang.documentationProvider'. Recurrent behaviour has been prevented."); return false; } return true; }

checkProvider

PsiElement (PsiManager psiManager, String link, PsiElement context) { PsiElement result = doIfNotNull(findDescriptor(psiManager, link, context), PsiMetaData::getDeclaration); DocumentationProvider styleProvider = getStyleProvider(); if (result == null && styleProvider != null) { result = styleProvider.getDocumentationElementForLink(psiManager, link, context); } DocumentationProvider provider = getScriptDocumentationProvider(); if (result == null && provider != null && !DumbService.isDumb(psiManager.getProject())) { result = provider.getDocumentationElementForLink(psiManager, link, context); } return result; }

getDocumentationElementForLink

String (PsiElement element, PsiElement originalElement) { return doIfNotNull(getDocumentation(element, originalElement), MdnSymbolDocumentation::getUrl); }

getUrlForHtml

MdnSymbolDocumentation (PsiElement element, PsiElement originalElement) { XmlTag tagContext = findTagContext(originalElement); if (tagContext != null && !(tagContext instanceof HtmlTag)) return null; MdnSymbolDocumentation result = getHtmlMdnDocumentation(element, tagContext); if (result == null && tagContext == null) { PsiElement declaration = doIfNotNull(findDescriptor(element.getManager(), element.getText(), originalElement), PsiMetaData::getDeclaration); if (declaration != null) { result = getHtmlMdnDocumentation(declaration, null); } } return result; }

getDocumentation

PsiMetaData (PsiManager psiManager, String text, PsiElement context) { if (context != null && (context.getNode() == null || context.getNode().getElementType() == XmlTokenType.XML_END_TAG_START || context.getParent() instanceof XmlText)) { return null; } String key = StringUtil.toLowerCase(text); final boolean isStdTag = key != null && (MdnDocumentationKt.getHtmlMdnTagDocumentation(MdnApiNamespace.Html, key) != null || MdnDocumentationKt.getHtmlMdnTagDocumentation(MdnApiNamespace.Svg, key) != null || MdnDocumentationKt.getHtmlMdnTagDocumentation(MdnApiNamespace.MathML, key) != null); if (isStdTag && !isAttributeContext(context)) { try { final XmlTag tagFromText = XmlElementFactory.getInstance(psiManager.getProject()).createTagFromText("<" + key + " xmlns=\"" + XmlUtil.XHTML_URI + "\"/>"); return tagFromText.getDescriptor(); } catch (IncorrectOperationException ignore) { } } else { XmlTag tagContext = findTagContext(context); if (tagContext != null) { XmlElementDescriptor tagDescriptor = tagContext.getDescriptor(); return tagDescriptor != null ? tagDescriptor.getAttributeDescriptor(text, tagContext) : null; } } return null; }

findDescriptor

boolean (PsiElement context) { if (context instanceof XmlAttribute || (context instanceof XmlToken && ((XmlToken)context).getTokenType() == XmlTokenType.XML_TAG_END)) { return true; } if (context instanceof PsiWhiteSpace) { PsiElement prevSibling = context.getPrevSibling(); if (prevSibling instanceof XmlAttribute) { return true; } } return false; }

isAttributeContext

XmlTag (PsiElement context) { if (context instanceof PsiWhiteSpace) { PsiElement prevSibling = context.getPrevSibling(); if (prevSibling instanceof XmlTag) { return (XmlTag)prevSibling; } } return PsiTreeUtil.getParentOfType(context, XmlTag.class, false); }

findTagContext

XmlTag (PsiElement context) { XmlTag tagBeforeWhiteSpace = findTagBeforeWhiteSpace(context); if (tagBeforeWhiteSpace != null) return tagBeforeWhiteSpace; return super.findTagContext(context); }

findTagContext

XmlTag (PsiElement context) { if (context instanceof PsiWhiteSpace) { PsiElement parent = context.getParent(); if (parent instanceof XmlText) { PsiElement prevSibling = parent.getPrevSibling(); if (prevSibling instanceof XmlTag) return (XmlTag)prevSibling; } else if (parent instanceof XmlTag) { return (XmlTag)parent; } } return null; }

findTagBeforeWhiteSpace

boolean (PsiElement context) { if (findTagBeforeWhiteSpace(context) != null) return false; return super.isAttributeContext(context); }

isAttributeContext

FormattingModel (@NotNull FormattingContext formattingContext) { final PsiFile psiFile = formattingContext.getContainingFile(); CodeStyleSettings settings = formattingContext.getCodeStyleSettings(); PsiElement element = formattingContext.getPsiElement(); if (psiFile.getViewProvider() instanceof TemplateLanguageFileViewProvider viewProvider) { if (isTemplateFile(psiFile)) { Language templateDataLanguage = viewProvider.getTemplateDataLanguage(); if (templateDataLanguage != psiFile.getLanguage()) { return createDataLanguageFormattingModel( viewProvider.getPsi(templateDataLanguage), templateDataLanguage, settings, psiFile, Indent.getNoneIndent()); } } else if (element instanceof OuterLanguageElement && isOuterLanguageElement(element)) { try { FormattingModel model = createTemplateFormattingModel(psiFile, viewProvider, (OuterLanguageElement)element, settings, Indent.getNoneIndent()); if (model != null) return model; } catch (FragmentedTemplateException ie) { return createDummyModel(new ReadOnlyBlock(element.getNode()), settings, psiFile); } } } return super.createModel(formattingContext); }

createModel

DocumentBasedFormattingModel (Block rootBlock, CodeStyleSettings settings, @NotNull PsiFile psiFile) { return new DocumentBasedFormattingModel(rootBlock, psiFile.getProject(), settings, psiFile.getFileType(), psiFile); }

createDummyModel

FormattingModel (PsiFile file, CodeStyleSettings settings, XmlFormattingPolicy xmlFormattingPolicy, List<? extends PsiElement> elements, Indent indent) { try { return createTemplateFormattingModelInternal(file, settings, xmlFormattingPolicy, elements, indent); } catch (FragmentedTemplateException fte) { assert elements.size() > 0; int start = Integer.MAX_VALUE; int end = -1; for (PsiElement element : elements) { TextRange range = element.getTextRange(); if (range.getStartOffset() < start) start = range.getStartOffset(); if (range.getEndOffset() > end) end = range.getEndOffset(); } return createDummyModel(new CompositeTemplateBlock(new TextRange(start, end)), settings, file); } }

createTemplateFormattingModel

FormattingModel (PsiElement dataElement, Language language, CodeStyleSettings settings, @NotNull PsiFile psiFile, @Nullable Indent indent) { Block block = createDataLanguageRootBlock(dataElement, language, settings, getPolicy(settings, psiFile), psiFile, indent); return new DocumentBasedFormattingModel(block, psiFile.getProject(), settings, psiFile.getFileType(), psiFile); }

createDataLanguageFormattingModel

Block (PsiElement dataElement, Language language, CodeStyleSettings settings, XmlFormattingPolicy xmlFormattingPolicy, @NotNull PsiFile psiFile, Indent indent) { Block block; if (dataElement instanceof XmlTag) { block = createXmlTagBlock(dataElement.getNode(), null, null, xmlFormattingPolicy, indent); } else { if (language.isKindOf(XMLLanguage.INSTANCE)) { block = createXmlBlock(dataElement.getNode(), null, Alignment.createAlignment(), xmlFormattingPolicy, indent, dataElement.getTextRange()); } else { final FormattingModelBuilder builder = LanguageFormatting.INSTANCE.forContext(language, dataElement); if (builder != null && !isInsideXmlAttributeValue(dataElement)) { FormattingModel otherLanguageModel = builder.createModel(FormattingContext.create(dataElement, settings)); block = otherLanguageModel.getRootBlock(); } else { block = new ReadOnlyBlock(dataElement.getNode()); } } } return block; }

createDataLanguageRootBlock

XmlTagBlock (ASTNode node, @Nullable Wrap wrap, @Nullable Alignment alignment, XmlFormattingPolicy policy, @Nullable Indent indent) { return new TemplateXmlTagBlock(this, node, wrap, alignment, policy, indent); }

createXmlTagBlock

XmlBlock (ASTNode node, @Nullable Wrap wrap, @Nullable Alignment alignment, XmlFormattingPolicy policy, @Nullable Indent indent, @Nullable TextRange textRange) { return new TemplateXmlBlock(this, node, wrap, alignment, policy, indent, textRange); }

createXmlBlock

SyntheticBlock (List<Block> subBlocks, Block parent, Indent indent, XmlFormattingPolicy policy, Indent childIndent) { return new TemplateSyntheticBlock(subBlocks, parent, indent, policy, childIndent); }

createSyntheticBlock

List<Block> (List<Block> originalBlocks, boolean templateOnly, CodeStyleSettings settings, @NotNull XmlFormattingPolicy xmlFormattingPolicy) { return originalBlocks; }

afterMerge

XmlFormattingPolicy (CodeStyleSettings settings, PsiFile psiFile) { final FormattingDocumentModelImpl documentModel = FormattingDocumentModelImpl.createOn(psiFile); return new HtmlPolicy(settings, documentModel); }

getPolicy

boolean (PsiElement element) { XmlAttributeValue value = PsiTreeUtil.getParentOfType(element, XmlAttributeValue.class, true); return value != null; }

isInsideXmlAttributeValue

void (Indent indent) { myInheritedIndent = indent; }

setIndent

Indent () { return myInheritedIndent != null ? myInheritedIndent : super.getIndent(); }

getIndent

Spacing (Block child1, @NotNull Block child2) { if (child1 != null && isXmlBlock(child1) != isXmlBlock(child2)) { if (shouldKeepWhiteSpacesInside()) return Spacing.getReadOnlySpacing(); return Spacing.createSpacing(0, 1, 0, true, myXmlFormattingPolicy.getKeepBlankLines()); } return super.getSpacing(child1, child2); }

getSpacing

boolean (@NotNull Block block) { if (block instanceof TemplateXmlTagBlock || block instanceof TemplateXmlBlock) return true; if (block instanceof ASTBlock) { ASTNode node = ((ASTBlock)block).getNode(); return node != null && node.getPsi().getLanguage().isKindOf(XMLLanguage.INSTANCE); } return false; }

isXmlBlock

XmlTagBlock (@NotNull ASTNode child, Indent indent, Wrap wrap, Alignment alignment) { return myBuilder.createXmlTagBlock(child, wrap, alignment, myXmlFormattingPolicy, indent); }

createTagBlock

Block (@NotNull ArrayList<Block> localResult, Indent childrenIndent) { try { List<Block> merged = myBuilder.mergeWithTemplateBlocks(localResult, myXmlFormattingPolicy.getSettings(), myXmlFormattingPolicy, childrenIndent); return myBuilder.createSyntheticBlock(merged, this, Indent.getNoneIndent(), myXmlFormattingPolicy, childrenIndent); } catch (FragmentedTemplateException e) { return myBuilder.createSyntheticBlock(localResult, this, Indent.getNoneIndent(), myXmlFormattingPolicy, childrenIndent); } }

createSyntheticBlock

XmlBlock (@NotNull ASTNode child, @Nullable Indent indent, @Nullable Wrap wrap, @Nullable Alignment alignment, @Nullable TextRange range) { return myBuilder.createXmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, range); }

createSimpleChild

void (Indent indent) { myInheritedIndent = indent; }

setIndent

Indent () { return myInheritedIndent == null ? super.getIndent() : myInheritedIndent; }

getIndent

Indent () { return Indent.getIndent(myXmlFormattingPolicy.indentChildrenOf(getTag()) ? Indent.Type.NORMAL : Indent.Type.NONE, false, true); }

getChildrenIndent

List<PsiElement> (PsiElement outerLangElement) { PsiFile file = outerLangElement.getContainingFile(); if (file != null && file.getViewProvider() instanceof TemplateLanguageFileViewProvider viewProvider) { return findAllElementsInside(outerLangElement.getTextRange(), viewProvider, false); } return EMPTY_PSI_ELEMENT_LIST; }

findAllMarkupLanguageElementsInside

List<PsiElement> (@NotNull PsiElement outerLangElement, @NotNull TemplateLanguageFileViewProvider viewProvider) { return findAllElementsInside(outerLangElement.getTextRange(), viewProvider, true); }

findAllTemplateLanguageElementsInside

List<PsiElement> (@NotNull TextRange range, @NotNull TemplateLanguageFileViewProvider viewProvider, boolean fromTemplate) { return findAllElementsInside(range, viewProvider, fromTemplate ? viewProvider.getBaseLanguage() : viewProvider.getTemplateDataLanguage()); }

findAllElementsInside

List<PsiElement> (TextRange range, TemplateLanguageFileViewProvider viewProvider, Language language) { List<PsiElement> matchingElements = new ArrayList<>(); PsiElement currElement = viewProvider.findElementAt(range.getStartOffset(), language); while (currElement instanceof OuterLanguageElement) { currElement = currElement.getNextSibling(); } if (currElement != null) { currElement = findTopmostElementInRange(currElement, range); Pair<Integer, PsiElement> result = addElementSequence(currElement, range, matchingElements); int lastOffset = result.first; assert lastOffset >= 0 : "Failed to process elements in range: " + range; if (lastOffset < range.getEndOffset()) { matchingElements.addAll(findAllElementsInside(new TextRange(lastOffset, range.getEndOffset()), viewProvider, language)); } } return matchingElements; }

findAllElementsInside

PsiElement (@NotNull PsiElement original, TextRange fitToRange) { PsiElement currElement = original; PsiElement prevElement = original; while (currElement != null) { if ((currElement instanceof PsiFile) || !fitToRange.contains(currElement.getTextRange())) { if (!fitToRange.contains(prevElement.getTextRange())) { return original; } return prevElement; } prevElement = currElement; currElement = currElement.getParent(); } return original; }

findTopmostElementInRange

Block (List<? extends Block> blockList, List<? extends TextRange> originalRanges, TextRange range) { return getBlockContaining(blockList, originalRanges, range, 0); }

getBlockContaining

boolean (@NotNull PsiElement element) { if (element instanceof PsiErrorElement) { String description = ((PsiErrorElement)element).getErrorDescription(); for (String ignorableMessage : IGNORABLE_ERROR_MESSAGES) { if (ignorableMessage.equals(description)) return false; } return true; } return false; }

isErrorElement

TextRange () { return myTextRange; }

getTextRange

List<Block> () { return mySubBlocks; }

getSubBlocks

Wrap () { return null; }

getWrap

Indent () { return Indent.getNoneIndent(); }

getIndent

Alignment () { return null; }

getAlignment

Spacing (Block child1, @NotNull Block child2) { return null; }

getSpacing

ChildAttributes (int newChildIndex) { return new ChildAttributes(null, null); }

getChildAttributes

boolean () { return false; }

isIncomplete

boolean () { return false; }

isLeaf

boolean (@NotNull PsiElement element) { return false; }

containsFatalError

List<Block> () { try { return buildChildrenWithMerge(); } catch (FragmentedTemplateException e) { myContainsErrorElements = true; return AbstractBlock.EMPTY; } }

buildChildren

List<PsiElement> (@NotNull PsiElement xmlDocument) { List<PsiElement> children = new ArrayList<>(); PsiElement child = xmlDocument.getFirstChild(); while (child != null) { if (!myBuilder.isOuterLanguageElement(child)) { children.add(child); } child = child.getNextSibling(); } return children; }

getXmlDocumentChildren

boolean (@NotNull Block block) { if (block instanceof ASTBlock) { ASTNode node = ((ASTBlock)block).getNode(); if (node != null) { return TemplateFormatUtil.isErrorElement(node.getPsi()); } } return false; }

containsErrorElement

void (List<Block> result, ASTNode child) { Block templateLanguageBlock = createTemplateLanguageBlock(child); if (templateLanguageBlock instanceof BlockWithParent) { ((BlockWithParent)templateLanguageBlock).setParent(this); } result.add(templateLanguageBlock); }

addBlocksForNonMarkupChild

Block (ASTNode child) { return myBuilder.createTemplateLanguageBlock( child, mySettings, myXmlFormattingPolicy, getChildIndent(child), getChildAlignment(child), getChildWrap(child) ); }

createTemplateLanguageBlock

AbstractXmlTemplateFormattingModelBuilder () { return myBuilder; }

getBuilder

boolean (Block block) { if (block instanceof TemplateXmlTagBlock) { return ((TemplateXmlTagBlock)block).isScriptBlock(); } return false; }

isScriptBlock

Indent () { return Indent.getNoneIndent(); }

getChildIndent

boolean () { return myNode.getFirstChildNode() == null || myContainsErrorElements; }

isLeaf

void (@Nullable Indent indent) { myIndent = indent; }

setIndent

ChildAttributes (int newChildIndex) { return new ChildAttributes(Indent.getNormalIndent(), null); }

getChildAttributes

Indent () { return Indent.getNormalIndent(); }

getDefaultMarkupIndent

CodeStyleSettings () { return mySettings; }

getSettings

BlockWithParent () { return myParent; }

getParent

void (BlockWithParent newParent) { myParent = newParent; }

setParent

XmlFormattingPolicy () { return myXmlFormattingPolicy; }

getXmlFormattingPolicy

boolean () { return myContainsErrorElements; }

containsErrorElements

XmlBlock (@NotNull ASTNode child, @Nullable Indent indent, @Nullable Wrap wrap, @Nullable Alignment alignment, @Nullable TextRange range) { return myBuilder.createXmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, notNull(range, child.getTextRange())); }

createSimpleChild

XmlTagBlock (@NotNull ASTNode child, Indent indent, Wrap wrap, Alignment alignment) { return myBuilder.createXmlTagBlock(child, wrap, alignment, myXmlFormattingPolicy, indent); }

createTagBlock

Indent () { Indent indent = super.getChildDefaultIndent(); if (indent == null) { indent = Indent.getNoneIndent(); } return indent; }

getChildDefaultIndent

List<Block> () { return super.buildChildren(); }

buildChildrenNoMerge

List<Block> () { try { List<Block> childBlocks = patchTopLevelChildBlocks(buildChildrenNoMerge()); return myBuilder.mergeWithTemplateBlocks(childBlocks, myXmlFormattingPolicy.getSettings(), myXmlFormattingPolicy, getChildDefaultIndent()); } catch (FragmentedTemplateException fte) { return EMPTY_BLOCK_LIST; } }

buildChildren

List<Block> (List<Block> originalBlocks) { if (myNode.getPsi() instanceof PsiFile) { List<Block> patchedBlocks = new ArrayList<>(); for (Block block : originalBlocks) { if (block == originalBlocks.get(0) && block instanceof TemplateXmlBlock) { patchedBlocks.addAll(((TemplateXmlBlock)block).buildChildrenNoMerge()); } else { patchedBlocks.add(block); } } return patchedBlocks; } else { return originalBlocks; } }

patchTopLevelChildBlocks

void (Indent indent) { myIndent = indent; }

setIndent

Indent () { return myIndent != null ? myIndent : super.getIndent(); }

getIndent

Spacing (Block child1, @NotNull Block child2) { if (child1 instanceof TemplateLanguageBlock && child2 instanceof TemplateLanguageBlock) { return ((TemplateLanguageBlock)child1).getSpacing((TemplateLanguageBlock)child2); } if (child1 instanceof TemplateLanguageBlock || child2 instanceof TemplateLanguageBlock) { return Spacing.createSpacing(0, Integer.MAX_VALUE, 0, true, myXmlFormattingPolicy.getKeepBlankLines()); } return super.getSpacing(child1, child2); }

getSpacing

boolean () { if (isTextElement()) { for (ASTNode child = myNode.getFirstChildNode(); child != null; child = child.getTreeNext()) { if (myBuilder.isOuterLanguageElement(child.getPsi())) return true; } } return false; }

isTextContainingTemplateElements

List<Block> () { if (myNode.getElementType() != XmlElementType.XML_COMMENT) return EMPTY; final ArrayList<Block> result = new ArrayList<>(3); ASTNode child = myNode.getFirstChildNode(); boolean hasOuterLangElements = false; while (child != null) { if (child instanceof OuterLanguageElement) { hasOuterLangElements = true; } if (myBuilder.isOuterLanguageElement(child.getPsi())) { result.add(createTemplateFragmentWrapper(child)); } else { result.add(new XmlBlock(child, null, null, myXmlFormattingPolicy, getChildIndent(), null, isPreserveSpace())); } child = child.getTreeNext(); } return hasOuterLangElements ? result : EMPTY; }

splitComment

AnotherLanguageBlockWrapper (@NotNull ASTNode child) { return new AnotherLanguageBlockWrapper(child, myXmlFormattingPolicy, new ReadOnlyBlock(child), null, child.getStartOffset(), child.getTextRange()); }

createTemplateFragmentWrapper

Set<PsiFile> (DefaultMutableTreeNode root, ConfigFileSearcher... searchers) { final MultiMap<Module, PsiFile> files = new MultiMap<>(); final MultiMap<VirtualFile, PsiFile> jars = new MultiMap<>(); final MultiMap<VirtualFile, PsiFile> virtualFiles = new MultiMap<>(); for (ConfigFileSearcher searcher : searchers) { files.putAllValues(searcher.getFilesByModules()); jars.putAllValues(searcher.getJars()); virtualFiles.putAllValues(searcher.getVirtualFiles()); } final Set<PsiFile> psiFiles = new HashSet<>(buildModuleNodes(files, jars, root)); for (Map.Entry<VirtualFile, Collection<PsiFile>> entry : virtualFiles.entrySet()) { DefaultMutableTreeNode node = createFileNode(entry.getKey()); List<PsiFile> list = new ArrayList<>(entry.getValue()); list.sort(FILE_COMPARATOR); for (PsiFile file : list) { node.add(createFileNode(file)); } root.add(node); } return psiFiles; }

buildTree

DefaultMutableTreeNode (VirtualFile file) { final DefaultMutableTreeNode root = (DefaultMutableTreeNode)myTree.getModel().getRoot(); final DefaultMutableTreeNode treeNode = createFileNode(file); root.add(treeNode); DefaultTreeModel model = (DefaultTreeModel)myTree.getModel(); model.nodeStructureChanged(root); return treeNode; }

addFile

Set<PsiFile> (final MultiMap<Module, PsiFile> files, final MultiMap<VirtualFile, PsiFile> jars, DefaultMutableTreeNode root) { final HashSet<PsiFile> psiFiles = new HashSet<>(); final List<Module> modules = new ArrayList<>(files.keySet()); modules.sort(ModulesAlphaComparator.INSTANCE); for (Module module : modules) { DefaultMutableTreeNode moduleNode = createFileNode(module); root.add(moduleNode); if (files.containsKey(module)) { List<PsiFile> moduleFiles = new ArrayList<>(files.get(module)); MultiMap<FileType, PsiFile> filesByType = new MultiMap<>(); for (PsiFile file : moduleFiles) { filesByType.putValue(file.getFileType(), file); } if (hasNonEmptyGroups(filesByType)) { for (Map.Entry<FileType, Collection<PsiFile>> entry : filesByType.entrySet()) { DefaultMutableTreeNode fileTypeNode = createFileNode(entry.getKey()); moduleNode.add(fileTypeNode); addChildrenFiles(psiFiles, fileTypeNode, new ArrayList<>(entry.getValue())); } } else { addChildrenFiles(psiFiles, moduleNode, moduleFiles); } } } List<VirtualFile> sortedJars = new ArrayList<>(jars.keySet()); sortedJars.sort((o1, o2) -> StringUtil.naturalCompare(o1.getName(), o2.getName())); for (VirtualFile file : sortedJars) { if (!file.isValid()) continue; final List<PsiFile> list = new ArrayList<>(jars.get(file)); final PsiFile jar = list.get(0).getManager().findFile(file); if (jar != null) { final DefaultMutableTreeNode jarNode = createFileNode(jar); root.add(jarNode); list.sort(FILE_COMPARATOR); for (PsiFile psiFile : list) { jarNode.add(createFileNode(psiFile)); psiFiles.add(psiFile); } } } return psiFiles; }

buildModuleNodes

boolean (MultiMap<FileType, PsiFile> filesByType) { long nonEmptyGroups = filesByType.entrySet().stream().map(Map.Entry::getValue) .filter(files -> files != null && !files.isEmpty()).limit(2).count(); return nonEmptyGroups > 1; }

hasNonEmptyGroups

void (@NotNull Set<? super PsiFile> psiFiles, DefaultMutableTreeNode parentNode, @NotNull List<? extends PsiFile> moduleFiles) { moduleFiles.sort(FILE_COMPARATOR); for (PsiFile file : moduleFiles) { final DefaultMutableTreeNode fileNode = createFileNode(file); parentNode.add(fileNode); psiFiles.add(file); } }

addChildrenFiles

DefaultMutableTreeNode (Object file) { return new DefaultMutableTreeNode(file); }

createFileNode

void (Object value, boolean expanded, ColoredTreeCellRenderer renderer) { if (!(value instanceof DefaultMutableTreeNode)) return; final Object object = ((DefaultMutableTreeNode)value).getUserObject(); if (object instanceof FileType fileType) { final Icon icon = fileType.getIcon(); renderer.setIcon(icon); renderer.append(getFileTypeNodeName(fileType), SimpleTextAttributes.REGULAR_ATTRIBUTES); } else if (object instanceof Module module) { final Icon icon = ModuleType.get(module).getIcon(); renderer.setIcon(icon); final String moduleName = module.getName(); renderer.append(moduleName, SimpleTextAttributes.REGULAR_ATTRIBUTES); } else if (object instanceof PsiFile psiFile) { final Icon icon = psiFile.getIcon(0); renderer.setIcon(icon); final String fileName = psiFile.getName(); renderer.append(fileName, SimpleTextAttributes.REGULAR_ATTRIBUTES); final VirtualFile virtualFile = psiFile.getVirtualFile(); if (virtualFile != null) { renderPath(renderer, virtualFile); } } else if (object instanceof VirtualFile file) { renderer.setIcon(VirtualFilePresentation.getIcon(file)); renderer.append(file.getName(), SimpleTextAttributes.REGULAR_ATTRIBUTES); renderPath(renderer, file); } }

renderNode

void (ColoredTreeCellRenderer renderer, VirtualFile virtualFile) { String path = virtualFile.getPath(); //NON-NLS final int i = path.indexOf(JarFileSystem.JAR_SEPARATOR); if (i >= 0) { path = path.substring(i + JarFileSystem.JAR_SEPARATOR.length()); } renderer.append(" (" + StringUtil.trimEnd(StringUtil.trimEnd(path, virtualFile.getName()), "/") + ")", SimpleTextAttributes.GRAYED_ATTRIBUTES); }

renderPath

void (JTree tree) { TreeSpeedSearch.installOn(tree, false, treePath -> { final Object object = ((DefaultMutableTreeNode)treePath.getLastPathComponent()).getUserObject(); if (object instanceof Module) { return ((Module)object).getName(); } else if (object instanceof PsiFile) { return ((PsiFile)object).getName(); } else if (object instanceof VirtualFile) { return ((VirtualFile)object).getName(); } else { return ""; } }); }

installSearch

void () { searchWithFiles(); }

search

List<PsiFile> () { myFiles.clear(); myJars.clear(); PsiManager psiManager = PsiManager.getInstance(myProject); List<PsiFile> files = new ArrayList<>(); for (PsiFile file : search(myModule, myProject)) { files.add(file); VirtualFile jar = JarFileSystem.getInstance().getVirtualFileForJar(file.getVirtualFile()); if (jar != null) { myJars.putValue(jar, file); } else { Module module = ModuleUtilCore.findModuleForPsiElement(file); if (module != null) { myFiles.putValue(module, file); } else { VirtualFile virtualFile = file.getVirtualFile(); myVirtualFiles.putValue(virtualFile.getParent(), psiManager.findFile(virtualFile)); } } } return files; }

searchWithFiles

ActionUpdateThread () { return ActionUpdateThread.BGT; }

getActionUpdateThread

String () { return XmlBundle.message("xml.intention.split.tag.text"); }

getText

String () { return XmlBundle.message("xml.intention.split.tag.family"); }

getFamilyName