Datasets:

Mlxa

/

java_methods

like 0

ChildAttributes (final int newChildIndex) { PsiElement element = myNode.getPsi(); if (element instanceof PsiFile || element instanceof XmlDocument || element instanceof XmlProlog) { return new ChildAttributes(Indent.getNoneIndent(), null); } else { return super.getChildAttributes(newChildIndex); } }

getChildAttributes

XmlFormattingPolicy () { return myXmlFormattingPolicy; }

getPolicy

boolean () { return myTag != null && myXmlFormattingPolicy.keepWhiteSpacesInsideTag(myTag); }

shouldKeepWhiteSpacesInside

ASTNode (final List<? extends Block> subBlocks) { LOG.assertTrue(!subBlocks.isEmpty()); final Block firstBlock = subBlocks.get(0); if (firstBlock instanceof AbstractBlock) { return ((AbstractBlock)firstBlock).getNode(); } else { return getFirstNode(firstBlock.getSubBlocks()); } }

getFirstNode

ASTNode (final List<? extends Block> subBlocks) { LOG.assertTrue(!subBlocks.isEmpty()); final Block lastBlock = subBlocks.get(subBlocks.size() - 1); if (lastBlock instanceof AbstractBlock) { return ((AbstractBlock)lastBlock).getNode(); } else { return getLastNode(lastBlock.getSubBlocks()); } }

getLastNode

boolean () { return myEndTreeNode.getElementType() == XmlTokenType.XML_TAG_END; }

isEndOfTag

boolean (final IElementType type1, final IElementType type2) { if ((type1 == XmlTokenType.XML_NAME || type1 == XmlTokenType.XML_TAG_NAME) && (type2 == XmlTokenType.XML_TAG_END)) return true; if ((type1 == XmlTokenType.XML_NAME || type1 == XmlTokenType.XML_TAG_NAME) && (type2 == XmlTokenType.XML_EMPTY_ELEMENT_END)) { return true; } if (isAttributeElementType(type1) && type2 == XmlTokenType.XML_EMPTY_ELEMENT_END) return true; return isAttributeElementType(type1) && type2 == XmlTokenType.XML_TAG_END; }

isXmlTagName

boolean (IElementType nodeType) { return nodeType == XmlElementType.XML_TEXT || nodeType == XmlElementType.HTML_RAW_TEXT; }

isTextNode

boolean () { return isTextNode(myEndTreeNode.getElementType()) || myEndTreeNode.getElementType() == XmlTokenType.XML_DATA_CHARACTERS || myEndTreeNode.getElementType() == XmlTokenType.XML_CHAR_ENTITY_REF || myEndTreeNode.getElementType() == XmlElementType.XML_ENTITY_REF; }

endsWithText

boolean () { return isTagDescription(myStartTreeNode); }

isTagDescription

boolean (final ASTNode startTreeNode) { return startTreeNode.getElementType() == XmlTokenType.XML_START_TAG_START || startTreeNode.getElementType() == XmlTokenType.XML_END_TAG_START; }

isTagDescription

boolean () { return isTextNode(myStartTreeNode.getElementType()) || myStartTreeNode.getElementType() == XmlTokenType.XML_DATA_CHARACTERS || myStartTreeNode.getElementType() == XmlTokenType.XML_CHAR_ENTITY_REF || myStartTreeNode.getElementType() == XmlElementType.XML_ENTITY_REF; }

startsWithText

boolean () { if (endsWithText()) return true; if (isEndOfTag() && myXmlFormattingPolicy.isTextElement(getTag())) return true; return isTextTag(myEndTreeNode); }

endsWithTextElement

XmlTag () { return myTag; }

getTag

boolean () { if (startsWithText()) return true; if (isStartOfTag() && myXmlFormattingPolicy.isTextElement(getTag())) return true; return isTextTag(myStartTreeNode); }

startsWithTextElement

boolean (final ASTNode treeNode) { return isXmlTag(treeNode) && myXmlFormattingPolicy.isTextElement((XmlTag)SourceTreeToPsiMap.treeElementToPsi(treeNode)); }

isTextTag

boolean (final ASTNode treeNode) { return (treeNode.getPsi() instanceof XmlTag); }

isXmlTag

boolean () { return isTagDescription(myStartTreeNode); }

isStartOfTag

TextRange (final List<? extends Block> subBlocks) { return new TextRange(subBlocks.get(0).getTextRange().getStartOffset(), subBlocks.get(subBlocks.size() - 1).getTextRange().getEndOffset()); }

calculateTextRange

boolean () { return getSubBlocks().get(getSubBlocks().size() - 1).isIncomplete(); }

isIncomplete

boolean () { return isXmlTag(myStartTreeNode); }

startsWithTag

XmlTag () { return (XmlTag)myStartTreeNode.getPsi(); }

getStartTag

boolean () { return isXmlTag(myEndTreeNode); }

endsWithTag

boolean () { return false; }

isJspTextBlock

boolean () { return false; }

isJspxTextBlock

boolean () { return (myStartTreeNode == myEndTreeNode) && (myStartTreeNode instanceof OuterLanguageElement); }

isOuterLanguageBlock

boolean () { return false; }

isLeaf

boolean () { return isCDATA(myStartTreeNode.getFirstChildNode()); }

startsWithCDATA

boolean (final ASTNode node) { return node != null && node.getElementType() == XmlElementType.XML_CDATA; }

isCDATA

boolean () { return myStartTreeNode.getElementType() == XmlTokenType.XML_CDATA_START && myEndTreeNode.getElementType() == XmlTokenType.XML_CDATA_END; }

containsCDATA

boolean () { return isCDATA(myStartTreeNode.getLastChildNode()); }

endsWithCDATA

boolean () { final List<Block> subBlocks = getSubBlocks(); final Block lastBlock = subBlocks.get(subBlocks.size() - 1); if (lastBlock instanceof XmlTagBlock) { return insertLineFeedAfter(((XmlTagBlock)lastBlock).getTag()); } if (endsWithText()) { return insertLineFeedAfter(myTag); } return false; }

insertLineFeedAfter

boolean (final XmlTag tag) { return myXmlFormattingPolicy.getWrappingTypeForTagBegin(tag) == WrapType.ALWAYS; }

insertLineFeedAfter

boolean (final IElementType elementType) { return elementType instanceof IXmlAttributeElementType; }

isAttributeElementType

boolean (ASTNode node, boolean defaultValue) { if (node.getPsi() instanceof XmlTag tag) { XmlAttribute spaceAttr = tag.getAttribute("xml:space"); if (spaceAttr != null) { String value = spaceAttr.getValue(); if ("preserve".equals(value)) { return true; } if ("default".equals(value)) { return false; } } } return defaultValue; }

shouldPreserveSpace

boolean () { return myPreserveSpace; }

isPreserveSpace

WrapType (final int type) { if (type == CommonCodeStyleSettings.DO_NOT_WRAP) return WrapType.NONE; if (type == CommonCodeStyleSettings.WRAP_ALWAYS) return WrapType.ALWAYS; if (type == CommonCodeStyleSettings.WRAP_AS_NEEDED) return WrapType.NORMAL; return WrapType.CHOP_DOWN_IF_LONG; }

getWrapType

boolean (IElementType elementType) { return elementType == XmlElementType.XML_TEXT || elementType == XmlElementType.HTML_RAW_TEXT; }

isTextNode

Wrap (final XmlTag parent) { return Wrap.createWrap(myXmlFormattingPolicy.getWrappingTypeForTagEnd(parent), true); }

getTagEndWrapping

Wrap (final ASTNode child, final Wrap tagBeginWrap, final Wrap attrWrap, final Wrap textWrap) { if (isTextNode(myNode.getElementType())) return textWrap; final IElementType elementType = child.getElementType(); if (isAttributeElementType(elementType)) return attrWrap; if (elementType == XmlTokenType.XML_START_TAG_START) return tagBeginWrap; if (elementType == XmlTokenType.XML_END_TAG_START) { final PsiElement parent = SourceTreeToPsiMap.treeElementToPsi(child.getTreeParent()); if (parent instanceof XmlTag tag) { if (canWrapTagEnd(tag)) { return getTagEndWrapping(tag); } } return null; } if (isTextNode(elementType) || elementType == XmlTokenType.XML_DATA_CHARACTERS) { ASTNode previous = FormatterUtil.getPreviousNonWhitespaceSibling(child); if (previous == null || !isTextNode(previous.getElementType())) { return myXmlFormattingPolicy.allowWrapBeforeText() ? textWrap : null; } return textWrap; } return null; }

chooseWrap

boolean (final XmlTag tag) { return hasSubTags(tag); }

canWrapTagEnd

boolean (XmlTag tag) { PsiElement child = tag.getFirstChild(); while (child != null) { if (child instanceof XmlTag) { return true; } child = child.getNextSibling(); } return false; }

hasSubTags

XmlTag () { return getTag(myNode); }

getTag

XmlTag (final ASTNode node) { final PsiElement element = SourceTreeToPsiMap.treeElementToPsi(node); if (element instanceof XmlTag) { return (XmlTag)element; } else { return null; } }

getTag

Wrap (final XmlTag tag) { return Wrap.createWrap(myXmlFormattingPolicy.getWrappingTypeForTagBegin(tag), true); }

createTagBeginWrapping

boolean (final PsiElement tag) { final TextRange tagRange = tag.getTextRange(); for (XmlTag subTag : JBIterable.of(myNode.getPsi().getChildren()).filter(XmlTag.class)) { final TextRange subTagRange = subTag.getTextRange(); if (subTagRange.getEndOffset() < tagRange.getStartOffset()) continue; if (subTagRange.getStartOffset() > tagRange.getEndOffset()) return true; if (tagRange.getStartOffset() > subTagRange.getStartOffset() && tagRange.getEndOffset() < subTagRange.getEndOffset()) return false; if (tagRange.getEndOffset() > subTagRange.getStartOffset() && tagRange.getEndOffset() < subTagRange.getEndOffset()) return false; } return true; }

doesNotIntersectSubTagsWith

boolean (final PsiElement tag) { final ASTNode closingTagStart = XmlChildRole.CLOSING_TAG_START_FINDER.findChild(myNode); final ASTNode startTagStart = XmlChildRole.START_TAG_END_FINDER.findChild(myNode); if (closingTagStart == null && startTagStart == null) { return tag.getTextRange().getEndOffset() <= myNode.getTextRange().getEndOffset(); } else if (closingTagStart == null) { return false; } else { return tag.getTextRange().getEndOffset() <= closingTagStart.getTextRange().getEndOffset(); } }

containsTag

ASTNode (final List<Block> result, final @NotNull ASTNode child, final Wrap wrap, final Alignment alignment, final Indent indent) { ASTNode resultNode = child; ASTNode currentChild = child.getTreeNext(); while (currentChild != null && currentChild.getElementType() != XmlTokenType.XML_END_TAG_START) { if (!containsWhiteSpacesOnly(currentChild)) { currentChild = processChild(result, currentChild, wrap, alignment, indent); resultNode = currentChild; } if (currentChild != null) { currentChild = currentChild.getTreeNext(); } } return resultNode; }

processAllChildrenFrom

void (@NotNull ASTNode child, @Nullable Indent indent, @NotNull List<? super Block> result, @Nullable Wrap wrap, @Nullable Alignment alignment) { if (isXmlTag(child)) { result.add(createTagBlock(child, indent != null ? indent : Indent.getNoneIndent(), wrap, alignment)); } else if (child.getElementType() == XmlElementType.XML_DOCTYPE) { result.add( new XmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, null, isPreserveSpace()) { @Override protected Wrap getDefaultWrap(final ASTNode node) { final IElementType type = node.getElementType(); return type == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN ? Wrap.createWrap(getWrapType(myXmlFormattingPolicy.getAttributesWrap()), false) : null; } } ); } else if (child.getElementType() == XmlTokenType.XML_DATA_CHARACTERS && child.getTreeParent().getElementType() != XmlElementType.XML_CDATA && child.textContains('\n')) { result.add(createRawTextChild(child, indent, wrap, alignment)); } else { result.add(createSimpleChild(child, indent, wrap, alignment, null)); } }

processSimpleChild

Wrap (final ASTNode node) { final IElementType type = node.getElementType(); return type == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN ? Wrap.createWrap(getWrapType(myXmlFormattingPolicy.getAttributesWrap()), false) : null; }

getDefaultWrap

XmlBlock (@NotNull ASTNode child, @Nullable Indent indent, @Nullable Wrap wrap, @Nullable Alignment alignment) { var text = child.getText(); var textStart = StringUtil.skipWhitespaceOrNewLineForward(text, 0); var textEnd = StringUtil.skipWhitespaceOrNewLineBackward(text, text.length()); TextRange textRange; if (textStart < textEnd) { textRange = child.getTextRange(); textRange = new TextRange(textRange.getStartOffset() + textStart, textRange.getStartOffset() + textEnd); } else { textRange = null; } return new XmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, textRange, isPreserveSpace()); }

createRawTextChild

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

createSimpleChild

XmlTagBlock (@NotNull ASTNode child, @Nullable Indent indent, final Wrap wrap, final Alignment alignment) { return new XmlTagBlock(child, wrap, alignment, myXmlFormattingPolicy, indent != null ? indent : Indent.getNoneIndent(), isPreserveSpace()); }

createTagBlock

XmlFormattingPolicy () { return myXmlFormattingPolicy; }

createPolicyFor

boolean (final IElementType elementType) { return elementType instanceof IXmlAttributeElementType; }

isAttributeElementType

boolean (final ASTNode child) { return isXmlTag(child.getPsi()); }

isXmlTag

boolean (final PsiElement psi) { return psi instanceof XmlTag; }

isXmlTag

boolean (@NotNull Language myLanguage, @NotNull Language childLanguage, @NotNull PsiElement childPsi) { if (myLanguage == childLanguage || childLanguage == HtmlFileType.INSTANCE.getLanguage() || childLanguage == XHtmlFileType.INSTANCE.getLanguage() || childLanguage == XmlFileType.INSTANCE.getLanguage()) { return true; } final FormattingModelBuilder childFormatter = LanguageFormatting.INSTANCE.forLanguage(childLanguage); return childFormatter == null || childFormatter instanceof DelegatingFormattingModelBuilder && ((DelegatingFormattingModelBuilder)childFormatter).dontFormatMyModel(childPsi); }

useMyFormatter

boolean (final ASTNode child) { return false; }

isJspxJavaContainingNode

int () { return insertLineBreakBeforeTag() ? 1 : 0; }

getBlankLinesBeforeTag

Spacing (boolean forceKeepLineBreaks, final boolean inText) { boolean shouldKeepLineBreaks = getShouldKeepLineBreaks(inText, forceKeepLineBreaks); return Spacing.createSpacing(0, Integer.MAX_VALUE, 0, shouldKeepLineBreaks, myXmlFormattingPolicy.getKeepBlankLines()); }

createDefaultSpace

boolean (final boolean inText, final boolean forceKeepLineBreaks) { if (forceKeepLineBreaks) { return true; } if (inText && myXmlFormattingPolicy.getShouldKeepLineBreaksInText()) { return true; } if (!inText && myXmlFormattingPolicy.getShouldKeepLineBreaks()) { return true; } return false; }

getShouldKeepLineBreaks

void (final List<? super Block> localResult, final ASTNode child, final Indent indent) { }

createJspTextNode

boolean () { return (isComment(myNode)) || myNode.getElementType() == TokenType.WHITE_SPACE || myNode.getElementType() == XmlTokenType.XML_DATA_CHARACTERS || myNode.getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN; }

isLeaf

boolean (final ASTNode node) { final PsiElement psiElement = SourceTreeToPsiMap.treeElementToPsi(node); if (psiElement instanceof PsiComment) return true; final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(psiElement.getLanguage()); if (parserDefinition == null) return false; final TokenSet commentTokens = parserDefinition.getCommentTokens(); return commentTokens.contains(node.getElementType()); }

isComment

void (final XmlFormattingPolicy xmlFormattingPolicy) { myXmlFormattingPolicy = xmlFormattingPolicy; }

setXmlFormattingPolicy

boolean (List<Block> result, final ASTNode child, Wrap wrap, Alignment alignment, Indent indent) { if (isBuildIndentsOnly()) return false; if (myInjectedBlockBuilder.addInjectedBlocks(result, child, wrap, alignment, indent)) { return true; } PsiFile containingFile = child.getPsi().getContainingFile(); FileViewProvider fileViewProvider = containingFile.getViewProvider(); if (fileViewProvider instanceof TemplateLanguageFileViewProvider) { Language templateLanguage = ((TemplateLanguageFileViewProvider)fileViewProvider).getTemplateDataLanguage(); PsiElement at = fileViewProvider.findElementAt(child.getStartOffset(), templateLanguage); if (at instanceof XmlToken) { at = at.getParent(); } // TODO: several comments if (at instanceof PsiComment && at.getTextRange().equals(child.getTextRange()) && at.getNode() != child) { return buildInjectedPsiBlocks(result, at.getNode(), wrap, alignment, indent); } } return false; }

buildInjectedPsiBlocks

boolean () { return myNode.getElementType() == XmlTokenType.XML_CDATA_START; }

isCDATAStart

boolean () { return myNode.getElementType() == XmlTokenType.XML_CDATA_END; }

isCDATAEnd

boolean (@NotNull ASTNode node) { PsiElement psiElement = node.getPsi(); if (psiElement instanceof PsiWhiteSpace) return true; Language nodeLang = psiElement.getLanguage(); if (!nodeLang.isKindOf(XMLLanguage.INSTANCE) || isTextOnlyNode(node) || node.getElementType() == XmlElementType.XML_PROLOG) { WhiteSpaceFormattingStrategy strategy = WhiteSpaceFormattingStrategyFactory.getStrategy(nodeLang); int length = node.getTextLength(); return strategy.check(node.getChars(), 0, length) >= length; } return false; }

containsWhiteSpacesOnly

boolean (@NotNull ASTNode node) { if (node.getPsi() instanceof XmlText || node.getElementType() == XmlElementType.HTML_RAW_TEXT) { return true; } ASTNode firstChild = node.getFirstChildNode(); ASTNode lastChild = node.getLastChildNode(); if (firstChild != null && firstChild == lastChild && firstChild.getPsi() instanceof XmlText) { return true; } return false; }

isTextOnlyNode

boolean (final XmlTag parentTag) { return !(parentTag.getFirstChild() instanceof PsiErrorElement); }

indentChildrenOf

boolean (final XmlTag xmlTag) { return false; }

insertLineBreakBeforeTag

boolean (XmlTag tag) { return false; }

insertLineBreakAfterTagBegin

boolean (final XmlTag xmlTag) { return false; }

removeLineBreakBeforeTag

WrapType (final XmlTag xmlTag) { return AbstractXmlBlock.hasSubTags(xmlTag) ? WrapType.ALWAYS : WrapType.NORMAL; }

getWrappingTypeForTagEnd

WrapType (final XmlTag tag) { final PsiElement element = tag.getNextSibling(); if (element instanceof XmlText && !(element.getFirstChild() instanceof PsiWhiteSpace) && !AbstractXmlBlock.hasSubTags(tag)) return WrapType.NORMAL; return WrapType.ALWAYS; }

getWrappingTypeForTagBegin

boolean (XmlTag tag) { return false; }

isTextElement

boolean (final XmlTag tag) { return false; }

keepWhiteSpacesInsideTag

int (final XmlTag tag) { return myXmlSettings.XML_TEXT_WRAP; }

getTextWrap

int () { return myXmlSettings.XML_ATTRIBUTE_WRAP; }

getAttributesWrap

boolean () { return myXmlSettings.XML_ALIGN_ATTRIBUTES; }

getShouldAlignAttributes

boolean () { return myXmlSettings.XML_ALIGN_TEXT; }

getShouldAlignText

boolean () { return myXmlSettings.XML_KEEP_WHITESPACES; }

getShouldKeepWhiteSpaces

boolean () { return myXmlSettings.XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE; }

getShouldAddSpaceAroundEqualityInAttribute

boolean () { return myXmlSettings.XML_SPACE_AFTER_TAG_NAME; }

getShouldAddSpaceAroundTagName

int () { return myXmlSettings.XML_KEEP_BLANK_LINES; }

getKeepBlankLines

boolean () { return myXmlSettings.XML_KEEP_LINE_BREAKS; }

getShouldKeepLineBreaks

boolean () { return myXmlSettings.XML_KEEP_LINE_BREAKS_IN_TEXT; }

getShouldKeepLineBreaksInText

boolean () { return myXmlSettings.XML_KEEP_WHITE_SPACES_INSIDE_CDATA; }

getKeepWhiteSpacesInsideCDATA

int () { return myXmlSettings.XML_WHITE_SPACE_AROUND_CDATA; }

getWhiteSpaceAroundCDATAOption

CodeStyleSettings () { return mySettings; }

getSettings

boolean () { return myXmlSettings.XML_SPACE_INSIDE_EMPTY_TAG; }

addSpaceIntoEmptyTag

boolean () { return false; }

shouldSaveSpacesBetweenTagAndText

boolean () { return true; }

isKeepSpacesAroundInlineTags

boolean (@NotNull XmlTag xmlTag, @NotNull Language language) { Collection<Language> allFileLanguages = xmlTag.getContainingFile().getViewProvider().getLanguages(); for (Language fileLanguage : allFileLanguages) { for (HtmlScriptInjectionBlocker blocker : INSTANCE.allForLanguage(fileLanguage)) { if (blocker.isLanguageInjectionDenied(xmlTag, language)) { // Language exists, but denied by EP return true; } } } // Language exists and not denied return false; }

isInjectionBlocked

void (@NotNull MultiHostRegistrar registrar, @NotNull PsiElement host) { if (!host.isValid() || !(host instanceof XmlText) || !HtmlUtil.isHtmlTagContainingFile(host)) { return; } XmlTag scriptTag = ((XmlText)host).getParentTag(); if (scriptTag == null) { return; } final Language language = getScriptLanguageToInject(scriptTag); if (language == null || HtmlScriptInjectionBlockerExtension.isInjectionBlocked(scriptTag, language)) { return; } if (LanguageUtil.isInjectableLanguage(language)) { List<PsiElement> elements = ContainerUtil.filter(host.getChildren(), (child) -> !(child instanceof OuterLanguageElement)); if (elements.isEmpty()) return; registrar.startInjecting(language); for (PsiElement child : elements) { registrar.addPlace(null, null, (PsiLanguageInjectionHost)host, child.getTextRangeInParent()); } registrar.doneInjecting(); } }

getLanguagesToInject

void (@NotNull DependentNSReference ref, @NotNull QuickFixActionRegistrar registrar) { registrar.register(new FetchExtResourceAction(ref.isForceFetchResultValid())); registrar.register(new ManuallySetupExtResourceAction()); registrar.register(new IgnoreExtResourceAction()); }

registerFixes

Class<DependentNSReference> () { return DependentNSReference.class; }

getReferenceClass

void (@NotNull URLReference ref, @NotNull QuickFixActionRegistrar registrar) { registrar.register(new FetchExtResourceAction()); registrar.register(new ManuallySetupExtResourceAction()); registrar.register(new IgnoreExtResourceAction()); final PsiElement parentElement = ref.getElement().getParent(); if (parentElement instanceof XmlAttribute && ((XmlAttribute)parentElement).isNamespaceDeclaration()) { registrar.register(new AddXsiSchemaLocationForExtResourceAction()); } }

registerFixes