From 1b343dd7d4fc08ccab6eeae6c320073e8a2044ee Mon Sep 17 00:00:00 2001 From: azerr Date: Fri, 4 Sep 2026 16:33:34 +0200 Subject: [PATCH 01/18] Implement Roslyn-style red-green tree architecture for DOM parser MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce an immutable green tree layer (width-based, no parent pointers) that the existing red DOM tree wraps with absolute offsets. DOMParser now delegates to GreenTreeBuilder → RedTreeBuilder pipeline. This enables future incremental reparsing by structural sharing of unchanged subtrees. Key components: - Green tree nodes: GreenDocument, GreenElement, GreenText, GreenComment, GreenCDATA, GreenProcessingInstruction, GreenDocumentType, and DTD nodes - GreenTreeBuilder: scanner-driven builder producing immutable green trees - RedTreeBuilder: converts green tree to existing DOMNode hierarchy - Gap-filling: automatic whitespace filler nodes ensure contiguous widths - All 2392 existing tests pass with zero regressions Signed-off-by: azerr --- .../org/eclipse/lemminx/dom/DOMParser.java | 771 +---------- .../eclipse/lemminx/dom/RedTreeBuilder.java | 423 ++++++ .../eclipse/lemminx/dom/green/GreenAttr.java | 68 + .../lemminx/dom/green/GreenAttrBuilder.java | 57 + .../eclipse/lemminx/dom/green/GreenCDATA.java | 47 + .../lemminx/dom/green/GreenComment.java | 55 + .../dom/green/GreenDTDAttlistDecl.java | 67 + .../lemminx/dom/green/GreenDTDDeclNode.java | 76 ++ .../dom/green/GreenDTDElementDecl.java | 53 + .../lemminx/dom/green/GreenDTDEntityDecl.java | 73 ++ .../dom/green/GreenDTDNotationDecl.java | 60 + .../lemminx/dom/green/GreenDTDParam.java | 40 + .../lemminx/dom/green/GreenDocument.java | 45 + .../lemminx/dom/green/GreenDocumentType.java | 66 + .../lemminx/dom/green/GreenElement.java | 99 ++ .../dom/green/GreenElementBuilder.java | 113 ++ .../eclipse/lemminx/dom/green/GreenNode.java | 70 + .../dom/green/GreenProcessingInstruction.java | 89 ++ .../eclipse/lemminx/dom/green/GreenText.java | 41 + .../lemminx/dom/green/GreenTreeBuilder.java | 1162 +++++++++++++++++ .../AbstractElementCompletionItem.java | 12 + .../services/format/DOMCDATAFormatter.java | 8 +- .../format/XMLFormatterDocumentOld.java | 3 + .../dom/green/GreenRedConsistencyTest.java | 235 ++++ .../dom/green/GreenTreeBuilderTest.java | 366 ++++++ .../lemminx/dom/green/GreenTreeDebugTest.java | 70 + .../lemminx/dom/green/RedTreeBuilderTest.java | 617 +++++++++ 27 files changed, 4083 insertions(+), 703 deletions(-) create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttr.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttrBuilder.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDAttlistDecl.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDElementDecl.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDEntityDecl.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDNotationDecl.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDParam.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenRedConsistencyTest.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java index a88dfb52c..037477093 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java @@ -1,701 +1,70 @@ -/** - * Copyright (c) 2018 Angelo ZERR. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v2.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v20.html - * - * SPDX-License-Identifier: EPL-2.0 - * - * Initial code from https://github.com/Microsoft/vscode-html-languageservice - * Initial copyright Copyright (C) Microsoft Corporation. All rights reserved. - * Initial license: MIT - * - * Contributors: - * - Microsoft Corporation: Initial code, written in TypeScript, licensed under MIT license - * - Angelo Zerr - translation and adaptation to Java - */ -package org.eclipse.lemminx.dom; - -import java.util.logging.Level; -import java.util.logging.Logger; - -import org.eclipse.lemminx.commons.BadLocationException; -import org.eclipse.lemminx.commons.TextDocument; -import org.eclipse.lemminx.dom.parser.Scanner; -import org.eclipse.lemminx.dom.parser.TokenType; -import org.eclipse.lemminx.dom.parser.XMLScanner; -import org.eclipse.lemminx.uriresolver.URIResolverExtensionManager; -import org.eclipse.lemminx.utils.DOMUtils; -import org.eclipse.lsp4j.jsonrpc.CancelChecker; - -/** - * Tolerant XML parser. - * - */ -public class DOMParser { - - private static final Logger LOGGER = Logger.getLogger(DOMParser.class.getName()); - - private static final DOMParser INSTANCE = new DOMParser(); - - public static DOMParser getInstance() { - return INSTANCE; - } - - private DOMParser() { - - } - - public DOMDocument parse(String text, String uri, URIResolverExtensionManager resolverExtensionManager) { - return parse(new TextDocument(text, uri), resolverExtensionManager); - } - - public DOMDocument parse(String text, String uri, URIResolverExtensionManager resolverExtensionManager, - boolean ignoreWhitespaceContent) { - return parse(new TextDocument(text, uri), resolverExtensionManager, ignoreWhitespaceContent); - } - - public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager) { - return parse(document, resolverExtensionManager, true); - } - - public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager, - boolean ignoreWhitespaceContent) { - return parse(document, resolverExtensionManager, ignoreWhitespaceContent, null); - } - - public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager, - boolean ignoreWhitespaceContent, CancelChecker monitor) { - boolean isDTD = DOMUtils.isDTD(document.getUri()); - boolean inDTDInternalSubset = false; - String text = document.getText(); - Scanner scanner = XMLScanner.createScanner(text, 0, isDTD); - DOMDocument xmlDocument = new DOMDocument(document, resolverExtensionManager); - xmlDocument.setCancelChecker(monitor); - - DOMNode curr = isDTD ? new DOMDocumentType(0, text.length()) : xmlDocument; - if (isDTD) { - xmlDocument.addChild(curr); - - // This DOMDocumentType object is hidden, and just represents the DTD file - // nothing should affect it's closed status - curr.setClosed(true); - } - DOMNode lastClosed = curr; - DOMAttr attr = null; - int endTagOpenOffset = -1; - DOMNode tempWhitespaceContent = null; - boolean isInitialDeclaration = true; // A declaration can have multiple internal declarations - boolean previousTokenWasEndTagOpen = false; - TokenType token = scanner.scan(); - while (token != TokenType.EOS) { - if (monitor != null) { - monitor.checkCanceled(); - } - if (tempWhitespaceContent != null && token != TokenType.EndTagOpen) { - tempWhitespaceContent = null; - } - if (previousTokenWasEndTagOpen) { - previousTokenWasEndTagOpen = false; - boolean linkToEmptyStartTag = false; - if (token == TokenType.EndTagClose) { - // ex : - String closeTag = null; - - /** - * Try to find a start element with no tag : <> - */ - while (!(curr.isElement() && ((DOMElement) curr).isSameTag(closeTag)) && curr.parent != null) { - curr.end = endTagOpenOffset; - curr = curr.parent; - } - if (curr != xmlDocument) { - linkToEmptyStartTag = true; - curr.setClosed(true); - if (curr.isElement()) { - ((DOMElement) curr).endTagOpenOffset = endTagOpenOffset; - } else if (curr.isProcessingInstruction() || curr.isProlog()) { - ((DOMProcessingInstruction) curr).endTagOpenOffset = endTagOpenOffset; - } - curr.end = scanner.getTokenEnd(); - } - } - if (token != TokenType.EndTag && !linkToEmptyStartTag) { - // The excepted token is not an EndTag, create a fake end tag element - DOMElement element = xmlDocument.createElement(endTagOpenOffset, endTagOpenOffset + 2); - element.endTagOpenOffset = endTagOpenOffset; - curr.addChild(element); - } - } - switch (token) { - case StartTagOpen: { - if (!curr.isClosed() && curr.parent != null) { - // The next node's parent (curr) is not closed at this point - // so the node's parent (curr) will have its end position updated - // to a newer end position. - curr.end = scanner.getTokenOffset(); - } - if ((curr.isClosed()) || curr.isDoctype()) { - // The next node being considered is a child of 'curr' - // and if 'curr' is already closed then 'curr' was not updated properly. - // Or if we get a Doctype node then we know it was not closed and 'curr' - // wasn't updated properly. - curr = curr.parent; - inDTDInternalSubset = false; // In case it was previously in the internal subset - } - DOMElement child = xmlDocument.createElement(scanner.getTokenOffset(), scanner.getTokenEnd()); - child.startTagOpenOffset = scanner.getTokenOffset(); - curr.addChild(child); - curr = child; - break; - } - - case StartTag: { - DOMElement element = (DOMElement) curr; - element.tag = scanner.getTokenText(); - curr.end = scanner.getTokenEnd(); - break; - } - - case StartTagClose: - if (curr.isElement()) { - DOMElement element = (DOMElement) curr; - curr.end = scanner.getTokenEnd(); // might be later set to end tag position - element.startTagCloseOffset = scanner.getTokenOffset(); - - // never enters isEmptyElement() is always false - if (element.hasTagName() && isEmptyElement(element.getTagName()) && curr.parent != null) { - curr.setClosed(true); - curr = curr.parent; - } - } else if (curr.isProcessingInstruction() || curr.isProlog()) { - DOMProcessingInstruction element = (DOMProcessingInstruction) curr; - curr.end = scanner.getTokenEnd(); // might be later set to end tag position - element.startTagClose = true; - if (element.getTarget() != null && isEmptyElement(element.getTarget()) && curr.parent != null) { - curr.setClosed(true); - curr = curr.parent; - } - } - curr.end = scanner.getTokenEnd(); - break; - - case EndTagOpen: - if (tempWhitespaceContent != null) { - curr.addChild(tempWhitespaceContent); - tempWhitespaceContent = null; - } - endTagOpenOffset = scanner.getTokenOffset(); - curr.end = scanner.getTokenOffset(); - previousTokenWasEndTagOpen = true; - break; - - case EndTag: - // end tag (ex: ) - String closeTag = scanner.getTokenText(); - DOMNode current = curr; - - /** - * eg: will set a,b,c end position to the start of | - */ - while (!(curr.isElement() && ((DOMElement) curr).isSameTag(closeTag)) && curr.parent != null) { - curr.end = endTagOpenOffset; - curr = curr.parent; - } - if (curr != xmlDocument) { - curr.setClosed(true); - if (curr.isElement()) { - ((DOMElement) curr).endTagOpenOffset = endTagOpenOffset; - } else if (curr.isProcessingInstruction() || curr.isProlog()) { - ((DOMProcessingInstruction) curr).endTagOpenOffset = endTagOpenOffset; - } - curr.end = scanner.getTokenEnd(); - } else { - // element open tag not found (ex: ) add a fake element which only has an - // end tag (no start tag). - DOMElement element = xmlDocument.createElement(scanner.getTokenOffset() - 2, - scanner.getTokenEnd()); - element.endTagOpenOffset = endTagOpenOffset; - element.tag = closeTag; - current.addChild(element); - curr = element; - } - break; - - case StartTagSelfClose: - if (curr.parent != null) { - curr.setClosed(true); - ((DOMElement) curr).selfClosed = true; - curr.end = scanner.getTokenEnd(); - lastClosed = curr; - curr = curr.parent; - } - break; - - case EndTagClose: - if (curr.parent != null) { - curr.end = scanner.getTokenEnd(); - lastClosed = curr; - if (lastClosed.isElement()) { - ((DOMElement) curr).endTagCloseOffset = scanner.getTokenOffset(); - } - if (curr.isDoctype()) { - curr.setClosed(true); - } - curr = curr.parent; - - } - break; - - case AttributeName: { - attr = new DOMAttr(null, scanner.getTokenOffset(), - scanner.getTokenEnd(), curr); - curr.setAttributeNode(attr); - curr.end = scanner.getTokenEnd(); - break; - } - - case DelimiterAssign: { - if (attr != null) { - // Sets the value to the '=' position in case there is no AttributeValue - attr.setDelimiter(scanner.getTokenOffset()); - } - break; - } - - case AttributeValue: { - if (curr.hasAttributes() && attr != null) { - attr.setValue(null, scanner.getTokenOffset(), scanner.getTokenEnd()); - } - attr = null; - curr.end = scanner.getTokenEnd(); - break; - } - - case CDATATagOpen: { - DOMCDATASection cdataNode = xmlDocument.createCDataSection(scanner.getTokenOffset(), text.length()); - curr.addChild(cdataNode); - curr = cdataNode; - break; - } - - case CDATAContent: { - DOMCDATASection cdataNode = (DOMCDATASection) curr; - cdataNode.startContent = scanner.getTokenOffset(); - cdataNode.endContent = scanner.getTokenEnd(); - curr.end = scanner.getTokenEnd(); - break; - } - - case CDATATagClose: { - curr.end = scanner.getTokenEnd(); - curr.setClosed(true); - curr = curr.parent; - break; - } - - case StartPrologOrPI: { - DOMProcessingInstruction prologOrPINode = xmlDocument - .createProcessingInstruction(scanner.getTokenOffset(), text.length()); - curr.addChild(prologOrPINode); - curr = prologOrPINode; - break; - } - - case PIName: { - DOMProcessingInstruction processingInstruction = ((DOMProcessingInstruction) curr); - processingInstruction.target = scanner.getTokenText(); - processingInstruction.processingInstruction = true; - break; - } - - case PrologName: { - DOMProcessingInstruction processingInstruction = ((DOMProcessingInstruction) curr); - processingInstruction.target = scanner.getTokenText(); - processingInstruction.prolog = true; - break; - } - - case PIContent: { - DOMProcessingInstruction processingInstruction = (DOMProcessingInstruction) curr; - processingInstruction.startContent = scanner.getTokenOffset(); - processingInstruction.endContent = scanner.getTokenEnd(); - break; - } - - case PIEnd: - case PrologEnd: { - curr.end = scanner.getTokenEnd(); - curr.setClosed(true); - curr = curr.parent; - break; - } - - case StartCommentTag: { - // Incase the tag before the comment tag (curr) was not properly closed - // curr should be set to the root node. - if (xmlDocument.isDTD() || inDTDInternalSubset) { - while (!curr.isDoctype()) { - curr = curr.parent; - } - } else if ((curr.isClosed())) { - curr = curr.parent; - } - DOMComment comment = xmlDocument.createComment(scanner.getTokenOffset(), text.length()); - curr.addChild(comment); - curr = comment; - try { - int endLine = document.positionAt(lastClosed.end).getLine(); - int startLine = document.positionAt(curr.start).getLine(); - if (endLine == startLine && lastClosed.end <= curr.start) { - comment.commentSameLineEndTag = true; - } - } catch (BadLocationException e) { - LOGGER.log(Level.SEVERE, "XMLParser StartCommentTag bad offset in document", e); - } - break; - } - - case Comment: { - DOMComment comment = (DOMComment) curr; - comment.startContent = scanner.getTokenOffset(); - comment.endContent = scanner.getTokenEnd(); - break; - } - - case EndCommentTag: { - curr.end = scanner.getTokenEnd(); - curr.setClosed(true); - curr = curr.parent; - break; - } - - case Content: { - boolean currIsDeclNode = curr instanceof DTDDeclNode; - if (currIsDeclNode) { - curr.end = scanner.getTokenOffset() - 1; - while (!curr.isDoctype()) { - curr = curr.getParentNode(); - } - } - int start = scanner.getTokenOffset(); - int end = scanner.getTokenEnd(); - DOMText textNode = xmlDocument.createText(start, end); - textNode.setClosed(true); - - if (scanner.isTokenTextBlank()) { - if (ignoreWhitespaceContent) { - if (curr.hasChildNodes()) { - break; - } - - tempWhitespaceContent = textNode; - break; - - } else if (!currIsDeclNode) { - textNode.setWhitespace(true); - } else { - break; - } - - } - - curr.addChild(textNode); - break; - } - - // DTD - - case DTDStartDoctypeTag: { - DOMDocumentType doctype = xmlDocument.createDocumentType(scanner.getTokenOffset(), text.length()); - curr.addChild(doctype); - doctype.parent = curr; - curr = doctype; - break; - } - - case DTDDoctypeName: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDDocTypeKindPUBLIC: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setKind(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDDocTypeKindSYSTEM: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setKind(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDDoctypePublicId: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setPublicId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDDoctypeSystemId: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setSystemId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDStartInternalSubset: { - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setStartInternalSubset(scanner.getTokenOffset()); - inDTDInternalSubset = true; - break; - } - - case DTDEndInternalSubset: { - while (!curr.isDoctype()) { - curr.end = scanner.getTokenOffset() - 1; - curr = curr.getParentNode(); - } - inDTDInternalSubset = false; - DOMDocumentType doctype = (DOMDocumentType) curr; - doctype.setEndInternalSubset(scanner.getTokenEnd()); - break; - } - - case DTDStartElement: { - // If previous 'curr' was an unclosed DTD Declaration - while (!curr.isDoctype()) { - curr.end = scanner.getTokenOffset(); - curr = curr.getParentNode(); - } - - DTDElementDecl child = new DTDElementDecl(scanner.getTokenOffset(), text.length()); - curr.addChild(child); - curr = child; - break; - } - - case DTDElementDeclName: { - DTDElementDecl element = (DTDElementDecl) curr; - element.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDElementCategory: { - DTDElementDecl element = (DTDElementDecl) curr; - element.setCategory(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDStartElementContent: { - DTDElementDecl element = (DTDElementDecl) curr; - element.setContent(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDElementContent: { - DTDElementDecl element = (DTDElementDecl) curr; - element.updateLastParameterEnd(scanner.getTokenEnd()); - break; - } - - case DTDEndElementContent: { - DTDElementDecl element = (DTDElementDecl) curr; - element.updateLastParameterEnd(scanner.getTokenEnd()); - break; - } - - case DTDStartAttlist: { - while (!curr.isDoctype()) { // If previous DTD Decl was unclosed - curr.end = scanner.getTokenOffset(); - curr = curr.getParentNode(); - } - DTDAttlistDecl child = new DTDAttlistDecl(scanner.getTokenOffset(), text.length()); - - isInitialDeclaration = true; - curr.addChild(child); - curr = child; - break; - } - - case DTDAttlistElementName: { - DTDAttlistDecl attribute = (DTDAttlistDecl) curr; - attribute.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDAttlistAttributeName: { - DTDAttlistDecl attribute = (DTDAttlistDecl) curr; - if (isInitialDeclaration == false) { - // All additional declarations are created as new DTDAttlistDecl's - DTDAttlistDecl child = new DTDAttlistDecl(attribute.getStart(), attribute.getEnd()); - attribute.addAdditionalAttDecl(child); - child.parent = attribute; - - attribute = child; - curr = child; - } - attribute.setAttributeName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDAttlistAttributeType: { - DTDAttlistDecl attribute = (DTDAttlistDecl) curr; - attribute.setAttributeType(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDAttlistAttributeValue: { - DTDAttlistDecl attribute = (DTDAttlistDecl) curr; - attribute.setAttributeValue(scanner.getTokenOffset(), scanner.getTokenEnd()); - - if (attribute.parent.isDTDAttListDecl()) { // Is not the root/main ATTLIST node - curr = attribute.parent; - } else { - isInitialDeclaration = false; - } - break; - } - - case DTDStartEntity: { - while (!curr.isDoctype()) { // If previous DTD Decl was unclosed - curr.end = scanner.getTokenOffset(); - curr = curr.getParentNode(); - } - DTDEntityDecl child = new DTDEntityDecl(scanner.getTokenOffset(), text.length()); - curr.addChild(child); - curr = child; - break; - } - - case DTDEntityPercent: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setPercent(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEntityName: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEntityValue: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setValue(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEntityKindPUBLIC: - case DTDEntityKindSYSTEM: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setKind(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEntityPublicId: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setPublicId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEntitySystemId: { - DTDEntityDecl entity = (DTDEntityDecl) curr; - entity.setSystemId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDStartNotation: { - while (!curr.isDoctype()) { // If previous DTD Decl was unclosed - curr.end = scanner.getTokenOffset(); - curr = curr.getParentNode(); - } - DTDNotationDecl child = new DTDNotationDecl(scanner.getTokenOffset(), text.length()); - curr.addChild(child); - curr = child; - isInitialDeclaration = true; - break; - } - - case DTDNotationName: { - DTDNotationDecl notation = (DTDNotationDecl) curr; - notation.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDNotationKindPUBLIC: { - DTDNotationDecl notation = (DTDNotationDecl) curr; - notation.setKind(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDNotationKindSYSTEM: { - DTDNotationDecl notation = (DTDNotationDecl) curr; - notation.setKind(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDNotationPublicId: { - DTDNotationDecl notation = (DTDNotationDecl) curr; - notation.setPublicId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDNotationSystemId: { - DTDNotationDecl notation = (DTDNotationDecl) curr; - notation.setSystemId(scanner.getTokenOffset(), scanner.getTokenEnd()); - break; - } - - case DTDEndTag: { - if ((curr.isDTDElementDecl() || curr.isDTDAttListDecl() || curr.isDTDEntityDecl() - || curr.isDTDNotationDecl())) { - while (curr.parent != null && !curr.parent.isDoctype()) { - curr = curr.parent; - } - curr.end = scanner.getTokenEnd(); - curr.setClosed(true); - curr = curr.parent; - } - break; - } - - case DTDEndDoctypeTag: { - ((DOMDocumentType) curr).end = scanner.getTokenEnd(); - curr.setClosed(true); - curr = curr.parent; - break; - } - - case DTDUnrecognizedParameters: { - DTDDeclNode node = (DTDDeclNode) curr; - node.setUnrecognized(scanner.getTokenOffset(), ((XMLScanner) scanner).getLastNonWhitespaceOffset()); - break; - } - - default: - } - token = scanner.scan(); - } - if (previousTokenWasEndTagOpen) { - previousTokenWasEndTagOpen = false; - if (token != TokenType.EndTag) { - // The excepted token is not an EndTag, create a fake end tag element - DOMElement element = xmlDocument.createElement(endTagOpenOffset, endTagOpenOffset + 2); - element.endTagOpenOffset = endTagOpenOffset; - curr.addChild(element); - } - } - while (curr.parent != null) { - curr.end = text.length(); - curr = curr.parent; - } - return xmlDocument; - } - - private static boolean isEmptyElement(String tag) { - return false; - } - -} +/** + * Copyright (c) 2018 Angelo ZERR. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v2.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Initial code from https://github.com/Microsoft/vscode-html-languageservice + * Initial copyright Copyright (C) Microsoft Corporation. All rights reserved. + * Initial license: MIT + * + * Contributors: + * - Microsoft Corporation: Initial code, written in TypeScript, licensed under MIT license + * - Angelo Zerr - translation and adaptation to Java + */ +package org.eclipse.lemminx.dom; + +import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.green.GreenDocument; +import org.eclipse.lemminx.dom.green.GreenTreeBuilder; +import org.eclipse.lemminx.uriresolver.URIResolverExtensionManager; +import org.eclipse.lsp4j.jsonrpc.CancelChecker; + +/** + * Tolerant XML parser. + * + */ +public class DOMParser { + + private static final DOMParser INSTANCE = new DOMParser(); + + public static DOMParser getInstance() { + return INSTANCE; + } + + private DOMParser() { + + } + + public DOMDocument parse(String text, String uri, URIResolverExtensionManager resolverExtensionManager) { + return parse(new TextDocument(text, uri), resolverExtensionManager); + } + + public DOMDocument parse(String text, String uri, URIResolverExtensionManager resolverExtensionManager, + boolean ignoreWhitespaceContent) { + return parse(new TextDocument(text, uri), resolverExtensionManager, ignoreWhitespaceContent); + } + + public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager) { + return parse(document, resolverExtensionManager, true); + } + + public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager, + boolean ignoreWhitespaceContent) { + return parse(document, resolverExtensionManager, ignoreWhitespaceContent, null); + } + + public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager, + boolean ignoreWhitespaceContent, CancelChecker monitor) { + String text = document.getText(); + String uri = document.getUri(); + GreenDocument greenDoc = GreenTreeBuilder.parse(text, uri, monitor); + DOMDocument xmlDocument = RedTreeBuilder.build(greenDoc, document, + resolverExtensionManager, ignoreWhitespaceContent); + xmlDocument.setCancelChecker(monitor); + return xmlDocument; + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java new file mode 100644 index 000000000..5a6af0319 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -0,0 +1,423 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom; + +import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.green.GreenAttr; +import org.eclipse.lemminx.dom.green.GreenCDATA; +import org.eclipse.lemminx.dom.green.GreenComment; +import org.eclipse.lemminx.dom.green.GreenDTDAttlistDecl; +import org.eclipse.lemminx.dom.green.GreenDTDDeclNode; +import org.eclipse.lemminx.dom.green.GreenDTDElementDecl; +import org.eclipse.lemminx.dom.green.GreenDTDEntityDecl; +import org.eclipse.lemminx.dom.green.GreenDTDNotationDecl; +import org.eclipse.lemminx.dom.green.GreenDocument; +import org.eclipse.lemminx.dom.green.GreenDocumentType; +import org.eclipse.lemminx.dom.green.GreenElement; +import org.eclipse.lemminx.dom.green.GreenNode; +import org.eclipse.lemminx.dom.green.GreenProcessingInstruction; +import org.eclipse.lemminx.dom.green.GreenText; +import org.eclipse.lemminx.uriresolver.URIResolverExtensionManager; +import org.w3c.dom.Node; + +/** + * Builds a red tree ({@link DOMDocument}) from an immutable green tree + * ({@link GreenDocument}). + * + *

The red tree provides absolute offsets, parent pointers, and the full + * {@link org.w3c.dom.Node} API that existing LemMinX features expect. + * The green tree is preserved for structural sharing during incremental + * reparsing.

+ */ +public final class RedTreeBuilder { + + private final boolean ignoreWhitespaceContent; + + private RedTreeBuilder(boolean ignoreWhitespaceContent) { + this.ignoreWhitespaceContent = ignoreWhitespaceContent; + } + + public static DOMDocument build(GreenDocument greenDoc, TextDocument textDocument, + URIResolverExtensionManager resolverExtensionManager) { + return new RedTreeBuilder(true).doBuild(greenDoc, textDocument, resolverExtensionManager); + } + + public static DOMDocument build(GreenDocument greenDoc, TextDocument textDocument, + URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent) { + return new RedTreeBuilder(ignoreWhitespaceContent).doBuild(greenDoc, textDocument, resolverExtensionManager); + } + + private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, + URIResolverExtensionManager resolverExtensionManager) { + DOMDocument domDoc = new DOMDocument(textDocument, resolverExtensionManager); + addChildren(domDoc, greenDoc, 0); + return domDoc; + } + + private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsStart) { + GreenNode[] children = greenParent.children(); + if (children.length == 0) { + return; + } + + int childrenStartRel = computeChildrenStartRel(greenParent); + int childAbsStart = parentAbsStart + childrenStartRel; + boolean skipWhitespace = ignoreWhitespaceContent + && (hasNonWhitespaceChild(children) || greenParent instanceof GreenDocumentType); + + for (GreenNode greenChild : children) { + if (skipWhitespace && isWhitespaceText(greenChild)) { + childAbsStart += greenChild.width(); + continue; + } + DOMNode redChild = createRedNode(greenChild, childAbsStart); + if (redChild != null) { + if (parent instanceof DTDAttlistDecl && redChild instanceof DTDAttlistDecl) { + ((DTDAttlistDecl) parent).addAdditionalAttDecl((DTDAttlistDecl) redChild); + redChild.parent = parent; + } else { + parent.addChild(redChild); + } + } + childAbsStart += greenChild.width(); + } + } + + private static boolean hasNonWhitespaceChild(GreenNode[] children) { + for (GreenNode child : children) { + if (!isWhitespaceText(child)) { + return true; + } + } + return false; + } + + private static boolean isWhitespaceText(GreenNode node) { + return node instanceof GreenText && ((GreenText) node).whitespace(); + } + + private DOMNode createRedNode(GreenNode green, int absStart) { + int absEnd = absStart + green.width(); + + switch (green.nodeType()) { + case Node.ELEMENT_NODE: + return createElement((GreenElement) green, absStart, absEnd); + case Node.TEXT_NODE: + return createText((GreenText) green, absStart, absEnd); + case Node.COMMENT_NODE: + return createComment((GreenComment) green, absStart, absEnd); + case Node.CDATA_SECTION_NODE: + return createCDATA((GreenCDATA) green, absStart, absEnd); + case Node.PROCESSING_INSTRUCTION_NODE: + return createPI((GreenProcessingInstruction) green, absStart, absEnd); + case Node.DOCUMENT_TYPE_NODE: + return createDocumentType((GreenDocumentType) green, absStart, absEnd); + case DOMNode.DTD_ELEMENT_DECL_NODE: + return createDTDElementDecl((GreenDTDElementDecl) green, absStart, absEnd); + case DOMNode.DTD_ATT_LIST_NODE: + return createDTDAttlistDecl((GreenDTDAttlistDecl) green, absStart, absEnd); + case Node.ENTITY_NODE: + return createDTDEntityDecl((GreenDTDEntityDecl) green, absStart, absEnd); + case DOMNode.DTD_NOTATION_DECL: + return createDTDNotationDecl((GreenDTDNotationDecl) green, absStart, absEnd); + case DOMNode.DTD_DECL_NODE: + return createDTDDeclNode((GreenDTDDeclNode) green, absStart, absEnd); + default: + return null; + } + } + + private DOMElement createElement(GreenElement green, int absStart, int absEnd) { + DOMElement elem = new DOMElement(absStart, absEnd); + elem.tag = green.tag(); + elem.selfClosed = green.selfClosed(); + boolean isOrphanEndTag = green.endTagOpenRel() != GreenElement.NULL_VALUE + && green.endTagOpenRel() == 0 + && green.startTagCloseRel() == GreenElement.NULL_VALUE; + elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : absStart; + elem.startTagCloseOffset = abs(green.startTagCloseRel(), absStart); + elem.endTagOpenOffset = abs(green.endTagOpenRel(), absStart); + elem.endTagCloseOffset = abs(green.endTagCloseRel(), absStart); + elem.setClosed(green.closed()); + + GreenAttr[] greenAttrs = green.attributes(); + for (GreenAttr ga : greenAttrs) { + DOMAttr attr = createAttr(ga, absStart, elem); + elem.setAttributeNode(attr); + } + + addChildren(elem, green, absStart); + return elem; + } + + private static DOMAttr createAttr(GreenAttr ga, int elemAbsStart, DOMNode owner) { + int nameStart = elemAbsStart + ga.nameStartRel(); + int nameEnd = elemAbsStart + ga.nameEndRel(); + DOMAttr attr = new DOMAttr(null, nameStart, nameEnd, owner); + if (ga.delimiterRel() != GreenAttr.NULL_VALUE) { + attr.setDelimiter(elemAbsStart + ga.delimiterRel()); + } + if (ga.valueStartRel() != GreenAttr.NULL_VALUE) { + attr.setValue(null, elemAbsStart + ga.valueStartRel(), elemAbsStart + ga.valueEndRel()); + } + return attr; + } + + private static DOMText createText(GreenText green, int absStart, int absEnd) { + DOMText text = new DOMText(absStart, absEnd); + text.setWhitespace(green.whitespace()); + text.setClosed(true); + return text; + } + + private static DOMComment createComment(GreenComment green, int absStart, int absEnd) { + DOMComment comment = new DOMComment(absStart, absEnd); + comment.startContent = abs(green.startContentRel(), absStart); + comment.endContent = abs(green.endContentRel(), absStart); + comment.commentSameLineEndTag = green.commentSameLineEndTag(); + comment.setClosed(green.closed()); + return comment; + } + + private static DOMCDATASection createCDATA(GreenCDATA green, int absStart, int absEnd) { + DOMCDATASection cdata = new DOMCDATASection(absStart, absEnd); + cdata.startContent = abs(green.startContentRel(), absStart); + cdata.endContent = abs(green.endContentRel(), absStart); + cdata.setClosed(green.closed()); + return cdata; + } + + private static DOMProcessingInstruction createPI(GreenProcessingInstruction green, + int absStart, int absEnd) { + DOMProcessingInstruction pi = new DOMProcessingInstruction(absStart, absEnd); + pi.target = green.target(); + pi.prolog = green.prolog(); + pi.processingInstruction = green.processingInstruction(); + pi.startTagClose = green.startTagClose(); + if (green.startContentRel() != GreenElement.NULL_VALUE) { + pi.startContent = absStart + green.startContentRel(); + } + if (green.endContentRel() != GreenElement.NULL_VALUE) { + pi.endContent = absStart + green.endContentRel(); + } + pi.endTagOpenOffset = abs(green.endTagOpenRel(), absStart); + pi.setClosed(green.closed()); + + GreenAttr[] greenAttrs = green.attributes(); + for (GreenAttr ga : greenAttrs) { + DOMAttr attr = createAttr(ga, absStart, pi); + pi.setAttributeNode(attr); + } + return pi; + } + + private DOMDocumentType createDocumentType(GreenDocumentType green, + int absStart, int absEnd) { + DOMDocumentType dt = new DOMDocumentType(absStart, absEnd); + dt.setClosed(green.closed()); + setDTDDeclFields(dt, green, absStart); + + if (green.kind() != null) { + dt.setKind(absStart + green.kind().startRel(), + absStart + green.kind().endRel()); + } + if (green.publicId() != null) { + dt.setPublicId(absStart + green.publicId().startRel(), + absStart + green.publicId().endRel()); + } + if (green.systemId() != null) { + dt.setSystemId(absStart + green.systemId().startRel(), + absStart + green.systemId().endRel()); + } + if (green.internalSubset() != null) { + dt.setStartInternalSubset(absStart + green.internalSubset().startRel()); + dt.setEndInternalSubset(absStart + green.internalSubset().endRel()); + } + + setDTDUnrecognized(dt, green, absStart); + addChildren(dt, green, absStart); + dt.end = absEnd; + return dt; + } + + private DTDElementDecl createDTDElementDecl(GreenDTDElementDecl green, + int absStart, int absEnd) { + DTDElementDecl decl = new DTDElementDecl(absStart, absEnd); + decl.setClosed(green.closed()); + setDTDDeclFields(decl, green, absStart); + if (green.category() != null) { + decl.setCategory(absStart + green.category().startRel(), + absStart + green.category().endRel()); + } + if (green.content() != null) { + decl.setContent(absStart + green.content().startRel(), + absStart + green.content().endRel()); + } + setDTDUnrecognized(decl, green, absStart); + addChildren(decl, green, absStart); + decl.end = absEnd; + return decl; + } + + private DTDAttlistDecl createDTDAttlistDecl(GreenDTDAttlistDecl green, + int absStart, int absEnd) { + DTDAttlistDecl decl = new DTDAttlistDecl(absStart, absEnd); + decl.setClosed(green.closed()); + setDTDDeclFields(decl, green, absStart); + if (green.attributeName() != null) { + decl.setAttributeName(absStart + green.attributeName().startRel(), + absStart + green.attributeName().endRel()); + } + if (green.attributeType() != null) { + decl.setAttributeType(absStart + green.attributeType().startRel(), + absStart + green.attributeType().endRel()); + } + if (green.attributeValue() != null) { + decl.setAttributeValue(absStart + green.attributeValue().startRel(), + absStart + green.attributeValue().endRel()); + } + setDTDUnrecognized(decl, green, absStart); + addChildren(decl, green, absStart); + decl.end = absEnd; + return decl; + } + + private DTDEntityDecl createDTDEntityDecl(GreenDTDEntityDecl green, + int absStart, int absEnd) { + DTDEntityDecl decl = new DTDEntityDecl(absStart, absEnd); + decl.setClosed(green.closed()); + if (green.percent() != null) { + decl.setPercent(absStart + green.percent().startRel(), + absStart + green.percent().endRel()); + } + setDTDDeclFields(decl, green, absStart); + if (green.value() != null) { + decl.setValue(absStart + green.value().startRel(), + absStart + green.value().endRel()); + } + if (green.kind() != null) { + decl.setKind(absStart + green.kind().startRel(), + absStart + green.kind().endRel()); + } + if (green.publicId() != null) { + decl.setPublicId(absStart + green.publicId().startRel(), + absStart + green.publicId().endRel()); + } + if (green.systemId() != null) { + decl.setSystemId(absStart + green.systemId().startRel(), + absStart + green.systemId().endRel()); + } + setDTDUnrecognized(decl, green, absStart); + addChildren(decl, green, absStart); + decl.end = absEnd; + return decl; + } + + private DTDNotationDecl createDTDNotationDecl(GreenDTDNotationDecl green, + int absStart, int absEnd) { + DTDNotationDecl decl = new DTDNotationDecl(absStart, absEnd); + decl.setClosed(green.closed()); + setDTDDeclFields(decl, green, absStart); + if (green.kind() != null) { + decl.setKind(absStart + green.kind().startRel(), + absStart + green.kind().endRel()); + } + if (green.publicId() != null) { + decl.setPublicId(absStart + green.publicId().startRel(), + absStart + green.publicId().endRel()); + } + if (green.systemId() != null) { + decl.setSystemId(absStart + green.systemId().startRel(), + absStart + green.systemId().endRel()); + } + setDTDUnrecognized(decl, green, absStart); + addChildren(decl, green, absStart); + decl.end = absEnd; + return decl; + } + + private DTDDeclNode createDTDDeclNode(GreenDTDDeclNode green, + int absStart, int absEnd) { + DTDDeclNode decl = new DTDDeclNode(absStart, absEnd); + decl.setClosed(green.closed()); + setDTDDeclFields(decl, green, absStart); + setDTDUnrecognized(decl, green, absStart); + addChildren(decl, green, absStart); + decl.end = absEnd; + return decl; + } + + private static void setDTDDeclFields(DTDDeclNode decl, GreenDTDDeclNode green, + int absStart) { + if (green.declType() != null) { + decl.setDeclType(absStart + green.declType().startRel(), + absStart + green.declType().endRel()); + } + if (green.name() != null) { + decl.setName(absStart + green.name().startRel(), + absStart + green.name().endRel()); + } + } + + private static void setDTDUnrecognized(DTDDeclNode decl, GreenDTDDeclNode green, + int absStart) { + if (green.unrecognized() != null) { + decl.setUnrecognized(absStart + green.unrecognized().startRel(), + absStart + green.unrecognized().endRel()); + } + } + + private static int computeChildrenStartRel(GreenNode greenParent) { + if (greenParent instanceof GreenDocument) { + return 0; + } + if (greenParent instanceof GreenElement) { + GreenElement elem = (GreenElement) greenParent; + if (elem.contentStartRel() != GreenElement.NULL_VALUE) { + return elem.contentStartRel(); + } + if (elem.startTagCloseRel() != GreenElement.NULL_VALUE) { + return elem.startTagCloseRel() + 1; + } + return 0; + } + if (greenParent instanceof GreenDocumentType) { + GreenDocumentType dt = (GreenDocumentType) greenParent; + if (dt.internalSubset() != null) { + return dt.internalSubset().startRel() + 1; + } + if (dt.childCount() == 0) { + return 0; + } + int childrenWidth = 0; + for (GreenNode child : dt.children()) { + childrenWidth += child.width(); + } + return dt.width() - childrenWidth; + } + if (greenParent instanceof GreenDTDDeclNode) { + if (greenParent.childCount() == 0) { + return 0; + } + int childrenWidth = 0; + for (GreenNode child : greenParent.children()) { + childrenWidth += child.width(); + } + return greenParent.width() - childrenWidth; + } + return 0; + } + + private static int abs(int relOffset, int absStart) { + return relOffset != GreenElement.NULL_VALUE ? absStart + relOffset : DOMNode.NULL_VALUE; + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttr.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttr.java new file mode 100644 index 000000000..2fc51d09e --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttr.java @@ -0,0 +1,68 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +/** + * Immutable green node for an XML attribute. + * + *

Offsets are relative to the owning element's start position. + * The red wrapper adds the element's absolute offset when converting.

+ */ +public final class GreenAttr { + + public static final int NULL_VALUE = -1; + + private final int nameStartRel; + private final int nameEndRel; + private final int delimiterRel; + private final int valueStartRel; + private final int valueEndRel; + + public GreenAttr(int nameStartRel, int nameEndRel, int delimiterRel, + int valueStartRel, int valueEndRel) { + this.nameStartRel = nameStartRel; + this.nameEndRel = nameEndRel; + this.delimiterRel = delimiterRel; + this.valueStartRel = valueStartRel; + this.valueEndRel = valueEndRel; + } + + public int nameStartRel() { + return nameStartRel; + } + + public int nameEndRel() { + return nameEndRel; + } + + public int delimiterRel() { + return delimiterRel; + } + + public int valueStartRel() { + return valueStartRel; + } + + public int valueEndRel() { + return valueEndRel; + } + + public int width() { + if (valueEndRel != NULL_VALUE) { + return valueEndRel - nameStartRel; + } + if (delimiterRel != NULL_VALUE) { + return delimiterRel + 1 - nameStartRel; + } + return nameEndRel - nameStartRel; + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttrBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttrBuilder.java new file mode 100644 index 000000000..b60022e33 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenAttrBuilder.java @@ -0,0 +1,57 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +/** + * Mutable builder for {@link GreenAttr}. + * + *

Offsets are collected as absolute positions during scanning; the builder + * converts them to element-relative offsets at {@link #build(int)} time.

+ */ +public final class GreenAttrBuilder { + + private int nameStart = GreenAttr.NULL_VALUE; + private int nameEnd = GreenAttr.NULL_VALUE; + private int delimiter = GreenAttr.NULL_VALUE; + private int valueStart = GreenAttr.NULL_VALUE; + private int valueEnd = GreenAttr.NULL_VALUE; + + public void setName(int start, int end) { + this.nameStart = start; + this.nameEnd = end; + } + + public void setDelimiter(int offset) { + this.delimiter = offset; + } + + public void setValue(int start, int end) { + this.valueStart = start; + this.valueEnd = end; + } + + /** + * Builds an immutable {@link GreenAttr} with offsets relative to the given + * element start position. + * + * @param elementStart the absolute start offset of the owning element + * @return immutable attribute + */ + public GreenAttr build(int elementStart) { + return new GreenAttr( + nameStart - elementStart, + nameEnd - elementStart, + delimiter != GreenAttr.NULL_VALUE ? delimiter - elementStart : GreenAttr.NULL_VALUE, + valueStart != GreenAttr.NULL_VALUE ? valueStart - elementStart : GreenAttr.NULL_VALUE, + valueEnd != GreenAttr.NULL_VALUE ? valueEnd - elementStart : GreenAttr.NULL_VALUE); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java new file mode 100644 index 000000000..1048cba78 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java @@ -0,0 +1,47 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for a CDATA section ({@code }). + */ +public final class GreenCDATA extends GreenNode { + + private final int startContentRel; + private final int endContentRel; + + public GreenCDATA(int width, boolean closed, int startContentRel, int endContentRel) { + super(width, closed); + this.startContentRel = startContentRel; + this.endContentRel = endContentRel; + } + + @Override + public short nodeType() { + return Node.CDATA_SECTION_NODE; + } + + public int startContentRel() { + return startContentRel; + } + + public int endContentRel() { + return endContentRel; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenCDATA(newWidth, closed(), startContentRel, endContentRel); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java new file mode 100644 index 000000000..070e30c21 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for an XML comment ({@code }). + */ +public final class GreenComment extends GreenNode { + + private final boolean commentSameLineEndTag; + private final int startContentRel; + private final int endContentRel; + + public GreenComment(int width, boolean closed, boolean commentSameLineEndTag, + int startContentRel, int endContentRel) { + super(width, closed); + this.commentSameLineEndTag = commentSameLineEndTag; + this.startContentRel = startContentRel; + this.endContentRel = endContentRel; + } + + @Override + public short nodeType() { + return Node.COMMENT_NODE; + } + + public boolean commentSameLineEndTag() { + return commentSameLineEndTag; + } + + public int startContentRel() { + return startContentRel; + } + + public int endContentRel() { + return endContentRel; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenComment(newWidth, closed(), commentSameLineEndTag, + startContentRel, endContentRel); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDAttlistDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDAttlistDecl.java new file mode 100644 index 000000000..cd920d28a --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDAttlistDecl.java @@ -0,0 +1,67 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lemminx.dom.DOMNode; + +/** + * Immutable green node for a DTD ATTLIST declaration ({@code }). + */ +public final class GreenDTDAttlistDecl extends GreenDTDDeclNode { + + private final GreenDTDParam attributeName; + private final GreenDTDParam attributeType; + private final GreenDTDParam attributeValue; + private final GreenDTDAttlistDecl[] internalDecls; + + public GreenDTDAttlistDecl(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children, + GreenDTDParam attributeName, GreenDTDParam attributeType, + GreenDTDParam attributeValue, + GreenDTDAttlistDecl[] internalDecls) { + super(width, closed, unrecognized, declType, name, parameters, children); + this.attributeName = attributeName; + this.attributeType = attributeType; + this.attributeValue = attributeValue; + this.internalDecls = internalDecls; + } + + @Override + public short nodeType() { + return DOMNode.DTD_ATT_LIST_NODE; + } + + public GreenDTDParam attributeName() { + return attributeName; + } + + public GreenDTDParam attributeType() { + return attributeType; + } + + public GreenDTDParam attributeValue() { + return attributeValue; + } + + public GreenDTDAttlistDecl[] internalDecls() { + return internalDecls; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDTDAttlistDecl(newWidth, closed(), unrecognized(), declType(), + name(), parameters(), newChildren, + attributeName, attributeType, attributeValue, internalDecls); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java new file mode 100644 index 000000000..7113de4aa --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java @@ -0,0 +1,76 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lemminx.dom.DOMNode; + +/** + * Immutable green node for a generic DTD declaration. + * + *

Serves as base data for {@link GreenDocumentType}, + * {@link GreenDTDAttlistDecl}, {@link GreenDTDElementDecl}, + * {@link GreenDTDEntityDecl}, and {@link GreenDTDNotationDecl}.

+ */ +public class GreenDTDDeclNode extends GreenNode { + + public static final GreenDTDParam[] EMPTY_PARAMS = new GreenDTDParam[0]; + + private final GreenDTDParam unrecognized; + private final GreenDTDParam declType; + private final GreenDTDParam name; + private final GreenDTDParam[] parameters; + private final GreenNode[] children; + + public GreenDTDDeclNode(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children) { + super(width, closed); + this.unrecognized = unrecognized; + this.declType = declType; + this.name = name; + this.parameters = parameters != null ? parameters : EMPTY_PARAMS; + this.children = children != null ? children : EMPTY_CHILDREN; + } + + @Override + public short nodeType() { + return DOMNode.DTD_DECL_NODE; + } + + public GreenDTDParam unrecognized() { + return unrecognized; + } + + public GreenDTDParam declType() { + return declType; + } + + public GreenDTDParam name() { + return name; + } + + public GreenDTDParam[] parameters() { + return parameters; + } + + @Override + public GreenNode[] children() { + return children; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDTDDeclNode(newWidth, closed(), unrecognized, declType, + name, parameters, newChildren); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDElementDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDElementDecl.java new file mode 100644 index 000000000..d164c6bbd --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDElementDecl.java @@ -0,0 +1,53 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lemminx.dom.DOMNode; + +/** + * Immutable green node for a DTD ELEMENT declaration ({@code }). + */ +public final class GreenDTDElementDecl extends GreenDTDDeclNode { + + private final GreenDTDParam category; + private final GreenDTDParam content; + + public GreenDTDElementDecl(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children, + GreenDTDParam category, GreenDTDParam content) { + super(width, closed, unrecognized, declType, name, parameters, children); + this.category = category; + this.content = content; + } + + @Override + public short nodeType() { + return DOMNode.DTD_ELEMENT_DECL_NODE; + } + + public GreenDTDParam category() { + return category; + } + + public GreenDTDParam content() { + return content; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDTDElementDecl(newWidth, closed(), unrecognized(), declType(), + name(), parameters(), newChildren, + category, content); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDEntityDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDEntityDecl.java new file mode 100644 index 000000000..2bab3e709 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDEntityDecl.java @@ -0,0 +1,73 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for a DTD ENTITY declaration ({@code }). + */ +public final class GreenDTDEntityDecl extends GreenDTDDeclNode { + + private final GreenDTDParam percent; + private final GreenDTDParam value; + private final GreenDTDParam kind; + private final GreenDTDParam publicId; + private final GreenDTDParam systemId; + + public GreenDTDEntityDecl(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children, + GreenDTDParam percent, GreenDTDParam value, + GreenDTDParam kind, GreenDTDParam publicId, + GreenDTDParam systemId) { + super(width, closed, unrecognized, declType, name, parameters, children); + this.percent = percent; + this.value = value; + this.kind = kind; + this.publicId = publicId; + this.systemId = systemId; + } + + @Override + public short nodeType() { + return Node.ENTITY_NODE; + } + + public GreenDTDParam percent() { + return percent; + } + + public GreenDTDParam value() { + return value; + } + + public GreenDTDParam kind() { + return kind; + } + + public GreenDTDParam publicId() { + return publicId; + } + + public GreenDTDParam systemId() { + return systemId; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDTDEntityDecl(newWidth, closed(), unrecognized(), declType(), + name(), parameters(), newChildren, + percent, value, kind, publicId, systemId); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDNotationDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDNotationDecl.java new file mode 100644 index 000000000..4fce98334 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDNotationDecl.java @@ -0,0 +1,60 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lemminx.dom.DOMNode; + +/** + * Immutable green node for a DTD NOTATION declaration ({@code }). + */ +public final class GreenDTDNotationDecl extends GreenDTDDeclNode { + + private final GreenDTDParam kind; + private final GreenDTDParam publicId; + private final GreenDTDParam systemId; + + public GreenDTDNotationDecl(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children, + GreenDTDParam kind, GreenDTDParam publicId, + GreenDTDParam systemId) { + super(width, closed, unrecognized, declType, name, parameters, children); + this.kind = kind; + this.publicId = publicId; + this.systemId = systemId; + } + + @Override + public short nodeType() { + return DOMNode.DTD_NOTATION_DECL; + } + + public GreenDTDParam kind() { + return kind; + } + + public GreenDTDParam publicId() { + return publicId; + } + + public GreenDTDParam systemId() { + return systemId; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDTDNotationDecl(newWidth, closed(), unrecognized(), declType(), + name(), parameters(), newChildren, + kind, publicId, systemId); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDParam.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDParam.java new file mode 100644 index 000000000..1517044e8 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDParam.java @@ -0,0 +1,40 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +/** + * Immutable representation of a DTD declaration parameter's position. + * + *

Offsets are relative to the owning DTD declaration node's start.

+ */ +public final class GreenDTDParam { + + private final int startRel; + private final int endRel; + + public GreenDTDParam(int startRel, int endRel) { + this.startRel = startRel; + this.endRel = endRel; + } + + public int startRel() { + return startRel; + } + + public int endRel() { + return endRel; + } + + public int width() { + return endRel - startRel; + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java new file mode 100644 index 000000000..338a35b70 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java @@ -0,0 +1,45 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for the document root. + * + *

The document root's width equals the full text length. Its children are + * the top-level nodes (prolog, doctype, root element, comments, PIs).

+ */ +public final class GreenDocument extends GreenNode { + + private final GreenNode[] children; + + public GreenDocument(int width, GreenNode[] children) { + super(width, true); + this.children = children != null ? children : EMPTY_CHILDREN; + } + + @Override + public short nodeType() { + return Node.DOCUMENT_NODE; + } + + @Override + public GreenNode[] children() { + return children; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDocument(newWidth, newChildren); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java new file mode 100644 index 000000000..1c33823f1 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java @@ -0,0 +1,66 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for a DOCTYPE declaration ({@code }). + */ +public final class GreenDocumentType extends GreenDTDDeclNode { + + private final GreenDTDParam kind; + private final GreenDTDParam publicId; + private final GreenDTDParam systemId; + private final GreenDTDParam internalSubset; + + public GreenDocumentType(int width, boolean closed, + GreenDTDParam unrecognized, GreenDTDParam declType, + GreenDTDParam name, GreenDTDParam[] parameters, + GreenNode[] children, + GreenDTDParam kind, GreenDTDParam publicId, + GreenDTDParam systemId, GreenDTDParam internalSubset) { + super(width, closed, unrecognized, declType, name, parameters, children); + this.kind = kind; + this.publicId = publicId; + this.systemId = systemId; + this.internalSubset = internalSubset; + } + + @Override + public short nodeType() { + return Node.DOCUMENT_TYPE_NODE; + } + + public GreenDTDParam kind() { + return kind; + } + + public GreenDTDParam publicId() { + return publicId; + } + + public GreenDTDParam systemId() { + return systemId; + } + + public GreenDTDParam internalSubset() { + return internalSubset; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenDocumentType(newWidth, closed(), unrecognized(), declType(), + name(), parameters(), newChildren, + kind, publicId, systemId, internalSubset); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java new file mode 100644 index 000000000..1a04c3b2e --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -0,0 +1,99 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for an XML element. + * + *

All offsets are relative to the node's own start (i.e., relative + * offset 0 is the first character of the element). The red wrapper adds the + * absolute document offset when queried.

+ */ +public final class GreenElement extends GreenNode { + + public static final int NULL_VALUE = -1; + + private final String tag; + private final boolean selfClosed; + private final int startTagCloseRel; + private final int endTagOpenRel; + private final int endTagCloseRel; + private final int contentStartRel; + private final GreenAttr[] attributes; + private final GreenNode[] children; + + public GreenElement(int width, boolean closed, String tag, boolean selfClosed, + int startTagCloseRel, int endTagOpenRel, int endTagCloseRel, + int contentStartRel, + GreenAttr[] attributes, GreenNode[] children) { + super(width, closed); + this.tag = tag; + this.selfClosed = selfClosed; + this.startTagCloseRel = startTagCloseRel; + this.endTagOpenRel = endTagOpenRel; + this.endTagCloseRel = endTagCloseRel; + this.contentStartRel = contentStartRel; + this.attributes = attributes != null ? attributes : EMPTY_ATTRS; + this.children = children != null ? children : EMPTY_CHILDREN; + } + + @Override + public short nodeType() { + return Node.ELEMENT_NODE; + } + + public String tag() { + return tag; + } + + public boolean selfClosed() { + return selfClosed; + } + + public int startTagCloseRel() { + return startTagCloseRel; + } + + public int endTagOpenRel() { + return endTagOpenRel; + } + + public int endTagCloseRel() { + return endTagCloseRel; + } + + public int contentStartRel() { + return contentStartRel; + } + + public GreenAttr[] attributes() { + return attributes; + } + + public int attributeCount() { + return attributes.length; + } + + @Override + public GreenNode[] children() { + return children; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenElement(newWidth, closed(), tag, selfClosed, + startTagCloseRel, endTagOpenRel, endTagCloseRel, + contentStartRel, attributes, newChildren); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java new file mode 100644 index 000000000..2c0e51e22 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java @@ -0,0 +1,113 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import java.util.ArrayList; +import java.util.List; + +/** + * Mutable builder for {@link GreenElement}. + * + *

Used during parsing: the scanner populates fields across multiple + * tokens, then {@link #build()} freezes the result into an immutable + * {@link GreenElement}.

+ */ +public final class GreenElementBuilder { + + private final int nodeStart; + private int nodeEnd; + private String tag; + private boolean selfClosed; + private boolean closed; + private int startTagCloseOffset = GreenElement.NULL_VALUE; + private int endTagOpenOffset = GreenElement.NULL_VALUE; + private int endTagCloseOffset = GreenElement.NULL_VALUE; + private List attributes; + private List children; + + public GreenElementBuilder(int nodeStart) { + this.nodeStart = nodeStart; + this.nodeEnd = nodeStart; + } + + public int nodeStart() { + return nodeStart; + } + + public int nodeEnd() { + return nodeEnd; + } + + public void setNodeEnd(int nodeEnd) { + this.nodeEnd = nodeEnd; + } + + public String tag() { + return tag; + } + + public void setTag(String tag) { + this.tag = tag; + } + + public void setSelfClosed(boolean selfClosed) { + this.selfClosed = selfClosed; + } + + public void setClosed(boolean closed) { + this.closed = closed; + } + + public void setStartTagCloseOffset(int offset) { + this.startTagCloseOffset = offset; + } + + public void setEndTagOpenOffset(int offset) { + this.endTagOpenOffset = offset; + } + + public void setEndTagCloseOffset(int offset) { + this.endTagCloseOffset = offset; + } + + public void addAttribute(GreenAttr attr) { + if (attributes == null) { + attributes = new ArrayList<>(4); + } + attributes.add(attr); + } + + public void addChild(GreenNode child) { + if (children == null) { + children = new ArrayList<>(4); + } + children.add(child); + } + + public GreenElement build() { + int width = nodeEnd - nodeStart; + int stcRel = startTagCloseOffset != GreenElement.NULL_VALUE + ? startTagCloseOffset - nodeStart : GreenElement.NULL_VALUE; + int etoRel = endTagOpenOffset != GreenElement.NULL_VALUE + ? endTagOpenOffset - nodeStart : GreenElement.NULL_VALUE; + int etcRel = endTagCloseOffset != GreenElement.NULL_VALUE + ? endTagCloseOffset - nodeStart : GreenElement.NULL_VALUE; + + GreenAttr[] attrs = attributes != null + ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + GreenNode[] kids = children != null + ? children.toArray(GreenNode.EMPTY_CHILDREN) : null; + + return new GreenElement(width, closed, tag, selfClosed, + stcRel, etoRel, etcRel, GreenElement.NULL_VALUE, attrs, kids); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java new file mode 100644 index 000000000..63bd3cdfc --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java @@ -0,0 +1,70 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +/** + * Immutable green node — the backbone of the red-green tree. + * + *

Green nodes store width (character span), not absolute offsets. + * They carry no parent pointer and are safe to share across document versions. + * The mutable red wrapper (the existing {@code DOMNode} hierarchy) computes + * absolute positions lazily from the green tree.

+ * + *

All subclasses must be immutable: every field is {@code final} and every + * collection is an unmodifiable snapshot taken at construction time.

+ */ +public abstract class GreenNode { + + public static final GreenNode[] EMPTY_CHILDREN = new GreenNode[0]; + public static final GreenAttr[] EMPTY_ATTRS = new GreenAttr[0]; + + private final int width; + private final boolean closed; + + protected GreenNode(int width, boolean closed) { + this.width = width; + this.closed = closed; + } + + public abstract short nodeType(); + + public int width() { + return width; + } + + public boolean closed() { + return closed; + } + + public GreenNode[] children() { + return EMPTY_CHILDREN; + } + + public int childCount() { + return children().length; + } + + public GreenNode child(int index) { + return children()[index]; + } + + public GreenNode withReplacedChild(int index, GreenNode newChild) { + GreenNode[] old = children(); + GreenNode[] copy = new GreenNode[old.length]; + System.arraycopy(old, 0, copy, 0, old.length); + int deltaWidth = newChild.width() - old[index].width(); + copy[index] = newChild; + return replaceChildren(copy, width + deltaWidth); + } + + protected abstract GreenNode replaceChildren(GreenNode[] newChildren, int newWidth); +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java new file mode 100644 index 000000000..07b23f7b1 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java @@ -0,0 +1,89 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for a processing instruction ({@code }) + * or XML prolog ({@code }). + */ +public final class GreenProcessingInstruction extends GreenNode { + + private final boolean startTagClose; + private final String target; + private final boolean prolog; + private final boolean processingInstruction; + private final int startContentRel; + private final int endContentRel; + private final int endTagOpenRel; + private final GreenAttr[] attributes; + + public GreenProcessingInstruction(int width, boolean closed, boolean startTagClose, + String target, boolean prolog, boolean processingInstruction, + int startContentRel, int endContentRel, int endTagOpenRel, + GreenAttr[] attributes) { + super(width, closed); + this.startTagClose = startTagClose; + this.target = target; + this.prolog = prolog; + this.processingInstruction = processingInstruction; + this.startContentRel = startContentRel; + this.endContentRel = endContentRel; + this.endTagOpenRel = endTagOpenRel; + this.attributes = attributes != null ? attributes : EMPTY_ATTRS; + } + + @Override + public short nodeType() { + return Node.PROCESSING_INSTRUCTION_NODE; + } + + public boolean startTagClose() { + return startTagClose; + } + + public String target() { + return target; + } + + public boolean prolog() { + return prolog; + } + + public boolean processingInstruction() { + return processingInstruction; + } + + public int startContentRel() { + return startContentRel; + } + + public int endContentRel() { + return endContentRel; + } + + public int endTagOpenRel() { + return endTagOpenRel; + } + + public GreenAttr[] attributes() { + return attributes; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenProcessingInstruction(newWidth, closed(), startTagClose, + target, prolog, processingInstruction, + startContentRel, endContentRel, endTagOpenRel, attributes); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java new file mode 100644 index 000000000..5608f3c9b --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java @@ -0,0 +1,41 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.w3c.dom.Node; + +/** + * Immutable green node for a text content node. + */ +public final class GreenText extends GreenNode { + + private final boolean whitespace; + + public GreenText(int width, boolean whitespace) { + super(width, true); + this.whitespace = whitespace; + } + + @Override + public short nodeType() { + return Node.TEXT_NODE; + } + + public boolean whitespace() { + return whitespace; + } + + @Override + protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { + return new GreenText(newWidth, whitespace); + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java new file mode 100644 index 000000000..cada2a5f6 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -0,0 +1,1162 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; + +import org.eclipse.lemminx.dom.DOMNode; +import org.eclipse.lemminx.dom.parser.Scanner; +import org.eclipse.lemminx.dom.parser.TokenType; +import org.eclipse.lemminx.dom.parser.XMLScanner; +import org.eclipse.lemminx.utils.DOMUtils; +import org.eclipse.lsp4j.jsonrpc.CancelChecker; + +/** + * Builds an immutable {@link GreenDocument} from XML text using the scanner. + * + *

This mirrors the logic of {@code DOMParser} but produces green nodes + * (width-based, immutable, no parent pointers) instead of red DOM nodes.

+ */ +public final class GreenTreeBuilder { + + private GreenTreeBuilder() { + } + + /** + * Parses the given XML text and returns an immutable green tree. + * + * @param text the XML text + * @param uri the document URI + * @param monitor optional cancel checker + * @return the root green document node + */ + public static GreenDocument parse(String text, String uri, CancelChecker monitor) { + return parse(text, uri, true, monitor); + } + + public static GreenDocument parse(String text, String uri, + boolean ignoreWhitespaceContent, CancelChecker monitor) { + boolean isDTD = DOMUtils.isDTD(uri); + Scanner scanner = XMLScanner.createScanner(text, 0, isDTD); + + Deque stack = new ArrayDeque<>(); + List rootChildren = new ArrayList<>(); + + if (isDTD) { + NodeBuilder dtdRoot = new NodeBuilder(NodeKind.DOCUMENT_TYPE, 0); + dtdRoot.closed = true; + stack.push(dtdRoot); + } + + GreenAttrBuilder currentAttr = null; + int endTagOpenOffset = -1; + boolean previousTokenWasEndTagOpen = false; + boolean isInitialDeclaration = true; + boolean inDTDInternalSubset = false; + GreenText tempWhitespaceContent = null; + int tempWhitespaceStart = -1; + int[] nextRootChildEnd = { 0 }; + + NodeBuilder lastClosed = null; + + TokenType token = scanner.scan(); + while (token != TokenType.EOS) { + if (monitor != null) { + monitor.checkCanceled(); + } + + if (tempWhitespaceContent != null && token != TokenType.EndTagOpen) { + tempWhitespaceContent = null; + } + + if (previousTokenWasEndTagOpen) { + previousTokenWasEndTagOpen = false; + boolean linkToEmptyStartTag = false; + + if (token == TokenType.EndTagClose) { + // + while (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.kind == NodeKind.ELEMENT && top.tag == null) { + break; + } + if (stack.size() == 1 && !isDTD) { + break; + } + top.nodeEnd = endTagOpenOffset; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + linkToEmptyStartTag = true; + top.closed = true; + top.endTagOpenOffset = endTagOpenOffset; + top.nodeEnd = scanner.getTokenEnd(); + } + } + + if (token != TokenType.EndTag && !linkToEmptyStartTag) { + GreenElement fakeEndTag = new GreenElement( + 2, false, null, false, + GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, null, null); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); + } + } + + if (currentAttr != null + && token != TokenType.DelimiterAssign + && token != TokenType.AttributeValue + && token != TokenType.Whitespace) { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addAttribute(currentAttr.build(top.nodeStart)); + } + currentAttr = null; + } + + switch (token) { + case StartTagOpen: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (!top.closed) { + top.nodeEnd = scanner.getTokenOffset(); + } + if (isDTD) { + if (top.closed && top.kind != NodeKind.DOCUMENT_TYPE) { + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } else if (isDTDDeclKind(top.kind)) { + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + } else if (top.closed || top.kind == NodeKind.DOCUMENT_TYPE) { + if (top.kind == NodeKind.DOCUMENT_TYPE) { + inDTDInternalSubset = false; + } + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + } + NodeBuilder element = new NodeBuilder(NodeKind.ELEMENT, scanner.getTokenOffset()); + element.startTagOpenOffset = scanner.getTokenOffset(); + stack.push(element); + break; + } + + case StartTag: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.tag = scanner.getTokenText(); + top.nodeEnd = scanner.getTokenEnd(); + } + break; + } + + case StartTagClose: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + if (top.kind == NodeKind.ELEMENT) { + top.startTagCloseOffset = scanner.getTokenOffset(); + } else if (top.kind == NodeKind.PROCESSING_INSTRUCTION) { + top.startTagClose = true; + } + } + break; + } + + case EndTagOpen: { + if (tempWhitespaceContent != null) { + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, tempWhitespaceContent, tempWhitespaceStart); + tempWhitespaceContent = null; + } + endTagOpenOffset = scanner.getTokenOffset(); + if (!stack.isEmpty() && !stack.peek().closed) { + stack.peek().nodeEnd = scanner.getTokenOffset(); + } + previousTokenWasEndTagOpen = true; + break; + } + + case EndTag: { + String closeTag = scanner.getTokenText(); + if (hasMatchingElement(stack, closeTag)) { + while (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.kind == NodeKind.ELEMENT && closeTag.equals(top.tag)) { + break; + } + if (stack.size() == 1 && !isDTD) { + break; + } + top.nodeEnd = endTagOpenOffset; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + } + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.kind == NodeKind.ELEMENT && closeTag.equals(top.tag)) { + top.closed = true; + top.endTagOpenOffset = endTagOpenOffset; + top.nodeEnd = scanner.getTokenEnd(); + } else { + NodeBuilder orphan = new NodeBuilder(NodeKind.ELEMENT, + scanner.getTokenOffset() - 2); + orphan.endTagOpenOffset = endTagOpenOffset; + orphan.tag = closeTag; + orphan.nodeEnd = scanner.getTokenEnd(); + stack.push(orphan); + } + } else { + NodeBuilder orphan = new NodeBuilder(NodeKind.ELEMENT, + scanner.getTokenOffset() - 2); + orphan.endTagOpenOffset = endTagOpenOffset; + orphan.tag = closeTag; + orphan.nodeEnd = scanner.getTokenEnd(); + stack.push(orphan); + } + break; + } + + case StartTagSelfClose: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.closed = true; + top.selfClosed = true; + top.nodeEnd = scanner.getTokenEnd(); + lastClosed = top; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case EndTagClose: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + if (top.kind == NodeKind.ELEMENT) { + top.endTagCloseOffset = scanner.getTokenOffset(); + } + if (top.kind == NodeKind.DOCUMENT_TYPE) { + top.closed = true; + } + lastClosed = top; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case AttributeName: { + currentAttr = new GreenAttrBuilder(); + currentAttr.setName(scanner.getTokenOffset(), scanner.getTokenEnd()); + if (!stack.isEmpty()) { + stack.peek().nodeEnd = scanner.getTokenEnd(); + } + break; + } + + case DelimiterAssign: { + if (currentAttr != null) { + currentAttr.setDelimiter(scanner.getTokenOffset()); + } + break; + } + + case AttributeValue: { + if (currentAttr != null && !stack.isEmpty()) { + NodeBuilder top = stack.peek(); + currentAttr.setValue(scanner.getTokenOffset(), scanner.getTokenEnd()); + top.addAttribute(currentAttr.build(top.nodeStart)); + } + currentAttr = null; + if (!stack.isEmpty()) { + stack.peek().nodeEnd = scanner.getTokenEnd(); + } + break; + } + + case CDATATagOpen: { + NodeBuilder cdata = new NodeBuilder(NodeKind.CDATA, scanner.getTokenOffset()); + stack.push(cdata); + break; + } + + case CDATAContent: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.startContentOffset = scanner.getTokenOffset(); + top.endContentOffset = scanner.getTokenEnd(); + top.nodeEnd = scanner.getTokenEnd(); + } + break; + } + + case CDATATagClose: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + top.closed = true; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case StartPrologOrPI: { + NodeBuilder pi = new NodeBuilder(NodeKind.PROCESSING_INSTRUCTION, + scanner.getTokenOffset()); + stack.push(pi); + break; + } + + case PIName: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.target = scanner.getTokenText(); + top.processingInstruction = true; + } + break; + } + + case PrologName: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.target = scanner.getTokenText(); + top.prolog = true; + } + break; + } + + case PIContent: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.startContentOffset = scanner.getTokenOffset(); + top.endContentOffset = scanner.getTokenEnd(); + } + break; + } + + case PIEnd: + case PrologEnd: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + top.closed = true; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case StartCommentTag: { + if (isDTD || inDTDInternalSubset) { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + } else if (!stack.isEmpty() && stack.peek().closed) { + NodeBuilder top = stack.peek(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder comment = new NodeBuilder(NodeKind.COMMENT, scanner.getTokenOffset()); + if (lastClosed != null && lastClosed.nodeEnd <= scanner.getTokenOffset()) { + comment.commentSameLineEndTag = !containsNewline(text, + lastClosed.nodeEnd, scanner.getTokenOffset()); + } + stack.push(comment); + break; + } + + case Comment: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.startContentOffset = scanner.getTokenOffset(); + top.endContentOffset = scanner.getTokenEnd(); + } + break; + } + + case EndCommentTag: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + top.closed = true; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case Content: { + boolean currIsDeclNode = !stack.isEmpty() + && isDTDDeclKind(stack.peek().kind); + if (currIsDeclNode) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset() - 1; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + int start = scanner.getTokenOffset(); + int end = scanner.getTokenEnd(); + boolean isBlank = scanner.isTokenTextBlank(); + + if (isBlank && currIsDeclNode) { + break; + } + + GreenText textNode = new GreenText(end - start, isBlank); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, textNode, start); + break; + } + + // DTD tokens + case DTDStartDoctypeTag: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder doctype = new NodeBuilder(NodeKind.DOCUMENT_TYPE, + scanner.getTokenOffset()); + stack.push(doctype); + break; + } + + case DTDDoctypeName: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdNameParam = stack.peek().lastParam(); + } + break; + } + + case DTDDocTypeKindPUBLIC: + case DTDDocTypeKindSYSTEM: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdKindParam = stack.peek().lastParam(); + } + break; + } + + case DTDDoctypePublicId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdPublicIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDDoctypeSystemId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdSystemIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDStartInternalSubset: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addParam(scanner.getTokenOffset(), scanner.getTokenOffset() + 1); + top.dtdInternalSubsetParam = top.lastParam(); + inDTDInternalSubset = true; + } + break; + } + + case DTDEndInternalSubset: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset() - 1; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + inDTDInternalSubset = false; + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.dtdInternalSubsetParam != null) { + top.dtdInternalSubsetParam = new int[] { + top.dtdInternalSubsetParam[0], scanner.getTokenEnd() }; + } + } + break; + } + + case DTDStartElement: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder decl = new NodeBuilder(NodeKind.DTD_ELEMENT_DECL, + scanner.getTokenOffset()); + decl.addDeclType(scanner.getTokenOffset() + 2, scanner.getTokenOffset() + 9); + stack.push(decl); + break; + } + + case DTDElementDeclName: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdNameParam = stack.peek().lastParam(); + } + break; + } + + case DTDElementCategory: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdCategoryParam = stack.peek().lastParam(); + } + break; + } + + case DTDStartElementContent: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdContentParam = stack.peek().lastParam(); + } + break; + } + + case DTDElementContent: + case DTDEndElementContent: { + if (!stack.isEmpty()) { + stack.peek().updateLastParamEnd(scanner.getTokenEnd()); + } + break; + } + + case DTDStartAttlist: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder decl = new NodeBuilder(NodeKind.DTD_ATTLIST_DECL, + scanner.getTokenOffset()); + decl.addDeclType(scanner.getTokenOffset() + 2, scanner.getTokenOffset() + 9); + isInitialDeclaration = true; + stack.push(decl); + break; + } + + case DTDAttlistElementName: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdNameParam = stack.peek().lastParam(); + } + break; + } + + case DTDAttlistAttributeName: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.kind == NodeKind.DTD_ATTLIST_DECL && top.dtdAttributeNameParam != null) { + int internalStart = lastParamEnd(top); + if (stack.size() >= 2) { + NodeBuilder below = peekSecond(stack); + if (below != null && below.kind == NodeKind.DTD_ATTLIST_DECL) { + top.nodeEnd = internalStart; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + } + NodeBuilder internalAttlist = new NodeBuilder(NodeKind.DTD_ATTLIST_DECL, + internalStart); + stack.push(internalAttlist); + top = internalAttlist; + } + top.addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + top.dtdAttributeNameParam = top.lastParam(); + } + break; + } + + case DTDAttlistAttributeType: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + top.dtdAttributeTypeParam = top.lastParam(); + } + break; + } + + case DTDAttlistAttributeValue: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + top.dtdAttributeValueParam = top.lastParam(); + } + break; + } + + case DTDStartEntity: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder decl = new NodeBuilder(NodeKind.DTD_ENTITY_DECL, + scanner.getTokenOffset()); + decl.addDeclType(scanner.getTokenOffset() + 2, scanner.getTokenOffset() + 8); + stack.push(decl); + break; + } + + case DTDEntityPercent: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdPercentParam = stack.peek().lastParam(); + } + break; + } + + case DTDEntityName: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdNameParam = stack.peek().lastParam(); + } + break; + } + + case DTDEntityValue: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdValueParam = stack.peek().lastParam(); + } + break; + } + + case DTDEntityKindPUBLIC: + case DTDEntityKindSYSTEM: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdKindParam = stack.peek().lastParam(); + } + break; + } + + case DTDEntityPublicId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdPublicIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDEntitySystemId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdSystemIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDStartNotation: { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenOffset(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + NodeBuilder decl = new NodeBuilder(NodeKind.DTD_NOTATION_DECL, + scanner.getTokenOffset()); + decl.addDeclType(scanner.getTokenOffset() + 2, scanner.getTokenOffset() + 10); + isInitialDeclaration = true; + stack.push(decl); + break; + } + + case DTDNotationName: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdNameParam = stack.peek().lastParam(); + } + break; + } + + case DTDNotationKindPUBLIC: + case DTDNotationKindSYSTEM: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdKindParam = stack.peek().lastParam(); + } + break; + } + + case DTDNotationPublicId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdPublicIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDNotationSystemId: { + if (!stack.isEmpty()) { + stack.peek().addParam(scanner.getTokenOffset(), scanner.getTokenEnd()); + stack.peek().dtdSystemIdParam = stack.peek().lastParam(); + } + break; + } + + case DTDEndTag: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + if (top.kind == NodeKind.DTD_ELEMENT_DECL + || top.kind == NodeKind.DTD_ATTLIST_DECL + || top.kind == NodeKind.DTD_ENTITY_DECL + || top.kind == NodeKind.DTD_NOTATION_DECL) { + while (!stack.isEmpty() && stack.peek().kind != NodeKind.DOCUMENT_TYPE) { + NodeBuilder nb = stack.peek(); + nb.nodeEnd = scanner.getTokenEnd(); + nb.closed = true; + GreenNode built = nb.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, nb.nodeStart); + } + } + } + break; + } + + case DTDEndDoctypeTag: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = scanner.getTokenEnd(); + top.closed = true; + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + break; + } + + case DTDUnrecognizedParameters: { + if (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addParam(scanner.getTokenOffset(), + ((XMLScanner) scanner).getLastNonWhitespaceOffset()); + top.dtdUnrecognizedParam = top.lastParam(); + } + break; + } + + default: + if (!stack.isEmpty() && stack.peek().closed + && stack.peek().kind != NodeKind.ELEMENT) { + stack.peek().nodeEnd = scanner.getTokenEnd(); + } + break; + } + + token = scanner.scan(); + } + + if (previousTokenWasEndTagOpen) { + GreenElement fakeEndTag = new GreenElement( + 2, false, null, false, + GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, null, null); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); + } + + // Flush pending attribute before closing remaining nodes + if (currentAttr != null && !stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.addAttribute(currentAttr.build(top.nodeStart)); + currentAttr = null; + } + + // Flush remaining open nodes + while (!stack.isEmpty()) { + NodeBuilder top = stack.peek(); + top.nodeEnd = text.length(); + GreenNode built = top.buildGreen(); + stack.pop(); + addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); + } + + return new GreenDocument(text.length(), + rootChildren.toArray(GreenNode.EMPTY_CHILDREN)); + } + + private static int lastParamEnd(NodeBuilder nb) { + if (nb.dtdParams != null && !nb.dtdParams.isEmpty()) { + return nb.dtdParams.get(nb.dtdParams.size() - 1)[1]; + } + return nb.nodeEnd; + } + + private static NodeBuilder peekSecond(Deque stack) { + java.util.Iterator it = stack.iterator(); + if (it.hasNext()) { + it.next(); + } + return it.hasNext() ? it.next() : null; + } + + private static boolean isDTDDeclKind(NodeKind kind) { + return kind == NodeKind.DTD_ENTITY_DECL + || kind == NodeKind.DTD_ELEMENT_DECL + || kind == NodeKind.DTD_ATTLIST_DECL + || kind == NodeKind.DTD_NOTATION_DECL + || kind == NodeKind.DTD_DECL; + } + + private static boolean hasMatchingElement(Deque stack, String tag) { + for (NodeBuilder nb : stack) { + if (nb.kind == NodeKind.ELEMENT && tag.equals(nb.tag)) { + return true; + } + } + return false; + } + + private static boolean containsNewline(String text, int from, int to) { + for (int i = from; i < to; i++) { + char c = text.charAt(i); + if (c == '\n' || c == '\r') { + return true; + } + } + return false; + } + + private static void addChildToCurrentOrRoot(Deque stack, + List rootChildren, int[] nextRootChildEnd, + GreenNode child, int childAbsStart) { + if (!stack.isEmpty()) { + stack.peek().addChild(child, childAbsStart); + } else { + if (childAbsStart > nextRootChildEnd[0]) { + rootChildren.add(new GreenText(childAbsStart - nextRootChildEnd[0], true)); + } + rootChildren.add(child); + nextRootChildEnd[0] = childAbsStart + child.width(); + } + } + + enum NodeKind { + ELEMENT, COMMENT, TEXT, CDATA, PROCESSING_INSTRUCTION, + DOCUMENT_TYPE, DTD_DECL, + DTD_ELEMENT_DECL, DTD_ATTLIST_DECL, DTD_ENTITY_DECL, DTD_NOTATION_DECL + } + + static final class NodeBuilder { + final NodeKind kind; + final int nodeStart; + int nodeEnd; + boolean closed; + + // Element fields + String tag; + boolean selfClosed; + int startTagOpenOffset = GreenElement.NULL_VALUE; + int startTagCloseOffset = GreenElement.NULL_VALUE; + int endTagOpenOffset = GreenElement.NULL_VALUE; + int endTagCloseOffset = GreenElement.NULL_VALUE; + List attributes; + + // PI fields + boolean startTagClose; + String target; + boolean prolog; + boolean processingInstruction; + + // Content offsets (comment, CDATA, PI) + int startContentOffset = GreenElement.NULL_VALUE; + int endContentOffset = GreenElement.NULL_VALUE; + boolean commentSameLineEndTag; + + // DTD fields + int[] dtdDeclType; + int[] dtdNameParam; + int[] dtdKindParam; + int[] dtdPublicIdParam; + int[] dtdSystemIdParam; + int[] dtdInternalSubsetParam; + int[] dtdCategoryParam; + int[] dtdContentParam; + int[] dtdAttributeNameParam; + int[] dtdAttributeTypeParam; + int[] dtdAttributeValueParam; + int[] dtdPercentParam; + int[] dtdValueParam; + int[] dtdUnrecognizedParam; + List dtdParams; + + // Children + List children; + int firstChildAbsStart = GreenElement.NULL_VALUE; + int nextChildAbsStart = GreenElement.NULL_VALUE; + + NodeBuilder(NodeKind kind, int nodeStart) { + this.kind = kind; + this.nodeStart = nodeStart; + this.nodeEnd = nodeStart; + } + + void addChild(GreenNode child, int childAbsStart) { + if (children == null) { + children = new ArrayList<>(4); + firstChildAbsStart = childAbsStart; + nextChildAbsStart = childAbsStart; + } + if (childAbsStart > nextChildAbsStart) { + children.add(new GreenText(childAbsStart - nextChildAbsStart, true)); + } + children.add(child); + nextChildAbsStart = childAbsStart + child.width(); + } + + void addAttribute(GreenAttr attr) { + if (attributes == null) { + attributes = new ArrayList<>(4); + } + attributes.add(attr); + } + + void addParam(int start, int end) { + if (dtdParams == null) { + dtdParams = new ArrayList<>(4); + } + dtdParams.add(new int[] { start, end }); + } + + void addDeclType(int start, int end) { + dtdDeclType = new int[] { start, end }; + } + + int[] lastParam() { + return dtdParams.get(dtdParams.size() - 1); + } + + void updateLastParamEnd(int end) { + if (dtdParams != null && !dtdParams.isEmpty()) { + int[] last = dtdParams.get(dtdParams.size() - 1); + last[1] = end; + } + } + + GreenNode buildGreen() { + int width = nodeEnd - nodeStart; + GreenNode[] kids = children != null + ? children.toArray(GreenNode.EMPTY_CHILDREN) : null; + + switch (kind) { + case ELEMENT: + return buildElement(width, kids); + case COMMENT: + return buildComment(width); + case CDATA: + return buildCDATA(width); + case PROCESSING_INSTRUCTION: + return buildPI(width); + case DOCUMENT_TYPE: + return buildDocumentType(width, kids); + case DTD_ELEMENT_DECL: + return buildDTDElementDecl(width, kids); + case DTD_ATTLIST_DECL: + return buildDTDAttlistDecl(width, kids); + case DTD_ENTITY_DECL: + return buildDTDEntityDecl(width, kids); + case DTD_NOTATION_DECL: + return buildDTDNotationDecl(width, kids); + case DTD_DECL: + return buildDTDDeclNode(width, kids); + default: + return new GreenText(width, false); + } + } + + private GreenElement buildElement(int width, GreenNode[] kids) { + GreenAttr[] attrs = attributes != null + ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + int contentStart = firstChildAbsStart != GreenElement.NULL_VALUE + ? firstChildAbsStart - nodeStart + : (startTagCloseOffset != GreenElement.NULL_VALUE + ? startTagCloseOffset + 1 - nodeStart + : GreenElement.NULL_VALUE); + return new GreenElement(width, closed, tag, selfClosed, + rel(startTagCloseOffset), rel(endTagOpenOffset), + rel(endTagCloseOffset), contentStart, attrs, kids); + } + + private GreenComment buildComment(int width) { + return new GreenComment(width, closed, commentSameLineEndTag, + rel(startContentOffset), rel(endContentOffset)); + } + + private GreenCDATA buildCDATA(int width) { + return new GreenCDATA(width, closed, + rel(startContentOffset), rel(endContentOffset)); + } + + private GreenProcessingInstruction buildPI(int width) { + GreenAttr[] attrs = attributes != null + ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + return new GreenProcessingInstruction(width, closed, startTagClose, + target, prolog, processingInstruction, + rel(startContentOffset), rel(endContentOffset), + rel(endTagOpenOffset), attrs); + } + + private GreenDocumentType buildDocumentType(int width, GreenNode[] kids) { + kids = padChildrenForDocType(kids); + return new GreenDocumentType(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids, + toParam(dtdKindParam), + toParam(dtdPublicIdParam), + toParam(dtdSystemIdParam), + toParam(dtdInternalSubsetParam)); + } + + private GreenNode[] padChildrenForDocType(GreenNode[] kids) { + if (dtdInternalSubsetParam == null || kids == null || kids.length == 0 + || firstChildAbsStart == GreenElement.NULL_VALUE) { + return kids; + } + int contentStart = dtdInternalSubsetParam[0] + 1; + int leadingGap = firstChildAbsStart - contentStart; + if (leadingGap <= 0) { + return kids; + } + GreenNode[] padded = new GreenNode[kids.length + 1]; + padded[0] = new GreenText(leadingGap, true); + System.arraycopy(kids, 0, padded, 1, kids.length); + return padded; + } + + private GreenDTDElementDecl buildDTDElementDecl(int width, GreenNode[] kids) { + return new GreenDTDElementDecl(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids, + toParam(dtdCategoryParam), + toParam(dtdContentParam)); + } + + private GreenDTDAttlistDecl buildDTDAttlistDecl(int width, GreenNode[] kids) { + return new GreenDTDAttlistDecl(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids, + toParam(dtdAttributeNameParam), + toParam(dtdAttributeTypeParam), + toParam(dtdAttributeValueParam), + null); + } + + private GreenDTDEntityDecl buildDTDEntityDecl(int width, GreenNode[] kids) { + return new GreenDTDEntityDecl(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids, + toParam(dtdPercentParam), + toParam(dtdValueParam), + toParam(dtdKindParam), + toParam(dtdPublicIdParam), + toParam(dtdSystemIdParam)); + } + + private GreenDTDNotationDecl buildDTDNotationDecl(int width, GreenNode[] kids) { + return new GreenDTDNotationDecl(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids, + toParam(dtdKindParam), + toParam(dtdPublicIdParam), + toParam(dtdSystemIdParam)); + } + + private GreenDTDDeclNode buildDTDDeclNode(int width, GreenNode[] kids) { + return new GreenDTDDeclNode(width, closed, + toParam(dtdUnrecognizedParam), + toParam(dtdDeclType), + toParam(dtdNameParam), + buildDTDParams(), + kids); + } + + private int rel(int absOffset) { + return absOffset != GreenElement.NULL_VALUE ? absOffset - nodeStart : GreenElement.NULL_VALUE; + } + + private GreenDTDParam toParam(int[] offsets) { + if (offsets == null) { + return null; + } + return new GreenDTDParam(offsets[0] - nodeStart, offsets[1] - nodeStart); + } + + private GreenDTDParam[] buildDTDParams() { + if (dtdParams == null || dtdParams.isEmpty()) { + return null; + } + GreenDTDParam[] result = new GreenDTDParam[dtdParams.size()]; + for (int i = 0; i < dtdParams.size(); i++) { + int[] p = dtdParams.get(i); + result[i] = new GreenDTDParam(p[0] - nodeStart, p[1] - nodeStart); + } + return result; + } + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/extensions/completion/AbstractElementCompletionItem.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/extensions/completion/AbstractElementCompletionItem.java index 8ae30a9b4..b605c7e86 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/extensions/completion/AbstractElementCompletionItem.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/extensions/completion/AbstractElementCompletionItem.java @@ -231,6 +231,12 @@ private static boolean isTextNode(DOMNode node, int offset) { } DOMElement element = (DOMElement) node; if (element.getEnd() <= offset) { + // When the cursor is at the exact end of an incomplete start tag + // (e.g., | return true; } @@ -292,6 +298,12 @@ private static List getAdditionalTextEdits(DOMNode node, int offset, S DOMElement element = (DOMElement) node; int endElementOffset = node.getEnd() - 1; endElement = element.hasEndTag() ? element : element.getOrphanEndElement(endElementOffset, tagName, true); + if (endElement == null && !element.hasEndTag()) { + // The orphan end tag might be a sibling rather than a child + // (e.g., where is a sibling of ). + // Search using the cursor offset which reaches beyond the element. + endElement = element.getOrphanEndElement(offset, tagName, true); + } } if (endElement != null && !tagName.equals(endElement.getTagName())) { Range range = XMLPositionUtility.selectEndTagName(endElement); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java index acbfaa8b2..2f05f8dd8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java @@ -37,12 +37,16 @@ public void formatCDATASection(DOMCDATASection cDATANode, XMLFormattingConstrain } if (isJoinCDATALines()) { + int cDATAStartContent = cDATANode.getStartContent(); + int cDATAEndContent = cDATANode.getEndContent(); + if (cDATAStartContent < 0 || cDATAEndContent < 0) { + // Empty CDATA section (e.g. ), nothing to format + return; + } int availableLineWidth = parentConstraints.getAvailableLineWidth(); int spaceStart = -1; int spaceEnd = -1; int contentEnd = -1; - int cDATAStartContent = cDATANode.getStartContent(); - int cDATAEndContent = cDATANode.getEndContent(); for (int i = cDATAStartContent; i <= cDATAEndContent; i++) { char c = text.charAt(i); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java index 2bc44b5f7..58d6483dc 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java @@ -658,6 +658,9 @@ private EmptyElements getEmptyElements(DOMElement element) { private static boolean formatDTD(DOMDocumentType doctype, int level, int end, XMLBuilder xmlBuilder) { DOMNode previous = null; for (DOMNode node : doctype.getChildren()) { + if (node.isText() && ((DOMText) node).isWhitespace()) { + continue; + } if (previous != null) { xmlBuilder.linefeed(); } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenRedConsistencyTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenRedConsistencyTest.java new file mode 100644 index 000000000..3475bfe12 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenRedConsistencyTest.java @@ -0,0 +1,235 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.DOMDocument; +import org.eclipse.lemminx.dom.DOMElement; +import org.eclipse.lemminx.dom.DOMNode; +import org.eclipse.lemminx.dom.DOMParser; +import org.junit.jupiter.api.Test; +import org.w3c.dom.Node; + +/** + * Validates that the green tree builder produces a structure consistent + * with the existing DOMParser. + */ +public class GreenRedConsistencyTest { + + @Test + public void simpleDocument() { + assertConsistent(""); + } + + @Test + public void nestedDocument() { + assertConsistent("text"); + } + + @Test + public void multipleChildren() { + assertConsistent(""); + } + + @Test + public void attributes() { + assertConsistent(""); + } + + @Test + public void mixedContent() { + assertConsistent("

hello world end

"); + } + + @Test + public void commentAndPI() { + assertConsistent(""); + } + + @Test + public void selfClosing() { + assertConsistent("
"); + } + + @Test + public void unclosedTag() { + assertConsistent(""); + } + + @Test + public void orphanEndTag() { + assertConsistent(""); + } + + @Test + public void cdataSection() { + assertConsistent(""); + } + + @Test + public void doctypeWithInternalSubset() { + assertConsistent( + "\n" + + " \n" + + "]>\n"); + } + + @Test + public void doctypeWithEntities() { + assertConsistent( + "\n" + + " \n" + + "]>\n"); + } + + @Test + public void orphanEndTagNoMatch() { + assertConsistent(""); + } + + @Test + public void multipleOrphanEndTags() { + assertConsistent(""); + } + + @Test + public void commentBetweenElements() { + assertConsistent(""); + } + + @Test + public void whitespaceOnlyContent() { + assertConsistent(" "); + } + + @Test + public void emptyDocument() { + assertConsistent(""); + } + + @Test + public void textOnly() { + assertConsistent("plain text"); + } + + @Test + public void unclosedTags() { + assertConsistent(""); + } + + @Test + public void windowsCRLF() { + assertConsistent("\r\n \r\n"); + } + + @Test + public void largeDocument() { + StringBuilder sb = new StringBuilder(); + sb.append("\n"); + for (int i = 0; i < 100; i++) { + sb.append(" value ").append(i).append("\n"); + } + sb.append(""); + assertConsistent(sb.toString()); + } + + private void assertConsistent(String xml) { + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + DOMDocument domDoc = DOMParser.getInstance().parse(textDoc, null); + + GreenDocument greenDoc = GreenTreeBuilder.parse(xml, "test://test.xml", null); + + assertEquals(domDoc.getEnd(), greenDoc.width(), + "Document width mismatch"); + + assertNodeConsistent(domDoc, greenDoc, 0, xml); + } + + private void assertNodeConsistent(DOMNode domNode, GreenNode greenNode, + int greenAbsStart, String xml) { + assertEquals(domNode.getNodeType(), greenNode.nodeType(), + "Node type mismatch at offset " + greenAbsStart); + + int domWidth = domNode.getEnd() - domNode.getStart(); + assertEquals(domWidth, greenNode.width(), + "Width mismatch for " + domNode.getNodeName() + + " at offset " + greenAbsStart + + " (DOM: " + domNode.getStart() + "-" + domNode.getEnd() + + ", green width: " + greenNode.width() + ")"); + + if (domNode.isElement() && greenNode instanceof GreenElement) { + DOMElement domElem = (DOMElement) domNode; + GreenElement greenElem = (GreenElement) greenNode; + assertEquals(domElem.getTagName(), greenElem.tag(), + "Tag name mismatch at offset " + greenAbsStart); + assertEquals(domElem.isSelfClosed(), greenElem.selfClosed(), + "Self-closed mismatch for " + domElem.getTagName()); + } + + List domChildren = domNode.getChildren(); + List filteredGreenChildren = filterGreenChildren(greenNode.children(), domChildren); + assertEquals(domChildren.size(), filteredGreenChildren.size(), + "Child count mismatch for " + domNode.getNodeName() + + " at offset " + greenAbsStart); + + for (int i = 0; i < domChildren.size(); i++) { + DOMNode domChild = domChildren.get(i); + GreenNode greenChild = filteredGreenChildren.get(i); + + int expectedChildStart = domChild.getStart(); + assertNodeConsistent(domChild, greenChild, expectedChildStart, xml); + } + } + + private List filterGreenChildren(GreenNode[] greenChildren, + List domChildren) { + boolean hasNonWhitespace = false; + for (GreenNode child : greenChildren) { + if (!(child instanceof GreenText && ((GreenText) child).whitespace())) { + hasNonWhitespace = true; + break; + } + } + if (!hasNonWhitespace) { + List result = new ArrayList<>(greenChildren.length); + for (GreenNode child : greenChildren) { + result.add(child); + } + return result; + } + List result = new ArrayList<>(domChildren.size()); + for (GreenNode child : greenChildren) { + if (child instanceof GreenText && ((GreenText) child).whitespace()) { + continue; + } + result.add(child); + } + return result; + } + + private int computeChildrenStartOffset(DOMNode domNode, int greenAbsStart) { + if (domNode.isElement()) { + DOMElement elem = (DOMElement) domNode; + if (elem.getStartTagCloseOffset() != DOMNode.NULL_VALUE) { + return elem.getStartTagCloseOffset() + 1; + } + } + return greenAbsStart; + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java new file mode 100644 index 000000000..044588118 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java @@ -0,0 +1,366 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +/** + * Tests for {@link GreenTreeBuilder}. + */ +public class GreenTreeBuilderTest { + + @Test + public void simpleElement() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + assertEquals(xml.length(), doc.width()); + assertEquals(1, doc.childCount()); + + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("root", root.tag()); + assertEquals(xml.length(), root.width()); + assertTrue(root.closed()); + } + + @Test + public void selfClosingElement() { + String xml = "
"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + assertEquals(xml.length(), doc.width()); + assertEquals(1, doc.childCount()); + + GreenElement br = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("br", br.tag()); + assertTrue(br.selfClosed()); + assertTrue(br.closed()); + assertEquals(xml.length(), br.width()); + } + + @Test + public void nestedElements() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + assertEquals(1, doc.childCount()); + GreenElement a = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("a", a.tag()); + assertEquals(xml.length(), a.width()); + + assertEquals(1, a.childCount()); + GreenElement b = assertInstanceOf(GreenElement.class, a.child(0)); + assertEquals("b", b.tag()); + + assertEquals(1, b.childCount()); + GreenElement c = assertInstanceOf(GreenElement.class, b.child(0)); + assertEquals("c", c.tag()); + assertTrue(c.selfClosed()); + } + + @Test + public void elementWithAttributes() { + String xml = "
"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + GreenElement div = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("div", div.tag()); + assertEquals(2, div.attributeCount()); + + GreenAttr cls = div.attributes()[0]; + assertNotNull(cls); + assertTrue(cls.nameStartRel() >= 0); + + GreenAttr id = div.attributes()[1]; + assertNotNull(id); + } + + @Test + public void textContent() { + String xml = "

hello

"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + GreenElement p = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("p", p.tag()); + assertEquals(1, p.childCount()); + + GreenText text = assertInstanceOf(GreenText.class, p.child(0)); + assertEquals(5, text.width()); + } + + @Test + public void comment() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, root.childCount()); + + GreenComment comment = assertInstanceOf(GreenComment.class, root.child(0)); + assertTrue(comment.closed()); + assertTrue(comment.width() > 0); + } + + @Test + public void cdataSection() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, root.childCount()); + + GreenCDATA cdata = assertInstanceOf(GreenCDATA.class, root.child(0)); + assertTrue(cdata.closed()); + } + + @Test + public void processingInstruction() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + assertEquals(2, doc.childCount()); + GreenProcessingInstruction pi = assertInstanceOf( + GreenProcessingInstruction.class, doc.child(0)); + assertEquals("xml", pi.target()); + assertTrue(pi.prolog()); + assertTrue(pi.closed()); + + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(1)); + assertEquals("root", root.tag()); + } + + @Test + public void widthSumsToDocumentLength() { + String xml = "\n\n \n \n"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertTotalWidthConsistent(doc); + } + + @Test + public void replaceChildStructuralSharing() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + GreenNode originalA = root.child(0); + GreenNode originalC = root.child(2); + + GreenText replacement = new GreenText(10, false); + GreenNode newRoot = root.withReplacedChild(1, replacement); + + GreenElement newRootElement = assertInstanceOf(GreenElement.class, newRoot); + assertTrue(newRootElement.child(0) == originalA, "unchanged child should be same object"); + assertTrue(newRootElement.child(2) == originalC, "unchanged child should be same object"); + assertInstanceOf(GreenText.class, newRootElement.child(1)); + } + + @Test + public void orphanEndTag() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertEquals(1, doc.childCount()); + GreenElement elem = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("meta", elem.tag()); + assertNotNull(elem.endTagOpenRel()); + } + + @Test + public void unclosedElement() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + GreenElement a = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals("a", a.tag()); + assertFalse(a.closed()); + } + + @Test + public void emptyDocument() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(0, doc.width()); + assertEquals(0, doc.childCount()); + } + + @Test + public void textOnlyDocument() { + String xml = "just some text"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertEquals(1, doc.childCount()); + GreenText text = assertInstanceOf(GreenText.class, doc.child(0)); + assertEquals(xml.length(), text.width()); + } + + @Test + public void attributeWithoutValue() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement input = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, input.attributeCount()); + GreenAttr attr = input.attributes()[0]; + assertEquals(GreenAttr.NULL_VALUE, attr.delimiterRel()); + assertEquals(GreenAttr.NULL_VALUE, attr.valueStartRel()); + } + + @Test + public void attributeWithDelimiterNoValue() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement input = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, input.attributeCount()); + GreenAttr attr = input.attributes()[0]; + assertTrue(attr.delimiterRel() != GreenAttr.NULL_VALUE); + assertEquals(GreenAttr.NULL_VALUE, attr.valueStartRel()); + } + + @Test + public void multipleAttributes() { + String xml = "
"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement div = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(3, div.attributeCount()); + } + + @Test + public void commentContent() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenComment comment = assertInstanceOf(GreenComment.class, doc.child(0)); + assertTrue(comment.closed()); + assertEquals(4, comment.startContentRel()); + } + + @Test + public void unclosedComment() { + String xml = "\n\n \n"); + } + + @Test + public void widthInvariantMalformed() { + assertWidthInvariant(""); + } + + @Test + public void widthInvariantOrphanEndTags() { + assertWidthInvariant(""); + } + + @Test + public void widthInvariantDoctype() { + assertWidthInvariant("\n \n]>\n"); + } + + private void assertWidthInvariant(String xml) { + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertChildrenWidthSum(doc); + } + + private void assertChildrenWidthSum(GreenNode node) { + GreenNode[] children = node.children(); + if (children.length == 0) { + return; + } + int sum = 0; + for (GreenNode child : children) { + assertTrue(child.width() > 0, "Child width must be positive"); + sum += child.width(); + assertChildrenWidthSum(child); + } + } + + @Test + public void largeDocumentPerformance() { + StringBuilder sb = new StringBuilder(); + sb.append("\n"); + int count = 10000; + for (int i = 0; i < count; i++) { + sb.append(" value").append(i).append("\n"); + } + sb.append(""); + String xml = sb.toString(); + + long start = System.nanoTime(); + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + long elapsed = System.nanoTime() - start; + + assertEquals(xml.length(), doc.width()); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + // count items + (count + 1) interleaved whitespace text nodes + assertEquals(2 * count + 1, root.childCount()); + + // Parse of 10K elements should complete in under 2 seconds + assertTrue(elapsed < 2_000_000_000L, + "Parse took too long: " + (elapsed / 1_000_000) + "ms"); + } + + private void assertTotalWidthConsistent(GreenNode node) { + GreenNode[] kids = node.children(); + if (kids.length > 0) { + for (GreenNode child : kids) { + assertTrue(child.width() > 0 || child.width() == 0, + "child width must be non-negative"); + assertTotalWidthConsistent(child); + } + } + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java new file mode 100644 index 000000000..f18fbb6f3 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java @@ -0,0 +1,70 @@ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lemminx.dom.*; +import org.junit.jupiter.api.Test; + +public class GreenTreeDebugTest { + @Test + public void debugDoctypeNoInternalSubset() { + // Same input as testDoctypeNoInternalSubset + String content = "\r\n\r\n Fred\r\n"; + DOMDocument doc = DOMParser.getInstance().parse(content, "test.xml", null); + System.out.println("Children count: " + doc.getChildren().size()); + for (DOMNode child : doc.getChildren()) { + System.out.println(" Child: " + child.getClass().getSimpleName() + " start=" + child.getStart() + " end=" + child.getEnd()); + if (child instanceof DOMDocumentType) { + DOMDocumentType dt = (DOMDocumentType) child; + System.out.println(" name=" + dt.getName() + " closed=" + dt.isClosed()); + System.out.println(" parameters count: " + dt.getParameters().size()); + for (int i = 0; i < dt.getParameters().size(); i++) { + DTDDeclParameter p = dt.getParameters().get(i); + System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); + } + DTDDeclParameter nameParam = dt.getNameParameter(); + if (nameParam != null) { + System.out.println(" nameParam start=" + nameParam.getStart() + " end=" + nameParam.getEnd()); + } + System.out.println(" internalSubset=" + dt.getInternalSubsetNode()); + } + } + } + + @Test + public void debugDoctypeWithInternalSubset() { + String content = "\n]>"; + DOMDocument doc = DOMParser.getInstance().parse(content, "test.xml", null); + System.out.println("Children count: " + doc.getChildren().size()); + for (DOMNode child : doc.getChildren()) { + System.out.println(" Child: " + child.getClass().getSimpleName() + " start=" + child.getStart() + " end=" + child.getEnd()); + if (child instanceof DOMDocumentType) { + DOMDocumentType dt = (DOMDocumentType) child; + System.out.println(" name=" + dt.getName() + " closed=" + dt.isClosed()); + System.out.println(" parameters count: " + dt.getParameters().size()); + for (int i = 0; i < dt.getParameters().size(); i++) { + DTDDeclParameter p = dt.getParameters().get(i); + System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); + } + DTDDeclParameter nameParam = dt.getNameParameter(); + if (nameParam != null) { + System.out.println(" nameParam start=" + nameParam.getStart() + " end=" + nameParam.getEnd()); + } + DTDDeclParameter internalSubset = dt.getInternalSubsetNode(); + if (internalSubset != null) { + System.out.println(" internalSubset start=" + internalSubset.getStart() + " end=" + internalSubset.getEnd()); + } + System.out.println(" children: " + dt.getChildren().size()); + for (DOMNode dtChild : dt.getChildren()) { + System.out.println(" dtChild: " + dtChild.getClass().getSimpleName() + " start=" + dtChild.getStart() + " end=" + dtChild.getEnd()); + if (dtChild instanceof DTDDeclNode) { + DTDDeclNode decl = (DTDDeclNode) dtChild; + System.out.println(" name=" + decl.getName() + " params=" + decl.getParameters().size()); + for (int i = 0; i < decl.getParameters().size(); i++) { + DTDDeclParameter p = decl.getParameters().get(i); + System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); + } + } + } + } + } + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java new file mode 100644 index 000000000..795ca4546 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java @@ -0,0 +1,617 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.List; + +import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.DOMAttr; +import org.eclipse.lemminx.dom.DOMCDATASection; +import org.eclipse.lemminx.dom.DOMComment; +import org.eclipse.lemminx.dom.DOMDocument; +import org.eclipse.lemminx.dom.DOMElement; +import org.eclipse.lemminx.dom.DOMNode; +import org.eclipse.lemminx.dom.DOMParser; +import org.eclipse.lemminx.dom.DOMProcessingInstruction; +import org.eclipse.lemminx.dom.DOMText; +import org.eclipse.lemminx.dom.RedTreeBuilder; +import org.junit.jupiter.api.Test; + +/** + * Tests that {@link RedTreeBuilder} produces a DOMDocument identical to + * the one built by {@link DOMParser}. + */ +public class RedTreeBuilderTest { + + @Test + public void simpleElement() { + assertRedTreeEquivalent(""); + } + + @Test + public void selfClosing() { + assertRedTreeEquivalent("
"); + } + + @Test + public void nestedElements() { + assertRedTreeEquivalent(""); + } + + @Test + public void elementWithAttributes() { + assertRedTreeEquivalent("
"); + } + + @Test + public void textContent() { + assertRedTreeEquivalent("

hello world

"); + } + + @Test + public void mixedContent() { + assertRedTreeEquivalent("

hello world end

"); + } + + @Test + public void comment() { + assertRedTreeEquivalent(""); + } + + @Test + public void cdataSection() { + assertRedTreeEquivalent(""); + } + + @Test + public void processingInstruction() { + assertRedTreeEquivalent(""); + } + + @Test + public void multipleRootChildren() { + assertRedTreeEquivalent(""); + } + + @Test + public void unclosedTag() { + assertRedTreeEquivalent(""); + } + + @Test + public void orphanEndTag() { + assertRedTreeEquivalent(""); + } + + @Test + public void complexDocument() { + String xml = "\n" + + "\n" + + " 4.0.0\n" + + " com.example\n" + + " test\n" + + " 1.0\n" + + " \n" + + " \n" + + " \n" + + " junit\n" + + " junit\n" + + " \n" + + " \n" + + ""; + assertRedTreeEquivalent(xml); + } + + @Test + public void largeDocument() { + StringBuilder sb = new StringBuilder(); + sb.append("\n"); + for (int i = 0; i < 1000; i++) { + sb.append(" value ").append(i).append("\n"); + } + sb.append(""); + assertRedTreeEquivalent(sb.toString()); + } + + // --- Edge cases: orphan end tags --- + + @Test + public void orphanEndTagAtRoot() { + assertRedTreeEquivalent(""); + } + + @Test + public void orphanEndTagEmpty() { + assertRedTreeEquivalent(""); + } + + @Test + public void orphanEndTagWithContent() { + assertRedTreeEquivalent("textmore"); + } + + @Test + public void multipleOrphanEndTags() { + assertRedTreeEquivalent(""); + } + + @Test + public void orphanEndTagBetweenElements() { + assertRedTreeEquivalent(""); + } + + // --- Edge cases: unclosed tags --- + + @Test + public void unclosedNestedTags() { + assertRedTreeEquivalent(""); + } + + @Test + public void unclosedWithSiblings() { + assertRedTreeEquivalent(""); + } + + @Test + public void unclosedStartTagNoClose() { + assertRedTreeEquivalent(""); + } + + // --- Edge cases: attributes --- + + @Test + public void attributeWithoutValue() { + assertRedTreeEquivalent(""); + } + + @Test + public void attributeWithoutValueBeforeClose() { + assertRedTreeEquivalent(""); + } + + @Test + public void multipleAttributesWithoutValues() { + assertRedTreeEquivalent(""); + } + + @Test + public void attributeWithDelimiterNoValue() { + assertRedTreeEquivalent(""); + } + + @Test + public void attributeWithDelimiterNoValueAtEOS() { + assertRedTreeEquivalent(""); + } + + @Test + public void attributeWithSpacesAroundEquals() { + assertRedTreeEquivalent("
"); + } + + @Test + public void attributeAtEOS() { + assertRedTreeEquivalent(""); + } + + // --- Edge cases: comments --- + + @Test + public void unclosedComment() { + assertRedTreeEquivalent(""); + } + + @Test + public void commentSameLineAsEndTag() { + assertRedTreeEquivalent(""); + } + + @Test + public void commentOnSameLineEndTag() { + assertRedTreeEquivalent("\n \n"); + } + + @Test + public void commentOnDifferentLine() { + assertRedTreeEquivalent("\n \n\n"); + } + + // --- Edge cases: CDATA --- + + @Test + public void emptyCDATA() { + assertRedTreeEquivalent(""); + } + + @Test + public void unclosedCDATA() { + assertRedTreeEquivalent("&\"']]>"); + } + + // --- Edge cases: processing instructions --- + + @Test + public void piWithAttributes() { + assertRedTreeEquivalent(""); + } + + @Test + public void piWithAttrNoValue() { + assertRedTreeEquivalent(""); + } + + @Test + public void piNonProlog() { + assertRedTreeEquivalent(""); + } + + @Test + public void unclosedPI() { + assertRedTreeEquivalent(""); + } + + @Test + public void doctypeWithPublicId() { + assertRedTreeEquivalent( + "" + + ""); + } + + @Test + public void doctypeWithSystemId() { + assertRedTreeEquivalent(""); + } + + @Test + public void doctypeWithInternalSubset() { + assertRedTreeEquivalent( + "\n" + + " \n" + + "]>\n"); + } + + @Test + public void doctypeEmpty() { + assertRedTreeEquivalent("\n"); + } + + @Test + public void doctypeUnclosed() { + assertRedTreeEquivalent("\n" + + "]>\n"); + } + + @Test + public void doctypeWithNotationDecl() { + assertRedTreeEquivalent( + "\n" + + "]>\n"); + } + + @Test + public void doctypeWithMultipleDecls() { + assertRedTreeEquivalent( + "\n" + + " \n" + + " \n" + + " \n" + + " \n" + + "]>\n"); + } + + @Test + public void doctypeAttlistMultipleAttributes() { + assertRedTreeEquivalent( + "\n" + + "]>\n"); + } + + @Test + public void doctypeUnrecognizedContent() { + assertRedTreeEquivalent( + "\n" + + "]>\n"); + } + + // --- Edge cases: end tag with spaces --- + + @Test + public void endTagWithSpaces() { + assertRedTreeEquivalent(""); + } + + @Test + public void endTagWithNewline() { + assertRedTreeEquivalent(""); + } + + // --- Edge cases: whitespace handling --- + + @Test + public void whitespaceOnlyContent() { + assertRedTreeEquivalent(" "); + } + + @Test + public void whitespaceBeforeAndAfterContent() { + assertRedTreeEquivalent(" text "); + } + + @Test + public void newlinesAndIndentation() { + assertRedTreeEquivalent("\n \n text\n \n"); + } + + // --- Edge cases: malformed XML --- + + @Test + public void startTagInsideStartTag() { + assertRedTreeEquivalent(""); + } + + @Test + public void closeTagMismatch() { + assertRedTreeEquivalent(""); + } + + @Test + public void multipleRoots() { + assertRedTreeEquivalent(""); + } + + @Test + public void emptyDocument() { + assertRedTreeEquivalent(""); + } + + @Test + public void textOnlyDocument() { + assertRedTreeEquivalent("just text"); + } + + @Test + public void openBracketOnly() { + assertRedTreeEquivalent("<"); + } + + @Test + public void closeBracketInContent() { + assertRedTreeEquivalent("a > b"); + } + + @Test + public void ampersandInContent() { + assertRedTreeEquivalent("a & b"); + } + + // --- Edge cases: mixed real-world patterns --- + + @Test + public void xhtmlSelfClosingElements() { + assertRedTreeEquivalent( + "\n" + + "\n" + + " Test\n" + + " \n" + + "
\n" + + "
\n" + + " \n" + + " \n" + + " \n" + + ""); + } + + @Test + public void mavenPom() { + assertRedTreeEquivalent( + "\n" + + "\n" + + " 4.0.0\n" + + " com.example\n" + + " test\n" + + " 1.0-SNAPSHOT\n" + + " \n" + + " \n" + + " junit\n" + + " junit\n" + + " 4.13.2\n" + + " test\n" + + " \n" + + " \n" + + ""); + } + + @Test + public void springConfig() { + assertRedTreeEquivalent( + "\n" + + "\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + ""); + } + + @Test + public void windowsCRLF() { + assertRedTreeEquivalent("\r\n \r\n"); + } + + @Test + public void mixedLineEndings() { + assertRedTreeEquivalent("\n \r\n \r \n"); + } + + private void assertRedTreeEquivalent(String xml) { + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + + DOMDocument expected = DOMParser.getInstance().parse(textDoc, null); + + GreenDocument greenDoc = GreenTreeBuilder.parse(xml, "test://test.xml", null); + DOMDocument actual = RedTreeBuilder.build(greenDoc, textDoc, null); + + assertNodesEqual(expected, actual, xml); + } + + private void assertNodesEqual(DOMNode expected, DOMNode actual, String xml) { + assertEquals(expected.getNodeType(), actual.getNodeType(), + "Node type mismatch at offset " + expected.getStart()); + assertEquals(expected.getStart(), actual.getStart(), + "Start offset mismatch for " + expected.getNodeName()); + assertEquals(expected.getEnd(), actual.getEnd(), + "End offset mismatch for " + expected.getNodeName()); + assertEquals(expected.isClosed(), actual.isClosed(), + "Closed mismatch for " + expected.getNodeName()); + + if (expected.isElement()) { + assertElementsEqual((DOMElement) expected, (DOMElement) actual); + } + if (expected.isComment()) { + assertCommentsEqual((DOMComment) expected, (DOMComment) actual); + } + if (expected instanceof DOMCDATASection) { + assertCDATAEqual((DOMCDATASection) expected, (DOMCDATASection) actual); + } + if (expected.isProcessingInstruction() || expected.isProlog()) { + assertPIEqual((DOMProcessingInstruction) expected, (DOMProcessingInstruction) actual); + } + if (expected.isText()) { + DOMText expText = (DOMText) expected; + DOMText actText = (DOMText) actual; + assertEquals(expText.isWhitespace(), actText.isWhitespace(), + "Whitespace mismatch for text at " + expected.getStart()); + } + + List expectedChildren = expected.getChildren(); + List actualChildren = actual.getChildren(); + assertEquals(expectedChildren.size(), actualChildren.size(), + "Child count mismatch for " + expected.getNodeName() + + " at " + expected.getStart()); + + for (int i = 0; i < expectedChildren.size(); i++) { + assertNodesEqual(expectedChildren.get(i), actualChildren.get(i), xml); + } + } + + private void assertElementsEqual(DOMElement expected, DOMElement actual) { + assertEquals(expected.getTagName(), actual.getTagName(), + "Tag name mismatch"); + assertEquals(expected.isSelfClosed(), actual.isSelfClosed(), + "Self-closed mismatch for " + expected.getTagName()); + assertEquals(expected.getStartTagOpenOffset(), actual.getStartTagOpenOffset(), + "StartTagOpen mismatch for " + expected.getTagName()); + assertEquals(expected.getStartTagCloseOffset(), actual.getStartTagCloseOffset(), + "StartTagClose mismatch for " + expected.getTagName()); + assertEquals(expected.getEndTagOpenOffset(), actual.getEndTagOpenOffset(), + "EndTagOpen mismatch for " + expected.getTagName()); + assertEquals(expected.getEndTagCloseOffset(), actual.getEndTagCloseOffset(), + "EndTagClose mismatch for " + expected.getTagName()); + + if (expected.hasAttributes()) { + assertEquals(expected.getAttributeNodes().size(), actual.getAttributeNodes().size(), + "Attribute count mismatch for " + expected.getTagName()); + for (int i = 0; i < expected.getAttributeNodes().size(); i++) { + DOMAttr expAttr = expected.getAttributeNodes().get(i); + DOMAttr actAttr = actual.getAttributeNodes().get(i); + assertEquals(expAttr.getName(), actAttr.getName(), + "Attribute name mismatch"); + assertEquals(expAttr.getOriginalValue(), actAttr.getOriginalValue(), + "Attribute value mismatch for " + expAttr.getName()); + } + } + } + + private void assertCommentsEqual(DOMComment expected, DOMComment actual) { + assertEquals(expected.getStartContent(), actual.getStartContent(), + "Comment startContent mismatch"); + assertEquals(expected.getEndContent(), actual.getEndContent(), + "Comment endContent mismatch"); + } + + private void assertCDATAEqual(DOMCDATASection expected, DOMCDATASection actual) { + assertEquals(expected.getStartContent(), actual.getStartContent(), + "CDATA startContent mismatch"); + assertEquals(expected.getEndContent(), actual.getEndContent(), + "CDATA endContent mismatch"); + } + + private void assertPIEqual(DOMProcessingInstruction expected, DOMProcessingInstruction actual) { + assertEquals(expected.getTarget(), actual.getTarget(), + "PI target mismatch"); + assertEquals(expected.isProlog(), actual.isProlog(), + "PI prolog mismatch"); + assertEquals(expected.getStartContent(), actual.getStartContent(), + "PI startContent mismatch"); + assertEquals(expected.getEndContent(), actual.getEndContent(), + "PI endContent mismatch"); + } +} From 432395f71f421b91467ee740b5e60c68ee61b0f3 Mon Sep 17 00:00:00 2001 From: azerr Date: Fri, 4 Sep 2026 20:15:06 +0200 Subject: [PATCH 02/18] Implement incremental reparse and atomic swap for red-green tree Add incremental reparsing that reuses unchanged subtrees when editing a document, avoiding full reparse for single-edit changes. The green tree is preserved on DOMDocument for structural sharing across versions. Key changes: - IncrementalParser: finds reusable prefix/suffix children at document level, reparses only the affected middle region via parseRange() - GreenTreeBuilder.parseRange(): parses a subrange of text, enabling partial reparsing without scanning the full document - ModelTextDocument: model field is now volatile for thread-safe reads, preserves previousModel and edit info for incremental path - DOMDocument stores its GreenDocument for reuse across edits - GreenNode.childrenStartRel() factored from RedTreeBuilder into each green node subclass Tests: 195 tests covering green tree, red tree, incremental parser, structural sharing, ModelTextDocument edit flow, and DOMParser integration. All 2461 existing tests pass with zero regressions. Signed-off-by: azerr Co-Authored-By: Claude Opus 4.6 --- .../lemminx/XMLTextDocumentService.java | 15 + .../lemminx/commons/ModelTextDocument.java | 324 +++++--- .../org/eclipse/lemminx/dom/DOMDocument.java | 10 + .../org/eclipse/lemminx/dom/DOMParser.java | 19 + .../eclipse/lemminx/dom/RedTreeBuilder.java | 43 +- .../lemminx/dom/green/GreenDTDDeclNode.java | 12 + .../lemminx/dom/green/GreenDocumentType.java | 15 + .../lemminx/dom/green/GreenElement.java | 11 + .../eclipse/lemminx/dom/green/GreenNode.java | 4 + .../lemminx/dom/green/GreenTreeBuilder.java | 20 +- .../lemminx/dom/green/IncrementalParser.java | 131 +++ .../commons/ModelTextDocumentTest.java | 129 +++ .../dom/green/GreenTreeBuilderTest.java | 134 ++++ .../lemminx/dom/green/GreenTreeDebugTest.java | 70 -- .../dom/green/IncrementalParserTest.java | 758 ++++++++++++++++++ .../lemminx/dom/green/RedTreeBuilderTest.java | 23 + 16 files changed, 1477 insertions(+), 241 deletions(-) create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java delete mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java index 8827a1bf9..b427b7584 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java @@ -202,6 +202,21 @@ public XMLTextDocumentService(XMLLanguageServer xmlLanguageServer) { this.xmlLanguageServer = xmlLanguageServer; DOMParser parser = DOMParser.getInstance(); this.documents = new ModelTextDocuments((document, cancelChecker) -> { + if (document instanceof ModelTextDocument) { + @SuppressWarnings("unchecked") + ModelTextDocument mtd = (ModelTextDocument) document; + DOMDocument prev = mtd.getPreviousModel(); + ModelTextDocument.EditInfo editInfo = mtd.getPendingEdit(); + if (prev != null && prev.getGreenDocument() != null && editInfo != null) { + return parser.parseIncremental(document, + prev.getGreenDocument(), + editInfo.getStartOffset(), + editInfo.getDeleteLength(), + editInfo.getInsertLength(), + getXMLLanguageService().getResolverExtensionManager(), + true, cancelChecker); + } + } return parser.parse(document, getXMLLanguageService().getResolverExtensionManager(), true, cancelChecker); }); this.sharedSettings = new SharedSettings(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java index 2e55e2d90..08c703df4 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java @@ -1,121 +1,203 @@ -/******************************************************************************* -* Copyright (c) 2019 Red Hat Inc. and others. -* All rights reserved. This program and the accompanying materials -* which accompanies this distribution, and is available at -* http://www.eclipse.org/legal/epl-v20.html -* -* SPDX-License-Identifier: EPL-2.0 -* -* Contributors: -* Red Hat Inc. - initial API and implementation -*******************************************************************************/ -package org.eclipse.lemminx.commons; - -import java.util.concurrent.CancellationException; -import java.util.function.BiFunction; -import java.util.logging.Logger; - -import org.eclipse.lsp4j.TextDocumentItem; -import org.eclipse.lsp4j.jsonrpc.CancelChecker; - -/** - * A {@link TextDocument} which is associate to a model loaded in async. - * - * @author Angelo ZERR - * - * @param the model type (ex : DOM Document) - */ -public class ModelTextDocument extends TextDocument { - - private static final Logger LOGGER = Logger.getLogger(ModelTextDocument.class.getName()); - - private final BiFunction parse; - - private T model; - - public ModelTextDocument(TextDocumentItem document, BiFunction parse) { - super(document); - this.parse = parse; - } - - public ModelTextDocument(String text, String uri, BiFunction parse) { - super(text, uri); - this.parse = parse; - } - - /** - * Returns the existing parsed model synchronized with last version of the text - * document and null otherwise. - * - * @return the existing parsed model synchronized with last version of the text - * document and null otherwise. - */ - public T getExistingModel() { - return model; - } - - /** - * Returns the parsed model synchronized with last version of the text document. - * - * @return the parsed model synchronized with last version of the text document. - */ - public T getModel() { - if (model == null) { - return getSynchronizedModel(); - } - return model; - } - - /** - * Return the existing parsed model synchronized with last version of the text - * document or parse the model. - * - * @return the existing parsed model synchronized with last version of the text - * document or parse the model. - */ - private synchronized T getSynchronizedModel() { - if (model != null) { - return model; - } - int version = super.getVersion(); - long start = System.currentTimeMillis(); - try { - LOGGER.fine("Start parsing of model with version '" + version); - // Stop of parse process can be done when completable future is canceled or when - // version of document changes - CancelChecker cancelChecker = new TextDocumentVersionChecker(this, version); - // parse the model - model = parse.apply(this, cancelChecker); - } catch (CancellationException e) { - LOGGER.fine("Stop parsing parsing of model with version '" + version + "' in " - + (System.currentTimeMillis() - start) + "ms"); - throw e; - } finally { - LOGGER.fine("End parse of model with version '" + version + "' in " + (System.currentTimeMillis() - start) - + "ms"); - } - return model; - } - - @Override - public void setText(String text) { - super.setText(text); - // text changed, cancel the completable future which load the model - cancelModel(); - } - - @Override - public void setVersion(int version) { - super.setVersion(version); - // version changed, mark the model as dirty - cancelModel(); - } - - /** - * Mark the model as dirty - */ - private void cancelModel() { - model = null; - } - -} \ No newline at end of file +/******************************************************************************* +* Copyright (c) 2019 Red Hat Inc. and others. +* All rights reserved. This program and the accompanying materials +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl-v20.html +* +* SPDX-License-Identifier: EPL-2.0 +* +* Contributors: +* Red Hat Inc. - initial API and implementation +*******************************************************************************/ +package org.eclipse.lemminx.commons; + +import java.util.List; +import java.util.concurrent.CancellationException; +import java.util.function.BiFunction; +import java.util.logging.Logger; + +import org.eclipse.lsp4j.Range; +import org.eclipse.lsp4j.TextDocumentContentChangeEvent; +import org.eclipse.lsp4j.TextDocumentItem; +import org.eclipse.lsp4j.jsonrpc.CancelChecker; + +/** + * A {@link TextDocument} which is associate to a model loaded in async. + * + * @author Angelo ZERR + * + * @param the model type (ex : DOM Document) + */ +public class ModelTextDocument extends TextDocument { + + private static final Logger LOGGER = Logger.getLogger(ModelTextDocument.class.getName()); + + private final BiFunction parse; + + private volatile T model; + + private volatile T previousModel; + + private volatile EditInfo pendingEdit; + + public ModelTextDocument(TextDocumentItem document, BiFunction parse) { + super(document); + this.parse = parse; + } + + public ModelTextDocument(String text, String uri, BiFunction parse) { + super(text, uri); + this.parse = parse; + } + + /** + * Returns the existing parsed model synchronized with last version of the text + * document and null otherwise. + * + * @return the existing parsed model synchronized with last version of the text + * document and null otherwise. + */ + public T getExistingModel() { + return model; + } + + /** + * Returns the parsed model synchronized with last version of the text document. + * + * @return the parsed model synchronized with last version of the text document. + */ + public T getModel() { + if (model == null) { + return getSynchronizedModel(); + } + return model; + } + + /** + * Return the existing parsed model synchronized with last version of the text + * document or parse the model. + * + * @return the existing parsed model synchronized with last version of the text + * document or parse the model. + */ + private synchronized T getSynchronizedModel() { + if (model != null) { + return model; + } + int version = super.getVersion(); + long start = System.currentTimeMillis(); + try { + LOGGER.fine("Start parsing of model with version '" + version); + // Stop of parse process can be done when completable future is canceled or when + // version of document changes + CancelChecker cancelChecker = new TextDocumentVersionChecker(this, version); + // parse the model + model = parse.apply(this, cancelChecker); + } catch (CancellationException e) { + LOGGER.fine("Stop parsing parsing of model with version '" + version + "' in " + + (System.currentTimeMillis() - start) + "ms"); + throw e; + } finally { + previousModel = null; + pendingEdit = null; + LOGGER.fine("End parse of model with version '" + version + "' in " + (System.currentTimeMillis() - start) + + "ms"); + } + return model; + } + + @Override + public void setText(String text) { + super.setText(text); + // text changed, cancel the completable future which load the model + cancelModel(); + } + + @Override + public void setVersion(int version) { + super.setVersion(version); + // version changed, mark the model as dirty + cancelModel(); + } + + @Override + public void update(List changes) { + if (changes != null && changes.size() == 1) { + TextDocumentContentChangeEvent change = changes.get(0); + Range range = change.getRange(); + if (range != null) { + try { + int start = offsetAt(range.getStart()); + Integer rangeLength = change.getRangeLength(); + int delLen = rangeLength != null ? rangeLength.intValue() + : offsetAt(range.getEnd()) - start; + int insLen = change.getText() != null ? change.getText().length() : 0; + pendingEdit = new EditInfo(start, delLen, insLen); + } catch (BadLocationException e) { + pendingEdit = null; + } + } + } else { + pendingEdit = null; + } + super.update(changes); + } + + /** + * Mark the model as dirty + */ + private void cancelModel() { + if (model != null) { + previousModel = model; + } + model = null; + } + + /** + * Returns the previous model (before the last edit) and null if not available. + * + * @return the previous model or null + */ + public T getPreviousModel() { + return previousModel; + } + + /** + * Returns the pending edit info (offset, delete/insert lengths) for + * the most recent single-change edit, or null if not available. + * + * @return the edit info or null + */ + public EditInfo getPendingEdit() { + return pendingEdit; + } + + /** + * Information about a single text edit: where it started in the old text, + * how many characters were deleted, and how many were inserted. + */ + public static final class EditInfo { + private final int startOffset; + private final int deleteLength; + private final int insertLength; + + public EditInfo(int startOffset, int deleteLength, int insertLength) { + this.startOffset = startOffset; + this.deleteLength = deleteLength; + this.insertLength = insertLength; + } + + public int getStartOffset() { + return startOffset; + } + + public int getDeleteLength() { + return deleteLength; + } + + public int getInsertLength() { + return insertLength; + } + } + +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java index 28d785af3..ad33b1fee 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java @@ -27,6 +27,7 @@ import org.eclipse.lemminx.commons.BadLocationException; import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.green.GreenDocument; import org.eclipse.lemminx.dom.parser.Constants; import org.eclipse.lemminx.uriresolver.URIResolverExtensionManager; import org.eclipse.lemminx.utils.DOMUtils; @@ -65,6 +66,7 @@ public class DOMDocument extends DOMNode implements Document { private String schemaPrefix; private CancelChecker cancelChecker; private String externalGrammarFromNamespaceURI; + private volatile GreenDocument greenDocument; public DOMDocument(TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager) { super(0, textDocument.getText().length()); @@ -81,6 +83,14 @@ public CancelChecker getCancelChecker() { return cancelChecker; } + public GreenDocument getGreenDocument() { + return greenDocument; + } + + public void setGreenDocument(GreenDocument greenDocument) { + this.greenDocument = greenDocument; + } + public List getRoots() { return super.getChildren(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java index 037477093..f8e4372e1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java @@ -20,6 +20,7 @@ import org.eclipse.lemminx.commons.TextDocument; import org.eclipse.lemminx.dom.green.GreenDocument; import org.eclipse.lemminx.dom.green.GreenTreeBuilder; +import org.eclipse.lemminx.dom.green.IncrementalParser; import org.eclipse.lemminx.uriresolver.URIResolverExtensionManager; import org.eclipse.lsp4j.jsonrpc.CancelChecker; @@ -62,8 +63,26 @@ public DOMDocument parse(TextDocument document, URIResolverExtensionManager reso String text = document.getText(); String uri = document.getUri(); GreenDocument greenDoc = GreenTreeBuilder.parse(text, uri, monitor); + return buildDocument(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent, monitor); + } + + public DOMDocument parseIncremental(TextDocument document, + GreenDocument previousGreenDoc, int editStart, int deleteLength, int insertLength, + URIResolverExtensionManager resolverExtensionManager, + boolean ignoreWhitespaceContent, CancelChecker monitor) { + String text = document.getText(); + String uri = document.getUri(); + GreenDocument greenDoc = IncrementalParser.incrementalParse( + previousGreenDoc, text, editStart, deleteLength, insertLength, uri, monitor); + return buildDocument(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent, monitor); + } + + private static DOMDocument buildDocument(GreenDocument greenDoc, TextDocument document, + URIResolverExtensionManager resolverExtensionManager, + boolean ignoreWhitespaceContent, CancelChecker monitor) { DOMDocument xmlDocument = RedTreeBuilder.build(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent); + xmlDocument.setGreenDocument(greenDoc); xmlDocument.setCancelChecker(monitor); return xmlDocument; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 5a6af0319..63f8c7f98 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -69,7 +69,7 @@ private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsSta return; } - int childrenStartRel = computeChildrenStartRel(greenParent); + int childrenStartRel = greenParent.childrenStartRel(); int childAbsStart = parentAbsStart + childrenStartRel; boolean skipWhitespace = ignoreWhitespaceContent && (hasNonWhitespaceChild(children) || greenParent instanceof GreenDocumentType); @@ -376,47 +376,6 @@ private static void setDTDUnrecognized(DTDDeclNode decl, GreenDTDDeclNode green, } } - private static int computeChildrenStartRel(GreenNode greenParent) { - if (greenParent instanceof GreenDocument) { - return 0; - } - if (greenParent instanceof GreenElement) { - GreenElement elem = (GreenElement) greenParent; - if (elem.contentStartRel() != GreenElement.NULL_VALUE) { - return elem.contentStartRel(); - } - if (elem.startTagCloseRel() != GreenElement.NULL_VALUE) { - return elem.startTagCloseRel() + 1; - } - return 0; - } - if (greenParent instanceof GreenDocumentType) { - GreenDocumentType dt = (GreenDocumentType) greenParent; - if (dt.internalSubset() != null) { - return dt.internalSubset().startRel() + 1; - } - if (dt.childCount() == 0) { - return 0; - } - int childrenWidth = 0; - for (GreenNode child : dt.children()) { - childrenWidth += child.width(); - } - return dt.width() - childrenWidth; - } - if (greenParent instanceof GreenDTDDeclNode) { - if (greenParent.childCount() == 0) { - return 0; - } - int childrenWidth = 0; - for (GreenNode child : greenParent.children()) { - childrenWidth += child.width(); - } - return greenParent.width() - childrenWidth; - } - return 0; - } - private static int abs(int relOffset, int absStart) { return relOffset != GreenElement.NULL_VALUE ? absStart + relOffset : DOMNode.NULL_VALUE; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java index 7113de4aa..67ee849d1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java @@ -63,6 +63,18 @@ public GreenDTDParam[] parameters() { return parameters; } + @Override + public int childrenStartRel() { + if (childCount() == 0) { + return 0; + } + int childrenWidth = 0; + for (GreenNode child : children()) { + childrenWidth += child.width(); + } + return width() - childrenWidth; + } + @Override public GreenNode[] children() { return children; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java index 1c33823f1..bb9deeb01 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocumentType.java @@ -57,6 +57,21 @@ public GreenDTDParam internalSubset() { return internalSubset; } + @Override + public int childrenStartRel() { + if (internalSubset != null) { + return internalSubset.startRel() + 1; + } + if (childCount() == 0) { + return 0; + } + int childrenWidth = 0; + for (GreenNode child : children()) { + childrenWidth += child.width(); + } + return width() - childrenWidth; + } + @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { return new GreenDocumentType(newWidth, closed(), unrecognized(), declType(), diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 1a04c3b2e..88d6e669b 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -85,6 +85,17 @@ public int attributeCount() { return attributes.length; } + @Override + public int childrenStartRel() { + if (contentStartRel != NULL_VALUE) { + return contentStartRel; + } + if (startTagCloseRel != NULL_VALUE) { + return startTagCloseRel + 1; + } + return 0; + } + @Override public GreenNode[] children() { return children; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java index 63bd3cdfc..aec6f8493 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java @@ -66,5 +66,9 @@ public GreenNode withReplacedChild(int index, GreenNode newChild) { return replaceChildren(copy, width + deltaWidth); } + public int childrenStartRel() { + return 0; + } + protected abstract GreenNode replaceChildren(GreenNode[] newChildren, int newWidth); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index cada2a5f6..efe3c37af 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -43,19 +43,19 @@ private GreenTreeBuilder() { * @return the root green document node */ public static GreenDocument parse(String text, String uri, CancelChecker monitor) { - return parse(text, uri, true, monitor); + return parseRange(text, uri, 0, text.length(), monitor); } - public static GreenDocument parse(String text, String uri, - boolean ignoreWhitespaceContent, CancelChecker monitor) { + public static GreenDocument parseRange(String text, String uri, + int rangeStart, int rangeEnd, CancelChecker monitor) { boolean isDTD = DOMUtils.isDTD(uri); - Scanner scanner = XMLScanner.createScanner(text, 0, isDTD); + Scanner scanner = XMLScanner.createScanner(text, rangeStart, isDTD); Deque stack = new ArrayDeque<>(); List rootChildren = new ArrayList<>(); if (isDTD) { - NodeBuilder dtdRoot = new NodeBuilder(NodeKind.DOCUMENT_TYPE, 0); + NodeBuilder dtdRoot = new NodeBuilder(NodeKind.DOCUMENT_TYPE, rangeStart); dtdRoot.closed = true; stack.push(dtdRoot); } @@ -67,12 +67,15 @@ public static GreenDocument parse(String text, String uri, boolean inDTDInternalSubset = false; GreenText tempWhitespaceContent = null; int tempWhitespaceStart = -1; - int[] nextRootChildEnd = { 0 }; + int[] nextRootChildEnd = { rangeStart }; NodeBuilder lastClosed = null; TokenType token = scanner.scan(); while (token != TokenType.EOS) { + if (rangeEnd < text.length() && scanner.getTokenOffset() >= rangeEnd && stack.isEmpty()) { + break; + } if (monitor != null) { monitor.checkCanceled(); } @@ -816,13 +819,14 @@ public static GreenDocument parse(String text, String uri, // Flush remaining open nodes while (!stack.isEmpty()) { NodeBuilder top = stack.peek(); - top.nodeEnd = text.length(); + top.nodeEnd = rangeEnd; GreenNode built = top.buildGreen(); stack.pop(); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, built, top.nodeStart); } - return new GreenDocument(text.length(), + int docWidth = rangeEnd - rangeStart; + return new GreenDocument(docWidth, rootChildren.toArray(GreenNode.EMPTY_CHILDREN)); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java new file mode 100644 index 000000000..7f75bbb19 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java @@ -0,0 +1,131 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import org.eclipse.lsp4j.jsonrpc.CancelChecker; + +/** + * Incremental parser that reparses only the affected region of a document + * when an edit is applied, reusing unchanged subtrees via structural sharing. + * + *

Given an old {@link GreenDocument}, the new text, and edit coordinates, + * this class identifies top-level children that are entirely before or after + * the edit (prefix/suffix), reparses only the affected middle range using + * {@link GreenTreeBuilder#parseRange}, and splices the result together.

+ * + *

Falls back to full reparse when the edit crosses all children or when + * the reparsed middle ends with an unclosed element (which would invalidate + * the suffix).

+ */ +public final class IncrementalParser { + + private IncrementalParser() { + } + + /** + * Incrementally reparses the document. Returns a new {@link GreenDocument} + * that structurally shares unchanged subtrees with the old tree. + * + * @param oldDoc the previous immutable green tree + * @param newText the full new document text (after edit applied) + * @param editStart offset in old text where the edit begins + * @param deleteLength number of characters deleted from old text + * @param insertLength number of characters inserted (length of new text at edit point) + * @param uri the document URI + * @param monitor optional cancel checker + * @return a new GreenDocument (never null) + */ + public static GreenDocument incrementalParse(GreenDocument oldDoc, + String newText, int editStart, int deleteLength, int insertLength, + String uri, CancelChecker monitor) { + GreenDocument result = tryIncremental(oldDoc, newText, editStart, + deleteLength, insertLength, uri, monitor); + if (result != null) { + return result; + } + return GreenTreeBuilder.parse(newText, uri, monitor); + } + + private static GreenDocument tryIncremental(GreenDocument oldDoc, + String newText, int editStart, int deleteLength, int insertLength, + String uri, CancelChecker monitor) { + GreenNode[] oldChildren = oldDoc.children(); + if (oldChildren.length == 0) { + return null; + } + + int editEnd = editStart + deleteLength; + + // Find reusable prefix: children entirely before the edit + int prefixCount = 0; + int prefixWidth = 0; + for (int i = 0; i < oldChildren.length; i++) { + int childEnd = prefixWidth + oldChildren[i].width(); + if (childEnd <= editStart) { + prefixCount++; + prefixWidth = childEnd; + } else { + break; + } + } + + // Find reusable suffix: children entirely after the edit in old text + int suffixCount = 0; + int suffixWidth = 0; + int scanPos = oldDoc.width(); + for (int i = oldChildren.length - 1; i >= prefixCount; i--) { + int childStart = scanPos - oldChildren[i].width(); + if (childStart >= editEnd) { + suffixCount++; + suffixWidth += oldChildren[i].width(); + scanPos = childStart; + } else { + break; + } + } + + if (prefixCount + suffixCount == 0) { + return null; + } + + int middleStart = prefixWidth; + int middleEnd = newText.length() - suffixWidth; + if (middleEnd < middleStart || middleEnd > newText.length()) { + return null; + } + + GreenDocument middleDoc = GreenTreeBuilder.parseRange( + newText, uri, middleStart, middleEnd, monitor); + GreenNode[] middleChildren = middleDoc.children(); + + if (suffixCount > 0 && middleChildren.length > 0 + && !middleChildren[middleChildren.length - 1].closed()) { + middleDoc = GreenTreeBuilder.parseRange( + newText, uri, middleStart, newText.length(), monitor); + middleChildren = middleDoc.children(); + suffixCount = 0; + suffixWidth = 0; + } + + int total = prefixCount + middleChildren.length + suffixCount; + GreenNode[] newChildren = new GreenNode[total]; + System.arraycopy(oldChildren, 0, newChildren, 0, prefixCount); + System.arraycopy(middleChildren, 0, newChildren, prefixCount, + middleChildren.length); + if (suffixCount > 0) { + System.arraycopy(oldChildren, oldChildren.length - suffixCount, + newChildren, prefixCount + middleChildren.length, suffixCount); + } + + return new GreenDocument(newText.length(), newChildren); + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java new file mode 100644 index 000000000..521c72479 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java @@ -0,0 +1,129 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.commons; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.Arrays; +import java.util.Collections; + +import org.eclipse.lsp4j.Position; +import org.eclipse.lsp4j.Range; +import org.eclipse.lsp4j.TextDocumentContentChangeEvent; +import org.junit.jupiter.api.Test; + +/** + * Tests for {@link ModelTextDocument} incremental edit support. + */ +public class ModelTextDocumentTest { + + @Test + public void editInfoCapturedBeforeTextUpdate() { + ModelTextDocument doc = createDoc("text"); + doc.getModel(); + + TextDocumentContentChangeEvent change = new TextDocumentContentChangeEvent( + new Range(new Position(0, 10), new Position(0, 10)), "X"); + doc.update(Collections.singletonList(change)); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + assertEquals(10, edit.getStartOffset()); + assertEquals(0, edit.getDeleteLength()); + assertEquals(1, edit.getInsertLength()); + } + + @Test + public void previousModelPreservedOnCancel() { + ModelTextDocument doc = createDoc(""); + String firstModel = doc.getModel(); + assertNotNull(firstModel); + + doc.setText("changed"); + + String prev = doc.getPreviousModel(); + assertNotNull(prev); + assertEquals(firstModel, prev); + } + + @Test + public void pendingEditClearedAfterGetModel() { + ModelTextDocument doc = createDoc("text"); + doc.getModel(); + + TextDocumentContentChangeEvent change = new TextDocumentContentChangeEvent( + new Range(new Position(0, 10), new Position(0, 10)), "X"); + doc.update(Collections.singletonList(change)); + assertNotNull(doc.getPendingEdit()); + + doc.getModel(); + + assertNull(doc.getPendingEdit()); + assertNull(doc.getPreviousModel()); + } + + @Test + public void multipleChangesNullifyPendingEdit() { + ModelTextDocument doc = createDoc("text"); + doc.getModel(); + + TextDocumentContentChangeEvent change1 = createChange(0, 6, 0, 10, "newtext"); + TextDocumentContentChangeEvent change2 = createChange(0, 0, 0, 0, "X"); + doc.update(Arrays.asList(change1, change2)); + + assertNull(doc.getPendingEdit()); + } + + @Test + public void fullDocumentChangeNullifyPendingEdit() { + ModelTextDocument doc = createDoc(""); + doc.getModel(); + + TextDocumentContentChangeEvent change = new TextDocumentContentChangeEvent(""); + doc.update(Collections.singletonList(change)); + + assertNull(doc.getPendingEdit()); + } + + @Test + public void doubleCancelModelPreservesFirstPreviousModel() { + ModelTextDocument doc = createDoc(""); + String firstModel = doc.getModel(); + assertNotNull(firstModel); + + doc.setText("changed1"); + String prevAfterFirst = doc.getPreviousModel(); + assertEquals(firstModel, prevAfterFirst); + + // Second setText without getModel() in between — model is already null, + // so cancelModel() does NOT overwrite previousModel + doc.setText("changed2"); + String prevAfterSecond = doc.getPreviousModel(); + assertEquals(firstModel, prevAfterSecond); + } + + private ModelTextDocument createDoc(String text) { + ModelTextDocument doc = new ModelTextDocument<>(text, "test://test.xml", + (document, cancelChecker) -> document.getText()); + doc.setIncremental(true); + return doc; + } + + private TextDocumentContentChangeEvent createChange( + int startLine, int startChar, int endLine, int endChar, String text) { + return new TextDocumentContentChangeEvent( + new Range(new Position(startLine, startChar), new Position(endLine, endChar)), + text); + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java index 044588118..ee32a0fdf 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java @@ -353,6 +353,140 @@ public void largeDocumentPerformance() { "Parse took too long: " + (elapsed / 1_000_000) + "ms"); } + @Test + public void deeplyNestedElements() { + StringBuilder open = new StringBuilder(); + StringBuilder close = new StringBuilder(); + for (int i = 0; i < 15; i++) { + open.append(""); + close.insert(0, ""); + } + String xml = open.toString() + "deep" + close.toString(); + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertChildrenWidthSum(doc); + + GreenNode current = doc.child(0); + for (int i = 0; i < 14; i++) { + GreenElement elem = assertInstanceOf(GreenElement.class, current); + assertEquals("n" + i, elem.tag()); + assertEquals(1, elem.childCount()); + current = elem.child(0); + } + GreenElement innermost = assertInstanceOf(GreenElement.class, current); + assertEquals("n14", innermost.tag()); + assertEquals(1, innermost.childCount()); + assertInstanceOf(GreenText.class, innermost.child(0)); + } + + @Test + public void mixedContentTextAndElements() { + String xml = "

startboldmiditalicend

"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + GreenElement p = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(5, p.childCount()); + assertInstanceOf(GreenText.class, p.child(0)); + assertInstanceOf(GreenElement.class, p.child(1)); + assertInstanceOf(GreenText.class, p.child(2)); + assertInstanceOf(GreenElement.class, p.child(3)); + assertInstanceOf(GreenText.class, p.child(4)); + } + + @Test + public void namespaceDeclarations() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, root.attributeCount()); + assertEquals(1, root.childCount()); + GreenElement child = assertInstanceOf(GreenElement.class, root.child(0)); + assertEquals("ns:child", child.tag()); + } + + @Test + public void multipleProcessingInstructions() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + assertEquals(4, doc.childCount()); + GreenProcessingInstruction pi0 = assertInstanceOf(GreenProcessingInstruction.class, doc.child(0)); + assertTrue(pi0.prolog()); + GreenProcessingInstruction pi1 = assertInstanceOf(GreenProcessingInstruction.class, doc.child(1)); + assertEquals("pi1", pi1.target()); + assertFalse(pi1.prolog()); + GreenProcessingInstruction pi2 = assertInstanceOf(GreenProcessingInstruction.class, doc.child(2)); + assertEquals("pi2", pi2.target()); + assertInstanceOf(GreenElement.class, doc.child(3)); + } + + @Test + public void doctypePublicSystem() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + assertEquals(xml.length(), doc.width()); + GreenDocumentType dt = assertInstanceOf(GreenDocumentType.class, doc.child(0)); + assertTrue(dt.closed()); + assertChildrenWidthSum(doc); + } + + @Test + public void parseRangeUnclosedElement() { + String text = ""; + GreenDocument rangeDoc = GreenTreeBuilder.parseRange(text, "test.xml", 4, 11, null); + assertEquals(7, rangeDoc.width()); + GreenElement b = assertInstanceOf(GreenElement.class, rangeDoc.child(0)); + assertEquals("b", b.tag()); + assertFalse(b.closed()); + } + + @Test + public void withReplacedChildWidthAdjustment() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + int originalWidth = root.width(); + + GreenText wider = new GreenText(20, false); + GreenNode newRoot = root.withReplacedChild(1, wider); + assertEquals(originalWidth - 4 + 20, newRoot.width()); + + GreenText narrower = new GreenText(1, false); + GreenNode newRoot2 = root.withReplacedChild(1, narrower); + assertEquals(originalWidth - 4 + 1, newRoot2.width()); + } + + @Test + public void withReplacedChildFirst() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + GreenNode origB = root.child(1); + GreenNode origC = root.child(2); + + GreenText replacement = new GreenText(5, false); + GreenElement newRoot = assertInstanceOf(GreenElement.class, root.withReplacedChild(0, replacement)); + assertInstanceOf(GreenText.class, newRoot.child(0)); + assertTrue(origB == newRoot.child(1)); + assertTrue(origC == newRoot.child(2)); + } + + @Test + public void withReplacedChildLast() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + GreenNode origA = root.child(0); + GreenNode origB = root.child(1); + + GreenText replacement = new GreenText(5, false); + GreenElement newRoot = assertInstanceOf(GreenElement.class, root.withReplacedChild(2, replacement)); + assertTrue(origA == newRoot.child(0)); + assertTrue(origB == newRoot.child(1)); + assertInstanceOf(GreenText.class, newRoot.child(2)); + } + private void assertTotalWidthConsistent(GreenNode node) { GreenNode[] kids = node.children(); if (kids.length > 0) { diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java deleted file mode 100644 index f18fbb6f3..000000000 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeDebugTest.java +++ /dev/null @@ -1,70 +0,0 @@ -package org.eclipse.lemminx.dom.green; - -import org.eclipse.lemminx.dom.*; -import org.junit.jupiter.api.Test; - -public class GreenTreeDebugTest { - @Test - public void debugDoctypeNoInternalSubset() { - // Same input as testDoctypeNoInternalSubset - String content = "\r\n\r\n Fred\r\n"; - DOMDocument doc = DOMParser.getInstance().parse(content, "test.xml", null); - System.out.println("Children count: " + doc.getChildren().size()); - for (DOMNode child : doc.getChildren()) { - System.out.println(" Child: " + child.getClass().getSimpleName() + " start=" + child.getStart() + " end=" + child.getEnd()); - if (child instanceof DOMDocumentType) { - DOMDocumentType dt = (DOMDocumentType) child; - System.out.println(" name=" + dt.getName() + " closed=" + dt.isClosed()); - System.out.println(" parameters count: " + dt.getParameters().size()); - for (int i = 0; i < dt.getParameters().size(); i++) { - DTDDeclParameter p = dt.getParameters().get(i); - System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); - } - DTDDeclParameter nameParam = dt.getNameParameter(); - if (nameParam != null) { - System.out.println(" nameParam start=" + nameParam.getStart() + " end=" + nameParam.getEnd()); - } - System.out.println(" internalSubset=" + dt.getInternalSubsetNode()); - } - } - } - - @Test - public void debugDoctypeWithInternalSubset() { - String content = "\n]>"; - DOMDocument doc = DOMParser.getInstance().parse(content, "test.xml", null); - System.out.println("Children count: " + doc.getChildren().size()); - for (DOMNode child : doc.getChildren()) { - System.out.println(" Child: " + child.getClass().getSimpleName() + " start=" + child.getStart() + " end=" + child.getEnd()); - if (child instanceof DOMDocumentType) { - DOMDocumentType dt = (DOMDocumentType) child; - System.out.println(" name=" + dt.getName() + " closed=" + dt.isClosed()); - System.out.println(" parameters count: " + dt.getParameters().size()); - for (int i = 0; i < dt.getParameters().size(); i++) { - DTDDeclParameter p = dt.getParameters().get(i); - System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); - } - DTDDeclParameter nameParam = dt.getNameParameter(); - if (nameParam != null) { - System.out.println(" nameParam start=" + nameParam.getStart() + " end=" + nameParam.getEnd()); - } - DTDDeclParameter internalSubset = dt.getInternalSubsetNode(); - if (internalSubset != null) { - System.out.println(" internalSubset start=" + internalSubset.getStart() + " end=" + internalSubset.getEnd()); - } - System.out.println(" children: " + dt.getChildren().size()); - for (DOMNode dtChild : dt.getChildren()) { - System.out.println(" dtChild: " + dtChild.getClass().getSimpleName() + " start=" + dtChild.getStart() + " end=" + dtChild.getEnd()); - if (dtChild instanceof DTDDeclNode) { - DTDDeclNode decl = (DTDDeclNode) dtChild; - System.out.println(" name=" + decl.getName() + " params=" + decl.getParameters().size()); - for (int i = 0; i < decl.getParameters().size(); i++) { - DTDDeclParameter p = decl.getParameters().get(i); - System.out.println(" param[" + i + "] start=" + p.getStart() + " end=" + p.getEnd() + " val='" + content.substring(p.getStart(), p.getEnd()) + "'"); - } - } - } - } - } - } -} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java new file mode 100644 index 000000000..62e097bf5 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java @@ -0,0 +1,758 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom.green; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; + +import org.eclipse.lemminx.commons.TextDocument; +import org.eclipse.lemminx.dom.DOMDocument; +import org.eclipse.lemminx.dom.DOMParser; +import org.junit.jupiter.api.Test; + +/** + * Tests for {@link IncrementalParser}. + */ +public class IncrementalParserTest { + + @Test + public void insertTextInElement() { + String oldText = "helloworld"; + String newText = "helloXworld"; + // Insert 'X' at offset 14 (after "hello", before "") + assertIncrementalParse(oldText, newText, 14, 0, 1); + } + + @Test + public void deleteTextInElement() { + String oldText = "helloworld"; + String newText = "hellworld"; + // Delete 'o' at offset 13 + assertIncrementalParse(oldText, newText, 13, 1, 0); + } + + @Test + public void replaceTextInElement() { + String oldText = "helloworld"; + String newText = "hiworld"; + // Replace "hello" (offset 9, length 5) with "hi" (length 2) + assertIncrementalParse(oldText, newText, 9, 5, 2); + } + + @Test + public void insertInNestedElement() { + String oldText = "text"; + String newText = "textX"; + // Insert 'X' at offset 23 (after "text") + assertIncrementalParse(oldText, newText, 23, 0, 1); + } + + @Test + public void insertAttributeValue() { + String oldText = "text"; + String newText = "text"; + // Replace "old" with "new" at offset 13 + assertIncrementalParse(oldText, newText, 13, 3, 3); + } + + @Test + public void insertInLargeDocument() { + StringBuilder sb = new StringBuilder(); + sb.append("\n"); + for (int i = 0; i < 100; i++) { + sb.append(" value").append(i).append("\n"); + } + sb.append(""); + String oldText = sb.toString(); + + // Find where item 50 is and modify its text + int idx = oldText.indexOf(">value50<"); + String newText = oldText.substring(0, idx + 1) + "MODIFIED50" + oldText.substring(idx + 8); + // Replace "value50" (7 chars) with "MODIFIED50" (10 chars) at offset idx+1 + assertIncrementalParse(oldText, newText, idx + 1, 7, 10); + } + + @Test + public void structuralSharingTopLevel() { + // Structural sharing works at document level: prolog and comment + // are reused when editing inside the root element + String oldText = "text"; + String newText = "textX"; + + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenNode oldProlog = oldDoc.child(0); + GreenNode oldComment = oldDoc.child(1); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 46, 0, 1, "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + assertSame(oldProlog, newDoc.child(0), + "Prolog should be structurally shared (before edit)"); + assertSame(oldComment, newDoc.child(1), + "Comment should be structurally shared (before edit)"); + assertNotSame(oldDoc.child(2), newDoc.child(2), + "Root element should be new (contains the edit)"); + } + + @Test + public void fallbackOnTagNameChange() { + String oldText = "text"; + String newText = "text"; + // Change tag name — should fall back to full reparse but still produce correct result + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 7, 1, 1, "test.xml", null); + assertNotNull(newDoc); + assertEquals(newText.length(), newDoc.width()); + } + + @Test + public void fallbackOnEmptyOldDoc() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 0, 7, "test.xml", null); + assertNotNull(newDoc); + assertEquals(newText.length(), newDoc.width()); + } + + @Test + public void fallbackOnMultiNodeInsert() { + String oldText = "text"; + String newText = "text"; + // Insert '' after — creates new sibling, should fall back + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 17, 0, 4, "test.xml", null); + assertNotNull(newDoc); + assertEquals(newText.length(), newDoc.width()); + } + + @Test + public void resultMatchesFullParse() { + String oldText = "helloworld"; + String newText = "hello thereworld"; + // Insert " there" at offset 14 + assertIncrementalMatchesFullParse(oldText, newText, 14, 0, 6); + } + + @Test + public void resultMatchesFullParseOnDelete() { + String oldText = "some text"; + String newText = "text"; + // Delete "some " at offset 26 + assertIncrementalMatchesFullParse(oldText, newText, 26, 5, 0); + } + + @Test + public void resultMatchesFullParseNestedEdit() { + String oldText = "deep"; + String newText = "deeper"; + assertIncrementalMatchesFullParse(oldText, newText, 12, 1, 3); + } + + @Test + public void insertNewChildElement() { + String oldText = "text"; + String newText = "text"; + // Insert '' inside at offset 13 + assertIncrementalMatchesFullParse(oldText, newText, 13, 0, 4); + } + + @Test + public void editInDocWithProlog() { + String oldText = "\ntext"; + String newText = "\ntextX"; + assertIncrementalMatchesFullParse(oldText, newText, 34, 0, 1); + } + + @Test + public void editInDocWithComment() { + String oldText = "text"; + String newText = "textX"; + assertIncrementalMatchesFullParse(oldText, newText, 28, 0, 1); + } + + @Test + public void multipleTopLevelElementsEditMiddle() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 5, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(2), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void multipleTopLevelElementsEditFirst() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 4, 5, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(1), newDoc.child(1)); + assertSame(oldDoc.child(2), newDoc.child(2)); + } + + @Test + public void multipleTopLevelElementsEditLast() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 8, 4, 5, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(1)); + } + + @Test + public void insertElementBetween() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 0, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void deleteElementFromMiddle() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 0, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(2), newDoc.child(1)); + } + + @Test + public void appendElementAtEnd() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 8, 0, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(1)); + } + + @Test + public void prependElementAtStart() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 0, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(1)); + assertSame(oldDoc.child(1), newDoc.child(2)); + } + + @Test + public void unclosedElementInvalidatesSuffix() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 3, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void largeDocumentPrefixSuffixReuse() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 200; i++) { + sb.append(""); + } + String oldText = sb.toString(); + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + + int editOffset = 0; + for (int i = 0; i < 100; i++) { + editOffset += oldDoc.child(i).width(); + } + int oldChildWidth = oldDoc.child(100).width(); + + String replacement = ""; + String newText = oldText.substring(0, editOffset) + replacement + + oldText.substring(editOffset + oldChildWidth); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, editOffset, oldChildWidth, replacement.length(), + "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + for (int i = 0; i < 100; i++) { + assertSame(oldDoc.child(i), newDoc.child(i), + "Prefix child " + i + " should be reused"); + } + for (int i = 101; i < 200; i++) { + assertSame(oldDoc.child(i), newDoc.child(i), + "Suffix child " + i + " should be reused"); + } + } + + @Test + public void editWithWhitespaceGaps() { + String oldText = "\n\n\n"; + String newText = "\n\n\n"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 5, 4, 5, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void singleRootElementFallsBack() { + String oldText = "text"; + String newText = "textX"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 10, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void parseRangeSingleElement() { + String text = ""; + GreenDocument rangeDoc = GreenTreeBuilder.parseRange( + text, "test.xml", 4, 8, null); + assertEquals(4, rangeDoc.width()); + assertEquals(1, rangeDoc.childCount()); + GreenElement b = (GreenElement) rangeDoc.child(0); + assertEquals("b", b.tag()); + } + + @Test + public void parseRangeMultipleElements() { + String text = ""; + GreenDocument rangeDoc = GreenTreeBuilder.parseRange( + text, "test.xml", 4, 12, null); + assertEquals(8, rangeDoc.width()); + assertEquals(2, rangeDoc.childCount()); + } + + @Test + public void parseRangeFullDocument() { + String text = ""; + GreenDocument rangeDoc = GreenTreeBuilder.parseRange( + text, "test.xml", 0, text.length(), null); + GreenDocument fullDoc = GreenTreeBuilder.parse(text, "test.xml", null); + assertGreenTreesEqual(fullDoc, rangeDoc, ""); + } + + @Test + public void editPreservesDocWidth() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 16, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + } + + @Test + public void replaceAtPositionZero() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 4, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(1), newDoc.child(1)); + assertSame(oldDoc.child(2), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void deleteAtPositionZero() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 4, 0, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(1), newDoc.child(0)); + assertSame(oldDoc.child(2), newDoc.child(1)); + } + + @Test + public void deleteLastElement() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 8, 4, 0, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(1)); + } + + @Test + public void editSpanningTwoNodes() { + String oldText = ""; + String newText = ""; + // Replace entirely + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editWithDoctype() { + String oldText = "text"; + String newText = "textX"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenNode oldProlog = oldDoc.child(0); + GreenNode oldDoctype = oldDoc.child(1); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 45, 0, 1, "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + assertSame(oldProlog, newDoc.child(0), + "Prolog should be reused"); + assertSame(oldDoctype, newDoc.child(1), + "Doctype should be reused"); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editInsertMalformedXml() { + String oldText = ""; + String newText = ""; + // Delete "/>" from — creates malformed XML + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 6, 2, 0, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editInCDATASection() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 19, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editInComment() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 15, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void replaceEntireDocument() { + String oldText = "old"; + String newText = "content"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, oldText.length(), newText.length(), "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editWithProcessingInstruction() { + String oldText = "text"; + String newText = "textX"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 43, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(1)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editSelfClosingToOpen() { + String oldText = ""; + String newText = "text"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 4, 11, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(2), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void whitespaceOnlyDocument() { + String oldText = " \n "; + String newText = " \n "; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 6, 0, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void sequentialIncrementalEdits() { + String text1 = ""; + String text2 = ""; + String text3 = ""; + + GreenDocument doc1 = GreenTreeBuilder.parse(text1, "test.xml", null); + GreenDocument doc2 = IncrementalParser.incrementalParse( + doc1, text2, 4, 4, 5, "test.xml", null); + GreenDocument doc3 = IncrementalParser.incrementalParse( + doc2, text3, 4, 5, 6, "test.xml", null); + + assertEquals(text3.length(), doc3.width()); + assertSame(doc1.child(0), doc3.child(0)); + assertSame(doc1.child(2), doc3.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(text3, "test.xml", null), + doc3, ""); + } + + @Test + public void editConvertOpenToSelfClosing() { + String oldText = "text"; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 11, 4, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(2), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void deleteAllContent() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, 12, 0, "test.xml", null); + assertEquals(0, newDoc.width()); + assertEquals(0, newDoc.childCount()); + } + + @Test + public void insertAtExactNodeBoundary() { + String oldText = ""; + String newText = "X"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void deleteSpanningThreeNodes() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 12, 0, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(4), newDoc.child(1)); + } + + @Test + public void veryLargeInsert() { + String oldText = ""; + StringBuilder sb = new StringBuilder(""); + for (int i = 0; i < 50; i++) { + sb.append(""); + } + sb.append(""); + String newText = sb.toString(); + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 4, 0, newText.length() - 8, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(0), newDoc.child(0)); + assertSame(oldDoc.child(1), newDoc.child(newDoc.childCount() - 1)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void editInDocWithNamespaces() { + String oldText = "text"; + String newText = "textX"; + assertIncrementalMatchesFullParse(oldText, newText, 50, 0, 1); + } + + @Test + public void editPrologContent() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 15, 3, 3, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertSame(oldDoc.child(1), newDoc.child(1)); + assertSame(oldDoc.child(2), newDoc.child(2)); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void middleEndLessThanMiddleStartFallsBack() { + // Large deletion: remove middle 2 nodes from 3, leaving prefix+suffix + // that overlap in the new shorter text + String oldText = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; + // Delete everything between ... and ... AND shrink content + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 0, oldText.length(), newText.length(), "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void parseIncrementalIntegration() { + String oldText = "text"; + String newText = "textX"; + + TextDocument textDoc = new TextDocument(newText, "test://test.xml"); + GreenDocument oldGreen = GreenTreeBuilder.parse(oldText, "test://test.xml", null); + + DOMDocument incremental = DOMParser.getInstance().parseIncremental( + textDoc, oldGreen, 11, 0, 1, null, true, null); + DOMDocument full = DOMParser.getInstance().parse( + new TextDocument(newText, "test://test.xml"), null, true, null); + + assertNotNull(incremental); + assertNotNull(incremental.getGreenDocument()); + assertEquals(full.getChildren().size(), incremental.getChildren().size()); + assertEquals(newText.length(), incremental.getEnd()); + } + + private void assertIncrementalParse(String oldText, String newText, + int editStart, int deleteLength, int insertLength) { + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, editStart, deleteLength, insertLength, "test.xml", null); + + assertNotNull(newDoc, "Incremental parse should produce a result"); + assertEquals(newText.length(), newDoc.width(), + "New document width should match new text length"); + } + + private void assertIncrementalMatchesFullParse(String oldText, String newText, + int editStart, int deleteLength, int insertLength) { + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + + GreenDocument incremental = IncrementalParser.incrementalParse( + oldDoc, newText, editStart, deleteLength, insertLength, "test.xml", null); + + GreenDocument fullParse = GreenTreeBuilder.parse(newText, "test.xml", null); + + assertGreenTreesEqual(fullParse, incremental, ""); + } + + private void assertGreenTreesEqual(GreenNode expected, GreenNode actual, String path) { + assertEquals(expected.nodeType(), actual.nodeType(), + path + ": nodeType mismatch"); + assertEquals(expected.width(), actual.width(), + path + ": width mismatch"); + assertEquals(expected.closed(), actual.closed(), + path + ": closed mismatch"); + + if (expected instanceof GreenElement && actual instanceof GreenElement) { + assertEquals(((GreenElement) expected).tag(), ((GreenElement) actual).tag(), + path + ": tag mismatch"); + } + + GreenNode[] expectedChildren = expected.children(); + GreenNode[] actualChildren = actual.children(); + assertEquals(expectedChildren.length, actualChildren.length, + path + ": child count mismatch"); + + for (int i = 0; i < expectedChildren.length; i++) { + assertGreenTreesEqual(expectedChildren[i], actualChildren[i], + path + "/child[" + i + "]"); + } + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java index 795ca4546..866541598 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java @@ -511,6 +511,29 @@ public void mixedLineEndings() { assertRedTreeEquivalent("\n \r\n \r \n"); } + @Test + public void deeplyNestedTenLevels() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 10; i++) { + sb.append(""); + } + sb.append("deep"); + for (int i = 9; i >= 0; i--) { + sb.append(""); + } + assertRedTreeEquivalent(sb.toString()); + } + + @Test + public void piInsideElement() { + assertRedTreeEquivalent(""); + } + + @Test + public void multiplePIsInsideElement() { + assertRedTreeEquivalent(""); + } + private void assertRedTreeEquivalent(String xml) { TextDocument textDoc = new TextDocument(xml, "test://test.xml"); From 29d4340630cfa1b074a2f9e9ff6271761fea536c Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 08:03:35 +0200 Subject: [PATCH 03/18] Add recursive descent to incremental parser for deep structural sharing The incremental parser now descends into elements when exactly one child contains the edit, finding prefix/suffix children at each nesting level. This is critical for the common XML pattern of a single root element wrapping many children (e.g., with 24863 elements). Before: editing one product reparsed the entire (20 MB). After: only the modified is reparsed, 24862 others are reused. Key changes: - IncrementalParser: recursive tryIncrementalOnChildren/tryDescentIntoElement replaces flat document-level-only algorithm - GreenElement.withNewChildren(): creates element with new children and adjusted endTagOpenRel/endTagCloseRel offsets - Adjacent GreenText nodes at splice boundaries are coalesced to match full-parse tree structure - 6 new tests: descent into root, deep nesting, many children (100), attribute edit fallback, text coalescing, prolog+doctype+descent Signed-off-by: azerr Co-Authored-By: Claude Opus 4.6 --- .../lemminx/dom/green/GreenElement.java | 9 + .../lemminx/dom/green/IncrementalParser.java | 176 +++++++++++++++--- .../dom/green/IncrementalParserTest.java | 134 +++++++++++++ 3 files changed, 288 insertions(+), 31 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 88d6e669b..17323eff4 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -101,6 +101,15 @@ public GreenNode[] children() { return children; } + public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { + return new GreenElement( + width() + widthDelta, closed(), tag, selfClosed, + startTagCloseRel, + endTagOpenRel != NULL_VALUE ? endTagOpenRel + widthDelta : NULL_VALUE, + endTagCloseRel != NULL_VALUE ? endTagCloseRel + widthDelta : NULL_VALUE, + contentStartRel, attributes, newChildren); + } + @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { return new GreenElement(newWidth, closed(), tag, selfClosed, diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java index 7f75bbb19..48e9cb08b 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java @@ -18,13 +18,18 @@ * when an edit is applied, reusing unchanged subtrees via structural sharing. * *

Given an old {@link GreenDocument}, the new text, and edit coordinates, - * this class identifies top-level children that are entirely before or after - * the edit (prefix/suffix), reparses only the affected middle range using - * {@link GreenTreeBuilder#parseRange}, and splices the result together.

+ * this class identifies children that are entirely before or after the edit + * (prefix/suffix), and reparses only the affected middle range using + * {@link GreenTreeBuilder#parseRange}.

* - *

Falls back to full reparse when the edit crosses all children or when - * the reparsed middle ends with an unclosed element (which would invalidate - * the suffix).

+ *

When exactly one child contains the edit and that child is a + * {@link GreenElement} with sub-children, the parser recursively descends + * into that element to find sharing at deeper levels. This is critical for + * documents with a single root element wrapping many children (the common + * XML pattern).

+ * + *

Falls back to full reparse when no structural sharing is possible or + * when the reparsed middle ends with an unclosed element.

*/ public final class IncrementalParser { @@ -47,41 +52,45 @@ private IncrementalParser() { public static GreenDocument incrementalParse(GreenDocument oldDoc, String newText, int editStart, int deleteLength, int insertLength, String uri, CancelChecker monitor) { - GreenDocument result = tryIncremental(oldDoc, newText, editStart, - deleteLength, insertLength, uri, monitor); + int delta = insertLength - deleteLength; + int editEnd = editStart + deleteLength; + + GreenNode[] result = tryIncrementalOnChildren( + oldDoc.children(), 0, childrenWidth(oldDoc.children()), + editStart, editEnd, delta, newText, uri, monitor); + if (result != null) { - return result; + return new GreenDocument(newText.length(), result); } return GreenTreeBuilder.parse(newText, uri, monitor); } - private static GreenDocument tryIncremental(GreenDocument oldDoc, - String newText, int editStart, int deleteLength, int insertLength, - String uri, CancelChecker monitor) { - GreenNode[] oldChildren = oldDoc.children(); + private static GreenNode[] tryIncrementalOnChildren( + GreenNode[] oldChildren, int childrenAbsStart, int childrenAreaWidth, + int editStart, int editEnd, int delta, + String newText, String uri, CancelChecker monitor) { + if (oldChildren.length == 0) { return null; } - int editEnd = editStart + deleteLength; - - // Find reusable prefix: children entirely before the edit + // Find prefix: children entirely before the edit int prefixCount = 0; int prefixWidth = 0; for (int i = 0; i < oldChildren.length; i++) { - int childEnd = prefixWidth + oldChildren[i].width(); + int childEnd = childrenAbsStart + prefixWidth + oldChildren[i].width(); if (childEnd <= editStart) { prefixCount++; - prefixWidth = childEnd; + prefixWidth += oldChildren[i].width(); } else { break; } } - // Find reusable suffix: children entirely after the edit in old text + // Find suffix: children entirely after the edit in old text int suffixCount = 0; int suffixWidth = 0; - int scanPos = oldDoc.width(); + int scanPos = childrenAbsStart + childrenAreaWidth; for (int i = oldChildren.length - 1; i >= prefixCount; i--) { int childStart = scanPos - oldChildren[i].width(); if (childStart >= editEnd) { @@ -93,12 +102,32 @@ private static GreenDocument tryIncremental(GreenDocument oldDoc, } } + // Try descent if exactly one child in the middle + int middleCount = oldChildren.length - prefixCount - suffixCount; + if (middleCount == 1) { + GreenNode middleChild = oldChildren[prefixCount]; + if (middleChild instanceof GreenElement && middleChild.childCount() > 0) { + GreenElement elem = (GreenElement) middleChild; + int elemAbsStart = childrenAbsStart + prefixWidth; + GreenElement newElem = tryDescentIntoElement( + elem, elemAbsStart, editStart, editEnd, delta, + newText, uri, monitor); + if (newElem != null) { + return splice(oldChildren, prefixCount, suffixCount, + new GreenNode[] { newElem }); + } + } + } + + // Need at least some sharing to justify partial reparse if (prefixCount + suffixCount == 0) { return null; } - int middleStart = prefixWidth; - int middleEnd = newText.length() - suffixWidth; + // Parse the middle range in new text + int middleStart = childrenAbsStart + prefixWidth; + int middleEnd = childrenAbsStart + childrenAreaWidth + delta - suffixWidth; + if (middleEnd < middleStart || middleEnd > newText.length()) { return null; } @@ -107,25 +136,110 @@ private static GreenDocument tryIncremental(GreenDocument oldDoc, newText, uri, middleStart, middleEnd, monitor); GreenNode[] middleChildren = middleDoc.children(); + // If last reparsed child is unclosed, invalidate suffix if (suffixCount > 0 && middleChildren.length > 0 && !middleChildren[middleChildren.length - 1].closed()) { + int extendedEnd = childrenAbsStart + childrenAreaWidth + delta; + if (extendedEnd > newText.length()) { + return null; + } middleDoc = GreenTreeBuilder.parseRange( - newText, uri, middleStart, newText.length(), monitor); + newText, uri, middleStart, extendedEnd, monitor); middleChildren = middleDoc.children(); suffixCount = 0; - suffixWidth = 0; } - int total = prefixCount + middleChildren.length + suffixCount; - GreenNode[] newChildren = new GreenNode[total]; - System.arraycopy(oldChildren, 0, newChildren, 0, prefixCount); - System.arraycopy(middleChildren, 0, newChildren, prefixCount, - middleChildren.length); + return splice(oldChildren, prefixCount, suffixCount, middleChildren); + } + + private static GreenElement tryDescentIntoElement( + GreenElement elem, int elemAbsStart, + int editStart, int editEnd, int delta, + String newText, String uri, CancelChecker monitor) { + + int csr = elem.childrenStartRel(); + int childrenAbsStart = elemAbsStart + csr; + int childrenAreaWidth = childrenWidth(elem.children()); + + // Only descend if edit is entirely within children area + if (editStart < childrenAbsStart + || editEnd > childrenAbsStart + childrenAreaWidth) { + return null; + } + + GreenNode[] newChildren = tryIncrementalOnChildren( + elem.children(), childrenAbsStart, childrenAreaWidth, + editStart, editEnd, delta, newText, uri, monitor); + + if (newChildren == null) { + return null; + } + + return elem.withNewChildren(newChildren, delta); + } + + private static GreenNode[] splice(GreenNode[] oldChildren, + int prefixCount, int suffixCount, GreenNode[] middle) { + int total = prefixCount + middle.length + suffixCount; + GreenNode[] result = new GreenNode[total]; + System.arraycopy(oldChildren, 0, result, 0, prefixCount); + System.arraycopy(middle, 0, result, prefixCount, middle.length); if (suffixCount > 0) { System.arraycopy(oldChildren, oldChildren.length - suffixCount, - newChildren, prefixCount + middleChildren.length, suffixCount); + result, prefixCount + middle.length, suffixCount); + } + return coalesceAdjacentText(result); + } + + private static GreenNode[] coalesceAdjacentText(GreenNode[] nodes) { + boolean needed = false; + for (int i = 0; i < nodes.length - 1; i++) { + if (nodes[i] instanceof GreenText && nodes[i + 1] instanceof GreenText) { + needed = true; + break; + } + } + if (!needed) { + return nodes; + } + int newLen = 0; + for (int i = 0; i < nodes.length;) { + newLen++; + if (nodes[i] instanceof GreenText) { + while (++i < nodes.length && nodes[i] instanceof GreenText) { + } + } else { + i++; + } } + GreenNode[] result = new GreenNode[newLen]; + int j = 0; + for (int i = 0; i < nodes.length;) { + if (nodes[i] instanceof GreenText) { + int w = 0; + boolean allWhitespace = true; + int start = i; + while (i < nodes.length && nodes[i] instanceof GreenText) { + w += nodes[i].width(); + if (!((GreenText) nodes[i]).whitespace()) { + allWhitespace = false; + } + i++; + } + result[j++] = (i - start == 1) ? nodes[start] + : new GreenText(w, allWhitespace); + } else { + result[j++] = nodes[i++]; + } + } + return result; + } - return new GreenDocument(newText.length(), newChildren); + private static int childrenWidth(GreenNode[] children) { + int w = 0; + for (GreenNode child : children) { + w += child.width(); + } + return w; } } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java index 62e097bf5..92bbc4f19 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/IncrementalParserTest.java @@ -674,6 +674,140 @@ public void editPrologContent() { newDoc, ""); } + @Test + public void descentIntoRootElement() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenElement oldRoot = (GreenElement) oldDoc.child(0); + GreenNode oldA = oldRoot.child(0); + GreenNode oldC = oldRoot.child(2); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 10, 4, 5, "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + GreenElement newRoot = (GreenElement) newDoc.child(0); + assertSame(oldA, newRoot.child(0), "Child before edit should be reused"); + assertSame(oldC, newRoot.child(2), "Child after edit should be reused"); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void descentDeepNested() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenElement oldRoot = (GreenElement) oldDoc.child(0); + GreenElement oldOuter = (GreenElement) oldRoot.child(0); + GreenNode oldA = oldOuter.child(0); + GreenNode oldC = oldOuter.child(2); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 17, 4, 5, "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + GreenElement newRoot = (GreenElement) newDoc.child(0); + GreenElement newOuter = (GreenElement) newRoot.child(0); + assertSame(oldA, newOuter.child(0), "Nested should be reused"); + assertSame(oldC, newOuter.child(2), "Nested should be reused"); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void descentWithManyChildren() { + StringBuilder sb = new StringBuilder(""); + for (int i = 0; i < 100; i++) { + sb.append(""); + } + sb.append(""); + String oldText = sb.toString(); + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenElement oldRoot = (GreenElement) oldDoc.child(0); + + int editOffset = oldRoot.childrenStartRel(); + for (int i = 0; i < 50; i++) { + editOffset += oldRoot.child(i).width(); + } + int oldChildWidth = oldRoot.child(50).width(); + String replacement = ""; + + String newText = oldText.substring(0, editOffset) + replacement + + oldText.substring(editOffset + oldChildWidth); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, editOffset, oldChildWidth, replacement.length(), + "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + GreenElement newRoot = (GreenElement) newDoc.child(0); + for (int i = 0; i < 50; i++) { + assertSame(oldRoot.child(i), newRoot.child(i), + "Prefix child " + i + " inside root should be reused"); + } + for (int i = 51; i < 100; i++) { + assertSame(oldRoot.child(i), newRoot.child(i), + "Suffix child " + i + " inside root should be reused"); + } + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void descentFallsBackOnAttributeEdit() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 13, 3, 3, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void descentTextCoalescing() { + String oldText = "hello"; + String newText = "helloX"; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 11, 0, 1, "test.xml", null); + assertEquals(newText.length(), newDoc.width()); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + + @Test + public void descentWithPrologAndDoctype() { + String oldText = ""; + String newText = ""; + GreenDocument oldDoc = GreenTreeBuilder.parse(oldText, "test.xml", null); + GreenNode oldProlog = oldDoc.child(0); + GreenNode oldDoctype = oldDoc.child(1); + + GreenDocument newDoc = IncrementalParser.incrementalParse( + oldDoc, newText, 46, 4, 5, "test.xml", null); + + assertEquals(newText.length(), newDoc.width()); + assertSame(oldProlog, newDoc.child(0), "Prolog should be reused"); + assertSame(oldDoctype, newDoc.child(1), "Doctype should be reused"); + + GreenElement oldRoot = (GreenElement) oldDoc.child(2); + GreenElement newRoot = (GreenElement) newDoc.child(2); + assertSame(oldRoot.child(0), newRoot.child(0), " inside root should be reused"); + assertSame(oldRoot.child(2), newRoot.child(2), " inside root should be reused"); + assertGreenTreesEqual( + GreenTreeBuilder.parse(newText, "test.xml", null), + newDoc, ""); + } + @Test public void middleEndLessThanMiddleStartFallsBack() { // Large deletion: remove middle 2 nodes from 3, leaving prefix+suffix From 54c28fc36949e989f6656de4985a215988b8575e Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 08:16:44 +0200 Subject: [PATCH 04/18] Add detailed documentation for incremental red-green parser Covers the full architecture: green tree (immutable, width-based nodes), red tree (mutable DOMNode facade), GreenTreeBuilder, RedTreeBuilder, incremental parser algorithm (prefix/suffix detection, recursive descent, text coalescing), LSP integration (ModelTextDocument, volatile fields, edit flow), performance characteristics, and limitations. Co-Authored-By: Claude Opus 4.6 --- docs/Incremental-Red-Green-Parser.md | 494 +++++++++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 docs/Incremental-Red-Green-Parser.md diff --git a/docs/Incremental-Red-Green-Parser.md b/docs/Incremental-Red-Green-Parser.md new file mode 100644 index 000000000..e9fc89c87 --- /dev/null +++ b/docs/Incremental-Red-Green-Parser.md @@ -0,0 +1,494 @@ +# Incremental Red-Green Parser + +LemMinX uses a **Roslyn-style red-green tree** architecture for its XML DOM parser. This design enables **incremental reparsing**: when a user edits a document, only the affected region is reparsed, while unchanged subtrees are reused from the previous parse. This makes editing large XML files (100k+ lines) feel instantaneous. + +## Table of Contents + +- [Architecture Overview](#architecture-overview) +- [Green Tree (Immutable Layer)](#green-tree-immutable-layer) +- [Red Tree (Mutable Facade)](#red-tree-mutable-facade) +- [GreenTreeBuilder](#greentreebuilder) +- [RedTreeBuilder](#redtreebuilder) +- [Incremental Parsing](#incremental-parsing) + - [Algorithm Overview](#algorithm-overview) + - [Prefix/Suffix Detection](#prefixsuffix-detection) + - [Recursive Descent](#recursive-descent) + - [Text Coalescing](#text-coalescing) + - [Fallback to Full Parse](#fallback-to-full-parse) +- [Integration with LSP](#integration-with-lsp) + - [ModelTextDocument](#modeltextdocument) + - [Atomic Swap (volatile)](#atomic-swap-volatile) + - [Parse Lambda](#parse-lambda) +- [Performance Characteristics](#performance-characteristics) +- [Limitations](#limitations) +- [Node Types](#node-types) + +--- + +## Architecture Overview + +The parser pipeline has three stages: + +``` + XML text + | + v + GreenTreeBuilder ──► GreenDocument (immutable, width-based) + | + v + RedTreeBuilder ──► DOMDocument (mutable, absolute offsets, parent pointers) + | + v + LSP features (completion, validation, hover, ...) +``` + +On subsequent edits, the `IncrementalParser` replaces the first stage: + +``` + Old GreenDocument + edit info + new text + | + v + IncrementalParser ──► New GreenDocument (shares unchanged subtrees) + | + v + RedTreeBuilder ──► New DOMDocument +``` + +The key insight from the [Roslyn compiler](https://github.com/dotnet/roslyn) is to split the tree into two layers: + +| Layer | Offsets | Parent pointers | Mutability | Sharing | +|-------|---------|-----------------|------------|---------| +| **Green** (syntax) | Relative (widths) | No | Immutable | Yes - across versions | +| **Red** (semantic) | Absolute | Yes | Mutable | No - rebuilt each time | + +Because green nodes store **widths** (relative offsets) rather than absolute positions, two structurally identical subtrees at different document positions use the exact same green node objects. + +--- + +## Green Tree (Immutable Layer) + +All green nodes extend `GreenNode`: + +``` +GreenNode (abstract) +├── width: int — total span in characters +├── closed: boolean — whether this node was properly closed +├── children(): GreenNode[] +├── childrenStartRel(): int — offset from node start where children begin +└── nodeType(): short +``` + +### Green Node Types + +| Class | DOM Node Type | Description | +|-------|--------------|-------------| +| `GreenDocument` | `DOCUMENT_NODE` | Root, width = text length | +| `GreenElement` | `ELEMENT_NODE` | Tag, attributes, children | +| `GreenText` | `TEXT_NODE` | Text content, tracks `whitespace` flag | +| `GreenComment` | `COMMENT_NODE` | `` | +| `GreenCDATA` | `CDATA_SECTION_NODE` | `` | +| `GreenProcessingInstruction` | `PROCESSING_INSTRUCTION_NODE` | ``, prolog | +| `GreenDocumentType` | `DOCUMENT_TYPE_NODE` | `` | +| `GreenDTDElementDecl` | `DTD_ELEMENT_DECL_NODE` | `` | +| `GreenDTDAttlistDecl` | `DTD_ATT_LIST_NODE` | `` | +| `GreenDTDEntityDecl` | `ENTITY_NODE` | `` | +| `GreenDTDNotationDecl` | `DTD_NOTATION_DECL` | `` | + +### GreenElement Fields + +All offsets are **relative to the element's own start** (offset 0 is the first `<`): + +```java +tag: String // "div", "root", etc. +selfClosed: boolean // true for
+startTagCloseRel: int // offset of '>' in start tag +endTagOpenRel: int // offset of '<' in +endTagCloseRel: int // offset of '>' in +contentStartRel: int // offset where first child content starts +attributes: GreenAttr[] +children: GreenNode[] +``` + +Example for `` (width = 21): +``` +startTagCloseRel = 5 (the '>' after "root") +endTagOpenRel = 14 (the '<' in "") +endTagCloseRel = 20 (the '>' in "") +contentStartRel = 6 (start of first child) +children = [GreenElement("a", w=4), GreenElement("b", w=4)] +``` + +### GreenElement.withNewChildren() + +Creates a new element node with different children, adjusting end-tag offsets by the width delta: + +```java +public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { + return new GreenElement( + width() + widthDelta, closed(), tag, selfClosed, + startTagCloseRel, + endTagOpenRel != NULL_VALUE ? endTagOpenRel + widthDelta : NULL_VALUE, + endTagCloseRel != NULL_VALUE ? endTagCloseRel + widthDelta : NULL_VALUE, + contentStartRel, attributes, newChildren); +} +``` + +The start tag is unchanged (same `startTagCloseRel`, same `attributes`), but the end tag shifts by `delta` because the content area grew or shrank. + +### GreenAttr + +Each attribute stores name/value offsets relative to its owning element: + +```java +nameStartRel, nameEndRel // "class" in class="foo" +delimiterRel // the '=' +valueStartRel, valueEndRel // "\"foo\"" (including quotes) +``` + +--- + +## Red Tree (Mutable Facade) + +The **red tree** is the existing `DOMDocument` / `DOMNode` / `DOMElement` hierarchy that all LemMinX features depend on. It provides: + +- **Absolute offsets** (`getStart()`, `getEnd()`) +- **Parent pointers** (`getParentNode()`) +- **W3C DOM API** (`getChildNodes()`, `getAttributes()`, etc.) + +The red tree is built fresh from the green tree on every parse, but this is fast because `RedTreeBuilder` only walks the tree once, computing absolute offsets on the fly. + +--- + +## GreenTreeBuilder + +`GreenTreeBuilder.parse(text, uri, monitor)` produces a `GreenDocument` from XML text. + +It uses the existing `XMLScanner` (char-by-char, no regex, no substring) and mirrors the token-handling logic of the original `DOMParser`, but builds `GreenNode` objects instead of `DOMNode` objects. + +### parseRange() + +```java +GreenTreeBuilder.parseRange(text, uri, rangeStart, rangeEnd, monitor) +``` + +Parses a **sub-range** of the document text. The scanner starts at `rangeStart` and stops when it reaches `rangeEnd` with an empty stack. This is the building block for incremental parsing: only the affected range is re-scanned. + +### NodeBuilder + +Internally, `GreenTreeBuilder` uses `NodeBuilder` — a mutable scratch object that accumulates scanner tokens and converts them into an immutable `GreenNode` via `buildGreen()`. Each `NodeBuilder` tracks: + +- Tag name, attributes, children +- Absolute offsets (converted to relative during `buildGreen()`) +- DTD-specific fields (element decls, attlists, entities, notations) + +--- + +## RedTreeBuilder + +`RedTreeBuilder.build(greenDoc, textDocument, resolverExtensionManager)` walks the green tree recursively, creating the corresponding red (`DOMNode`) tree. + +For each green node, it: +1. Computes absolute offsets: `absStart + relativeOffset` +2. Creates the corresponding `DOMNode` subclass +3. Copies fields (tag, attributes, content offsets) +4. Recursively processes children, advancing `childAbsStart` by each child's width + +Whitespace-only text nodes between elements are skipped when `ignoreWhitespaceContent` is true (the default), matching the original parser's behavior. + +--- + +## Incremental Parsing + +The `IncrementalParser` is the heart of the performance optimization. Given an old `GreenDocument`, the new text, and edit coordinates, it produces a new `GreenDocument` that structurally shares unchanged subtrees with the old one. + +### Algorithm Overview + +``` +incrementalParse(oldDoc, newText, editStart, deleteLength, insertLength) + │ + ├─ tryIncrementalOnChildren(oldDoc.children, ...) + │ │ + │ ├─ Find prefix: children entirely before the edit + │ ├─ Find suffix: children entirely after the edit + │ │ + │ ├─ If exactly 1 middle child is a GreenElement with children: + │ │ └─ tryDescentIntoElement() → recursive descent + │ │ + │ ├─ If no sharing possible (prefix + suffix == 0): + │ │ └─ return null (fallback to full parse) + │ │ + │ └─ parseRange the middle region + │ ├─ If last reparsed child is unclosed: extend to include suffix + │ └─ splice(prefix + middle + suffix) → coalesceAdjacentText() + │ + └─ If result is null: GreenTreeBuilder.parse() (full reparse) +``` + +### Prefix/Suffix Detection + +The algorithm scans children left-to-right to find the **prefix** — consecutive children whose end offset falls before the edit start — and right-to-left for the **suffix** — children whose start offset falls after the edit end. + +``` +Document children: [PI] [Text] [Element-A] [Element-B] [Element-C] + ^^^ ^^^ ^^^^^^^^^ + prefix (2) suffix (1) + ^^^^^^^^^^^^ ^^^^^^^^^^^^ + middle (2) — must be reparsed +``` + +Prefix and suffix children are **reused as-is** from the old tree. Only the middle region is reparsed via `GreenTreeBuilder.parseRange()`. + +### Recursive Descent + +When exactly **one child** contains the edit and that child is a `GreenElement` with sub-children, the parser **descends into it** rather than reparsing the entire element. + +This is critical for the common XML pattern where a single root element wraps thousands of children: + +```xml + ← root element (1 child of document) + ... + ... ← edit is here + ... + ... + ... + +``` + +Without recursive descent, the entire `` element (and all 24,863 products) would be reparsed. With descent, the algorithm enters ``, finds 24,862 products as prefix/suffix, and reparses only the one affected product. + +The descent algorithm in `tryDescentIntoElement()`: + +1. Check that the edit is entirely within the element's **children area** (not in the start tag or end tag). If the edit touches an attribute or tag name, descent is not safe. +2. Recursively call `tryIncrementalOnChildren()` on the element's children. +3. If successful, return `elem.withNewChildren(newChildren, delta)` — a new `GreenElement` with the same tag, attributes, and start tag, but different children and adjusted end-tag offsets. + +Descent can be **multi-level**: if the element's single middle child is itself an element with children, the algorithm descends again. This handles arbitrarily deep nesting. + +### Text Coalescing + +After splicing prefix + reparsed middle + suffix, adjacent `GreenText` nodes may appear at the boundaries. For example: + +``` +Old children: [...] [Text "hello world"] [...] + ^^^^^ + edit here +After splice: [Text "hello "] [Text "new"] [Text " world"] + ^^ prefix text ^^ middle ^^ suffix text +``` + +A full parse would produce a single `GreenText` for the combined content. To ensure the incremental result matches the full-parse structure, `coalesceAdjacentText()` merges adjacent `GreenText` nodes: + +```java +[Text "hello "] [Text "new"] [Text " world"] → [Text "hello new world"] +``` + +The merged node's `whitespace` flag is `true` only if **all** merged nodes were whitespace. + +### Fallback to Full Parse + +The incremental parser falls back to a full reparse when: + +- **No structural sharing is possible**: `prefixCount + suffixCount == 0` at the document level +- **The reparsed middle ends with an unclosed element**: this invalidates the suffix (the unclosed element would absorb suffix nodes). The parser first tries extending the reparse range to include the suffix. If that also fails, it falls back to full parse. +- **The edit touches a tag name or attribute** of the single middle child: descent guard prevents corruption. + +--- + +## Integration with LSP + +### ModelTextDocument + +`ModelTextDocument` extends `TextDocument` with three `volatile` fields for thread-safe incremental support: + +```java +volatile DOMDocument model; // current parsed model +volatile DOMDocument previousModel; // model before the last edit +volatile EditInfo pendingEdit; // edit coordinates +``` + +The `update()` method is overridden to capture `EditInfo` **before** the text is changed (because offsets refer to the old text): + +```java +@Override +public void update(List changes) { + // Capture edit info BEFORE super.update() changes the text + if (changes != null && changes.size() == 1) { + Range range = changes.get(0).getRange(); + if (range != null) { + int start = offsetAt(range.getStart()); + pendingEdit = new EditInfo(start, deleteLength, insertLength); + } + } else { + pendingEdit = null; // multiple changes → can't incrementally parse + } + super.update(changes); // applies the text change +} +``` + +### Atomic Swap (volatile) + +The `volatile` keyword on `model`, `previousModel`, and `pendingEdit` ensures that: + +- The parsing thread sees the latest `previousModel` and `pendingEdit` set by the LSP event thread +- The LSP event thread sees the latest `model` set by the parsing thread + +The `cancelModel()` method atomically transitions the model state: + +```java +private void cancelModel() { + if (model != null) { + previousModel = model; // save current model for incremental use + } + model = null; // mark as dirty +} +``` + +The `DOMDocument` also stores its green tree via `volatile GreenDocument greenDocument`, so the incremental parser can access the previous green tree. + +### Parse Lambda + +In `XMLTextDocumentService`, the parse lambda checks for the incremental path: + +```java +DOMDocument prev = mtd.getPreviousModel(); +ModelTextDocument.EditInfo editInfo = mtd.getPendingEdit(); +if (prev != null && prev.getGreenDocument() != null && editInfo != null) { + return parser.parseIncremental(document, + prev.getGreenDocument(), + editInfo.getStartOffset(), + editInfo.getDeleteLength(), + editInfo.getInsertLength(), + resolverExtensionManager, + true /* ignoreWhitespaceContent */, cancelChecker); +} +// fallback: full parse +return parser.parse(document, resolverExtensionManager, true, cancelChecker); +``` + +The incremental path is taken when all three conditions are met: +1. A previous model exists (the document was parsed before) +2. The previous model has a green tree +3. A single-change edit info is available + +If any condition is missing (first parse, multiple simultaneous changes, full-document replacement), the standard full-parse path is taken. + +### Edit Flow + +The complete sequence for a `textDocument/didChange` notification: + +``` +1. setVersion(newVersion) → cancelModel() → previousModel = model; model = null +2. update(changes) → captures EditInfo before super.update() + → super.update() modifies the text +3. (later) getModel() → model is null → getSynchronizedModel() +4. getSynchronizedModel() → parse lambda runs + a. Checks previousModel, pendingEdit, greenDocument + b. If available: IncrementalParser.incrementalParse() + c. Else: GreenTreeBuilder.parse() (full) + d. RedTreeBuilder.build() (in both cases) + e. model = result; previousModel = null; pendingEdit = null +``` + +--- + +## Performance Characteristics + +### Time Complexity + +| Operation | Full Parse | Incremental Parse | +|-----------|-----------|-------------------| +| GreenTreeBuilder | O(n) | O(m) where m = middle range size | +| RedTreeBuilder | O(n) | O(n) — always walks full tree | +| IncrementalParser | — | O(k) where k = children count at each level | + +For a 600,000-line file with a single-character edit in one element: +- **Full parse**: scans all 600,000 lines +- **Incremental parse with descent**: scans only the ~25 lines of the affected element, plus O(log depth) work for descent + +### Memory + +Green nodes are shared between versions via structural sharing. For a single-character edit in a 24,863-element document, only the modified element and its ancestors are new allocations — the other 24,862 elements are the exact same Java objects. + +### Scanner Performance + +The `XMLScanner` and `GreenTreeBuilder` use only `charAt()` for character-by-character scanning. No `substring()`, no regex, no string allocation in the hot path. This is critical for handling multi-MB files without GC pressure. + +--- + +## Limitations + +1. **The red tree is always fully rebuilt.** `RedTreeBuilder` walks the entire green tree on every parse. For very large files, this is the bottleneck rather than the scanner. A future optimization could cache and reuse red subtrees that map to unchanged green subtrees. + +2. **Multi-change edits bypass incremental parsing.** If `textDocument/didChange` contains more than one `TextDocumentContentChangeEvent`, the incremental path is skipped (full reparse). This is uncommon in practice — most editors send single-change events. + +3. **Full-document replacements bypass incremental parsing.** A `TextDocumentContentChangeEvent` without a `Range` replaces the entire document. This cannot be incrementally parsed. + +4. **Edits that touch element structure fall back to broader reparsing.** If an edit changes a tag name or removes a closing tag, the incremental parser correctly detects that the reparsed middle is unclosed and extends the reparse range or falls back entirely. + +5. **DTD internal subsets are not incrementally parsed.** The `GreenDocumentType` node is treated as atomic — any edit within a `` block reparses the entire doctype. + +--- + +## Node Types + +### Class Diagram + +``` +GreenNode (abstract) +├── GreenDocument +├── GreenElement +├── GreenText +├── GreenComment +├── GreenCDATA +├── GreenProcessingInstruction +├── GreenDocumentType +│ └── (DTD nodes as children) +├── GreenDTDDeclNode +│ ├── GreenDTDElementDecl +│ ├── GreenDTDAttlistDecl +│ ├── GreenDTDEntityDecl +│ └── GreenDTDNotationDecl +├── GreenAttr (not a GreenNode — stored in GreenElement.attributes[]) +└── GreenDTDParam (not a GreenNode — stores DTD parameter offsets) +``` + +### File Locations + +``` +org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/ +├── dom/green/ +│ ├── GreenNode.java — abstract base, width/closed/children +│ ├── GreenDocument.java — document root +│ ├── GreenElement.java — XML element with tag, attrs, children +│ ├── GreenText.java — text content +│ ├── GreenComment.java — comment +│ ├── GreenCDATA.java — CDATA section +│ ├── GreenProcessingInstruction.java — PI and prolog +│ ├── GreenDocumentType.java — DOCTYPE +│ ├── GreenDTDDeclNode.java — base for DTD declarations +│ ├── GreenDTDElementDecl.java — +│ ├── GreenDTDAttlistDecl.java — +│ ├── GreenDTDEntityDecl.java — +│ ├── GreenDTDNotationDecl.java — +│ ├── GreenAttr.java — attribute (name/value offsets) +│ ├── GreenDTDParam.java — DTD parameter offsets +│ ├── GreenTreeBuilder.java — scanner → green tree +│ └── IncrementalParser.java — old green + edit → new green +├── dom/ +│ ├── DOMParser.java — entry point (parse + parseIncremental) +│ └── RedTreeBuilder.java — green tree → DOMDocument +└── commons/ + └── ModelTextDocument.java — volatile model + EditInfo capture +``` + +### Test Locations + +``` +org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/ +├── dom/green/ +│ ├── GreenTreeBuilderTest.java — 37 tests (green tree correctness) +│ ├── RedTreeBuilderTest.java — 77 tests (green→red equivalence) +│ └── IncrementalParserTest.java — 59 tests (incremental correctness) +└── commons/ + └── ModelTextDocumentTest.java — 6 tests (EditInfo, volatile state) +``` From aa9bb76b2774d2eb35d8983fb9b5647b0e83f187 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 08:51:22 +0200 Subject: [PATCH 05/18] Reduce memory by extracting only GreenDocument from previous model Replace previousModel (full DOMDocument with entire red tree) with previousIncrementalData that stores only the extracted GreenDocument. The old red tree is now eligible for GC immediately on cancelModel() instead of being held during the entire incremental parse. For a 21 MB file, this frees ~20 MB of heap earlier. The incrementalDataExtractor function is passed through ModelTextDocuments to ModelTextDocument, keeping the generic API clean. Co-Authored-By: Claude Opus 4.6 --- .../lemminx/XMLTextDocumentService.java | 9 +-- .../lemminx/commons/ModelTextDocument.java | 32 +++++++--- .../lemminx/commons/ModelTextDocuments.java | 10 +++- .../commons/ModelTextDocumentTest.java | 60 ++++++++++++++++--- 4 files changed, 91 insertions(+), 20 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java index b427b7584..957ffd10d 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java @@ -38,6 +38,7 @@ import org.eclipse.lemminx.commons.TextDocument; import org.eclipse.lemminx.dom.DOMDocument; import org.eclipse.lemminx.dom.DOMParser; +import org.eclipse.lemminx.dom.green.GreenDocument; import org.eclipse.lemminx.extensions.contentmodel.settings.XMLValidationRootSettings; import org.eclipse.lemminx.services.DocumentSymbolsResult; import org.eclipse.lemminx.services.SymbolInformationResult; @@ -205,11 +206,11 @@ public XMLTextDocumentService(XMLLanguageServer xmlLanguageServer) { if (document instanceof ModelTextDocument) { @SuppressWarnings("unchecked") ModelTextDocument mtd = (ModelTextDocument) document; - DOMDocument prev = mtd.getPreviousModel(); + Object prevData = mtd.getPreviousIncrementalData(); ModelTextDocument.EditInfo editInfo = mtd.getPendingEdit(); - if (prev != null && prev.getGreenDocument() != null && editInfo != null) { + if (prevData instanceof GreenDocument && editInfo != null) { return parser.parseIncremental(document, - prev.getGreenDocument(), + (GreenDocument) prevData, editInfo.getStartOffset(), editInfo.getDeleteLength(), editInfo.getInsertLength(), @@ -218,7 +219,7 @@ public XMLTextDocumentService(XMLLanguageServer xmlLanguageServer) { } } return parser.parse(document, getXMLLanguageService().getResolverExtensionManager(), true, cancelChecker); - }); + }, DOMDocument::getGreenDocument); this.sharedSettings = new SharedSettings(); this.limitExceededWarner = null; this.xmlValidatorDelayer = new ModelValidatorDelayer((document) -> { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java index 08c703df4..759663977 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java @@ -14,6 +14,7 @@ import java.util.List; import java.util.concurrent.CancellationException; import java.util.function.BiFunction; +import java.util.function.Function; import java.util.logging.Logger; import org.eclipse.lsp4j.Range; @@ -34,20 +35,34 @@ public class ModelTextDocument extends TextDocument { private final BiFunction parse; + private final Function incrementalDataExtractor; + private volatile T model; - private volatile T previousModel; + private volatile Object previousIncrementalData; private volatile EditInfo pendingEdit; public ModelTextDocument(TextDocumentItem document, BiFunction parse) { + this(document, parse, null); + } + + public ModelTextDocument(TextDocumentItem document, BiFunction parse, + Function incrementalDataExtractor) { super(document); this.parse = parse; + this.incrementalDataExtractor = incrementalDataExtractor; } public ModelTextDocument(String text, String uri, BiFunction parse) { + this(text, uri, parse, null); + } + + public ModelTextDocument(String text, String uri, BiFunction parse, + Function incrementalDataExtractor) { super(text, uri); this.parse = parse; + this.incrementalDataExtractor = incrementalDataExtractor; } /** @@ -98,7 +113,7 @@ private synchronized T getSynchronizedModel() { + (System.currentTimeMillis() - start) + "ms"); throw e; } finally { - previousModel = null; + previousIncrementalData = null; pendingEdit = null; LOGGER.fine("End parse of model with version '" + version + "' in " + (System.currentTimeMillis() - start) + "ms"); @@ -148,18 +163,21 @@ public void update(List changes) { */ private void cancelModel() { if (model != null) { - previousModel = model; + if (incrementalDataExtractor != null) { + previousIncrementalData = incrementalDataExtractor.apply(model); + } } model = null; } /** - * Returns the previous model (before the last edit) and null if not available. + * Returns the data extracted from the previous model for incremental parsing, + * or null if not available. * - * @return the previous model or null + * @return the incremental data or null */ - public T getPreviousModel() { - return previousModel; + public Object getPreviousIncrementalData() { + return previousIncrementalData; } /** diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocuments.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocuments.java index d3431fc58..cb2736af1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocuments.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocuments.java @@ -32,13 +32,21 @@ public class ModelTextDocuments extends TextDocuments> { private final BiFunction parse; + private final Function incrementalDataExtractor; + public ModelTextDocuments(BiFunction parse) { + this(parse, null); + } + + public ModelTextDocuments(BiFunction parse, + Function incrementalDataExtractor) { this.parse = parse; + this.incrementalDataExtractor = incrementalDataExtractor; } @Override public ModelTextDocument createDocument(TextDocumentItem document) { - ModelTextDocument doc = new ModelTextDocument(document, parse); + ModelTextDocument doc = new ModelTextDocument(document, parse, incrementalDataExtractor); doc.setIncremental(isIncremental()); return doc; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java index 521c72479..1873dc833 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java @@ -45,14 +45,14 @@ public void editInfoCapturedBeforeTextUpdate() { } @Test - public void previousModelPreservedOnCancel() { + public void previousIncrementalDataPreservedOnCancel() { ModelTextDocument doc = createDoc(""); String firstModel = doc.getModel(); assertNotNull(firstModel); doc.setText("changed"); - String prev = doc.getPreviousModel(); + Object prev = doc.getPreviousIncrementalData(); assertNotNull(prev); assertEquals(firstModel, prev); } @@ -70,7 +70,7 @@ public void pendingEditClearedAfterGetModel() { doc.getModel(); assertNull(doc.getPendingEdit()); - assertNull(doc.getPreviousModel()); + assertNull(doc.getPreviousIncrementalData()); } @Test @@ -97,25 +97,69 @@ public void fullDocumentChangeNullifyPendingEdit() { } @Test - public void doubleCancelModelPreservesFirstPreviousModel() { + public void doubleCancelModelPreservesFirstIncrementalData() { ModelTextDocument doc = createDoc(""); String firstModel = doc.getModel(); assertNotNull(firstModel); doc.setText("changed1"); - String prevAfterFirst = doc.getPreviousModel(); + Object prevAfterFirst = doc.getPreviousIncrementalData(); assertEquals(firstModel, prevAfterFirst); // Second setText without getModel() in between — model is already null, - // so cancelModel() does NOT overwrite previousModel + // so cancelModel() does NOT overwrite previousIncrementalData doc.setText("changed2"); - String prevAfterSecond = doc.getPreviousModel(); + Object prevAfterSecond = doc.getPreviousIncrementalData(); assertEquals(firstModel, prevAfterSecond); } + @Test + public void noExtractorMeansNoPreviousIncrementalData() { + ModelTextDocument doc = new ModelTextDocument<>("", "test://test.xml", + (document, cancelChecker) -> document.getText()); + doc.setIncremental(true); + String firstModel = doc.getModel(); + assertNotNull(firstModel); + + doc.setText("changed"); + + assertNull(doc.getPreviousIncrementalData()); + } + + @Test + public void customExtractorStoresTransformedData() { + ModelTextDocument doc = new ModelTextDocument<>("", "test://test.xml", + (document, cancelChecker) -> document.getText(), + s -> s.length()); + doc.setIncremental(true); + String firstModel = doc.getModel(); + assertNotNull(firstModel); + + doc.setText("changed"); + + Object prev = doc.getPreviousIncrementalData(); + assertNotNull(prev); + assertEquals(firstModel.length(), prev); + } + + @Test + public void doubleCancelWithoutExtractorRemainsNull() { + ModelTextDocument doc = new ModelTextDocument<>("", "test://test.xml", + (document, cancelChecker) -> document.getText()); + doc.setIncremental(true); + doc.getModel(); + + doc.setText("changed1"); + assertNull(doc.getPreviousIncrementalData()); + + doc.setText("changed2"); + assertNull(doc.getPreviousIncrementalData()); + } + private ModelTextDocument createDoc(String text) { ModelTextDocument doc = new ModelTextDocument<>(text, "test://test.xml", - (document, cancelChecker) -> document.getText()); + (document, cancelChecker) -> document.getText(), + s -> s); doc.setIncremental(true); return doc; } From 745a573378d3a20eaf94dcdc4986850196ff0765 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 14:05:08 +0200 Subject: [PATCH 06/18] Add lazy red tree building for incremental parses When parsing incrementally, defer DOMNode children creation until accessed via getChildren(), getFirstChild(), etc. Each element stores its GreenNode and absolute offset, expanding only when a feature navigates into it. This avoids creating all 50K+ red nodes upfront when only a small path is accessed (e.g., hover at cursor position). Co-Authored-By: Claude Opus 4.6 --- .../java/org/eclipse/lemminx/dom/DOMNode.java | 26 ++++++- .../org/eclipse/lemminx/dom/DOMParser.java | 5 +- .../eclipse/lemminx/dom/RedTreeBuilder.java | 40 +++++++--- .../lemminx/dom/green/RedTreeBuilderTest.java | 74 +++++++++++++++++++ 4 files changed, 132 insertions(+), 13 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index 4442b95de..eb922dd80 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -18,6 +18,7 @@ import java.util.Objects; import java.util.function.Function; +import org.eclipse.lemminx.dom.green.GreenNode; import org.w3c.dom.DOMException; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; @@ -73,11 +74,14 @@ public abstract class DOMNode implements Node, DOMRange { int end; // | DOMNode parent; - + // Cache the index in parent's children list to avoid O(n) indexOf() calls // This is set to -1 when not cached, and updated when needed int cachedIndexInParent = -1; + GreenNode lazyGreenNode; + int lazyAbsStart; + private static final NodeList EMPTY_CHILDREN = new NodeList() { @Override @@ -236,6 +240,7 @@ private String toString(int indent) { result.append(getNodeName()); result.append(", closed: "); result.append(isClosed()); + ensureChildren(); if (children != null && children.size() > 0) { result.append(", \n"); for (int i = 0; i < indent + 1; i++) { @@ -520,12 +525,22 @@ public List getChildrenWithAttributeValue(String name, String value) { return result; } + private void ensureChildren() { + if (lazyGreenNode != null) { + GreenNode green = lazyGreenNode; + int absStart = lazyAbsStart; + lazyGreenNode = null; + RedTreeBuilder.expandLazy(this, green, absStart); + } + } + /** * Returns the node children. - * + * * @return the node children. */ public List getChildren() { + ensureChildren(); if (children == null) { return Collections.emptyList(); } @@ -690,6 +705,7 @@ public DOMNode getParentNode() { */ @Override public DOMNode getFirstChild() { + ensureChildren(); return this.children != null && children.size() > 0 ? this.children.get(0) : null; } @@ -700,6 +716,7 @@ public DOMNode getFirstChild() { */ @Override public DOMNode getLastChild() { + ensureChildren(); return this.children != null && this.children.size() > 0 ? this.children.get(this.children.size() - 1) : null; } @@ -720,6 +737,7 @@ public NamedNodeMap getAttributes() { */ @Override public NodeList getChildNodes() { + ensureChildren(); return children != null ? children : EMPTY_CHILDREN; } @@ -921,6 +939,7 @@ public String getTextContent() throws DOMException { return null; // concatenation of the textContent attribute value of every child node default: + ensureChildren(); if (this.children != null && children.size() > 0) { final StringBuilder builder = new StringBuilder(); for (DOMNode child : children) { @@ -953,6 +972,9 @@ public Object getUserData(String arg0) { */ @Override public boolean hasChildNodes() { + if (lazyGreenNode != null) { + return true; + } return children != null && !children.isEmpty(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java index f8e4372e1..274a0f8b3 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java @@ -74,7 +74,10 @@ public DOMDocument parseIncremental(TextDocument document, String uri = document.getUri(); GreenDocument greenDoc = IncrementalParser.incrementalParse( previousGreenDoc, text, editStart, deleteLength, insertLength, uri, monitor); - return buildDocument(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent, monitor); + DOMDocument xmlDocument = RedTreeBuilder.buildLazy(greenDoc, document, resolverExtensionManager); + xmlDocument.setGreenDocument(greenDoc); + xmlDocument.setCancelChecker(monitor); + return xmlDocument; } private static DOMDocument buildDocument(GreenDocument greenDoc, TextDocument document, diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 63f8c7f98..e461382b1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -41,19 +41,30 @@ public final class RedTreeBuilder { private final boolean ignoreWhitespaceContent; + private final boolean lazy; - private RedTreeBuilder(boolean ignoreWhitespaceContent) { + private RedTreeBuilder(boolean ignoreWhitespaceContent, boolean lazy) { this.ignoreWhitespaceContent = ignoreWhitespaceContent; + this.lazy = lazy; } public static DOMDocument build(GreenDocument greenDoc, TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager) { - return new RedTreeBuilder(true).doBuild(greenDoc, textDocument, resolverExtensionManager); + return new RedTreeBuilder(true, false).doBuild(greenDoc, textDocument, resolverExtensionManager); } public static DOMDocument build(GreenDocument greenDoc, TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent) { - return new RedTreeBuilder(ignoreWhitespaceContent).doBuild(greenDoc, textDocument, resolverExtensionManager); + return new RedTreeBuilder(ignoreWhitespaceContent, false).doBuild(greenDoc, textDocument, resolverExtensionManager); + } + + public static DOMDocument buildLazy(GreenDocument greenDoc, TextDocument textDocument, + URIResolverExtensionManager resolverExtensionManager) { + return new RedTreeBuilder(true, true).doBuild(greenDoc, textDocument, resolverExtensionManager); + } + + static void expandLazy(DOMNode node, GreenNode green, int absStart) { + new RedTreeBuilder(true, true).addChildren(node, green, absStart); } private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, @@ -63,6 +74,15 @@ private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, return domDoc; } + private void addChildrenOrDefer(DOMNode node, GreenNode green, int absStart) { + if (lazy && green.children().length > 0) { + node.lazyGreenNode = green; + node.lazyAbsStart = absStart; + } else { + addChildren(node, green, absStart); + } + } + private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsStart) { GreenNode[] children = greenParent.children(); if (children.length == 0) { @@ -155,7 +175,7 @@ private DOMElement createElement(GreenElement green, int absStart, int absEnd) { elem.setAttributeNode(attr); } - addChildren(elem, green, absStart); + addChildrenOrDefer(elem, green, absStart); return elem; } @@ -244,7 +264,7 @@ private DOMDocumentType createDocumentType(GreenDocumentType green, } setDTDUnrecognized(dt, green, absStart); - addChildren(dt, green, absStart); + addChildrenOrDefer(dt, green, absStart); dt.end = absEnd; return dt; } @@ -263,7 +283,7 @@ private DTDElementDecl createDTDElementDecl(GreenDTDElementDecl green, absStart + green.content().endRel()); } setDTDUnrecognized(decl, green, absStart); - addChildren(decl, green, absStart); + addChildrenOrDefer(decl, green, absStart); decl.end = absEnd; return decl; } @@ -286,7 +306,7 @@ private DTDAttlistDecl createDTDAttlistDecl(GreenDTDAttlistDecl green, absStart + green.attributeValue().endRel()); } setDTDUnrecognized(decl, green, absStart); - addChildren(decl, green, absStart); + addChildrenOrDefer(decl, green, absStart); decl.end = absEnd; return decl; } @@ -317,7 +337,7 @@ private DTDEntityDecl createDTDEntityDecl(GreenDTDEntityDecl green, absStart + green.systemId().endRel()); } setDTDUnrecognized(decl, green, absStart); - addChildren(decl, green, absStart); + addChildrenOrDefer(decl, green, absStart); decl.end = absEnd; return decl; } @@ -340,7 +360,7 @@ private DTDNotationDecl createDTDNotationDecl(GreenDTDNotationDecl green, absStart + green.systemId().endRel()); } setDTDUnrecognized(decl, green, absStart); - addChildren(decl, green, absStart); + addChildrenOrDefer(decl, green, absStart); decl.end = absEnd; return decl; } @@ -351,7 +371,7 @@ private DTDDeclNode createDTDDeclNode(GreenDTDDeclNode green, decl.setClosed(green.closed()); setDTDDeclFields(decl, green, absStart); setDTDUnrecognized(decl, green, absStart); - addChildren(decl, green, absStart); + addChildrenOrDefer(decl, green, absStart); decl.end = absEnd; return decl; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java index 866541598..7eff0efbd 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/RedTreeBuilderTest.java @@ -534,6 +534,80 @@ public void multiplePIsInsideElement() { assertRedTreeEquivalent(""); } + // --- Lazy building tests --- + + @Test + public void lazyBuildProducesSameTree() { + String xml = "text"; + assertLazyTreeEquivalent(xml); + } + + @Test + public void lazyBuildDeferredUntilAccess() { + String xml = ""; + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + GreenDocument greenDoc = GreenTreeBuilder.parse(xml, "test://test.xml", null); + DOMDocument doc = RedTreeBuilder.buildLazy(greenDoc, textDoc, null); + + DOMElement root = (DOMElement) doc.getFirstChild(); + assertEquals("root", root.getTagName()); + + DOMElement a = (DOMElement) root.getFirstChild(); + assertEquals("a", a.getTagName()); + assertEquals(true, a.hasChildNodes()); + + DOMElement b = (DOMElement) a.getFirstChild(); + assertEquals("b", b.getTagName()); + } + + @Test + public void lazyBuildComplexDocument() { + String xml = "\n" + + "\n" + + " \n" + + " \n" + + " junit\n" + + " \n" + + " \n" + + ""; + assertLazyTreeEquivalent(xml); + } + + @Test + public void lazyBuildFindNodeAt() { + String xml = "textdeep"; + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + GreenDocument greenDoc = GreenTreeBuilder.parse(xml, "test://test.xml", null); + DOMDocument doc = RedTreeBuilder.buildLazy(greenDoc, textDoc, null); + doc.setGreenDocument(greenDoc); + + int offset = xml.indexOf("deep") + 1; + DOMNode found = doc.findNodeAt(offset); + assertEquals(true, found.isText()); + assertEquals("deep", ((DOMText) found).getData()); + } + + @Test + public void lazyBuildLargeDocument() { + StringBuilder sb = new StringBuilder(); + sb.append("\n"); + for (int i = 0; i < 1000; i++) { + sb.append(" value ").append(i).append("\n"); + } + sb.append(""); + assertLazyTreeEquivalent(sb.toString()); + } + + private void assertLazyTreeEquivalent(String xml) { + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + + GreenDocument greenDoc = GreenTreeBuilder.parse(xml, "test://test.xml", null); + DOMDocument eager = RedTreeBuilder.build(greenDoc, textDoc, null); + DOMDocument lazy = RedTreeBuilder.buildLazy(greenDoc, textDoc, null); + + assertNodesEqual(eager, lazy, xml); + } + private void assertRedTreeEquivalent(String xml) { TextDocument textDoc = new TextDocument(xml, "test://test.xml"); From 190a3791df0ca0626e4172bf109d78a97492b749 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 15:06:34 +0200 Subject: [PATCH 07/18] Reduce memory footprint of red-green tree and DOM nodes - Pack boolean fields into bit flags (widthAndFlags in GreenNode, byte flags in DOMNode) saving ~12MB across ~1.5M green nodes and ~8MB across red nodes - Replace ArrayList with raw arrays in NodeBuilder and GreenElementBuilder, reducing allocation from 578MB to 24MB - Add ArrayLineTracker (flat int[]+byte[]) replacing TreeLineTracker AVL tree, saving ~22MB (5 bytes/line vs 40 bytes/line) - Cache GreenText whitespace nodes for widths 0-127, saving ~14MB - Remove cached delimiter field from DOMCharacterData (computed on demand) - Add trimToSize compaction for XMLNodeList and XMLNamedNodeMap - Reduce default capacity of XMLNodeList from 10 to 2 Co-Authored-By: Claude Opus 4.6 --- .../lemminx/commons/ArrayLineTracker.java | 365 ++++++++++++++++++ .../eclipse/lemminx/commons/TextDocument.java | 2 +- .../eclipse/lemminx/dom/DOMCharacterData.java | 28 +- .../org/eclipse/lemminx/dom/DOMElement.java | 7 +- .../java/org/eclipse/lemminx/dom/DOMNode.java | 89 ++--- .../eclipse/lemminx/dom/RedTreeBuilder.java | 4 +- .../eclipse/lemminx/dom/green/GreenCDATA.java | 2 +- .../lemminx/dom/green/GreenComment.java | 8 +- .../lemminx/dom/green/GreenDTDDeclNode.java | 2 +- .../lemminx/dom/green/GreenDocument.java | 2 +- .../lemminx/dom/green/GreenElement.java | 10 +- .../dom/green/GreenElementBuilder.java | 31 +- .../eclipse/lemminx/dom/green/GreenNode.java | 26 +- .../dom/green/GreenProcessingInstruction.java | 2 +- .../eclipse/lemminx/dom/green/GreenText.java | 22 +- .../lemminx/dom/green/GreenTreeBuilder.java | 80 ++-- .../lemminx/dom/green/IncrementalParser.java | 2 +- .../lemminx/commons/ArrayLineTrackerTest.java | 263 +++++++++++++ 18 files changed, 794 insertions(+), 151 deletions(-) create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ArrayLineTrackerTest.java diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java new file mode 100644 index 000000000..c2f2316f4 --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java @@ -0,0 +1,365 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v2.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.commons; + +import org.eclipse.lsp4j.Position; + +/** + * Memory-efficient line tracker using flat arrays instead of an AVL tree. + * + *

Uses ~5 bytes per line (4-byte int offset + 1-byte delimiter type) vs + * ~40 bytes per line for the tree-based tracker. For a 621K-line file this + * saves ~22 MB of heap.

+ * + *

Query operations (offset-to-line, line-to-offset) are O(log n) via + * binary search. Update operations are O(n) for the array shift but use + * {@link System#arraycopy} which is extremely fast in practice.

+ */ +public class ArrayLineTracker implements ILineTracker { + + private static final String[] DELIMITERS = { "\r", "\n", "\r\n" }; + private static final String NO_DELIM = ""; + + private static final byte DELIM_NONE = 0; + private static final byte DELIM_LF = 1; + private static final byte DELIM_CR = 2; + private static final byte DELIM_CRLF = 3; + + private int[] lineStarts; + private byte[] delimTypes; + private int lineCount; + private int textLength; + + public ArrayLineTracker() { + lineStarts = new int[16]; + delimTypes = new byte[16]; + lineStarts[0] = 0; + delimTypes[0] = DELIM_NONE; + lineCount = 1; + textLength = 0; + } + + @Override + public void set(String text) { + textLength = text != null ? text.length() : 0; + int count = 1; + if (text != null) { + for (int i = 0; i < text.length(); i++) { + char ch = text.charAt(i); + if (ch == '\n') { + count++; + } else if (ch == '\r') { + count++; + if (i + 1 < text.length() && text.charAt(i + 1) == '\n') { + i++; + } + } + } + } + + lineStarts = new int[count]; + delimTypes = new byte[count]; + lineCount = count; + + lineStarts[0] = 0; + int lineIndex = 0; + if (text != null) { + for (int i = 0; i < text.length(); i++) { + char ch = text.charAt(i); + if (ch == '\n') { + delimTypes[lineIndex] = DELIM_LF; + lineIndex++; + lineStarts[lineIndex] = i + 1; + } else if (ch == '\r') { + if (i + 1 < text.length() && text.charAt(i + 1) == '\n') { + delimTypes[lineIndex] = DELIM_CRLF; + lineIndex++; + lineStarts[lineIndex] = i + 2; + i++; + } else { + delimTypes[lineIndex] = DELIM_CR; + lineIndex++; + lineStarts[lineIndex] = i + 1; + } + } + } + } + delimTypes[lineIndex] = DELIM_NONE; + } + + @Override + public void replace(int offset, int length, String text) throws BadLocationException { + int textLen = text != null ? text.length() : 0; + int delta = textLen - length; + + int startLine = findLineByOffset(offset); + int endLine = (length == 0) ? startLine : findLineByOffset(offset + length); + + byte endLineDelim = delimTypes[endLine]; + + int newDelimCount = 0; + int[] newStarts = null; + byte[] newDelims = null; + + if (textLen > 0) { + int count = 0; + for (int i = 0; i < textLen; i++) { + char ch = text.charAt(i); + if (ch == '\n') { + count++; + } else if (ch == '\r') { + count++; + if (i + 1 < textLen && text.charAt(i + 1) == '\n') { + i++; + } + } + } + if (count > 0) { + newDelimCount = count; + newStarts = new int[count]; + newDelims = new byte[count]; + int idx = 0; + for (int i = 0; i < textLen; i++) { + char ch = text.charAt(i); + if (ch == '\n') { + newDelims[idx] = DELIM_LF; + newStarts[idx] = offset + i + 1; + idx++; + } else if (ch == '\r') { + if (i + 1 < textLen && text.charAt(i + 1) == '\n') { + newDelims[idx] = DELIM_CRLF; + newStarts[idx] = offset + i + 2; + idx++; + i++; + } else { + newDelims[idx] = DELIM_CR; + newStarts[idx] = offset + i + 1; + idx++; + } + } + } + } + } + + int removedLines = endLine - startLine; + int linesDelta = newDelimCount - removedLines; + int newLineCount = lineCount + linesDelta; + + ensureCapacity(newLineCount); + + int tailSrc = endLine + 1; + int tailDst = startLine + 1 + newDelimCount; + int tailLen = lineCount - tailSrc; + + if (tailLen > 0) { + System.arraycopy(lineStarts, tailSrc, lineStarts, tailDst, tailLen); + System.arraycopy(delimTypes, tailSrc, delimTypes, tailDst, tailLen); + if (delta != 0) { + for (int i = tailDst; i < tailDst + tailLen; i++) { + lineStarts[i] += delta; + } + } + } + + if (newDelimCount > 0) { + for (int i = 0; i < newDelimCount; i++) { + lineStarts[startLine + 1 + i] = newStarts[i]; + delimTypes[startLine + i] = newDelims[i]; + } + } + delimTypes[startLine + newDelimCount] = endLineDelim; + + lineCount = newLineCount; + textLength += delta; + } + + @Override + public String getLineDelimiter(int line) throws BadLocationException { + if (line < 0 || line >= lineCount) { + throw new BadLocationException(); + } + String delim = delimiterTypeToString(delimTypes[line]); + return NO_DELIM.equals(delim) ? null : delim; + } + + @Override + public int computeNumberOfLines(String text) { + int count = 0; + if (text != null) { + for (int i = 0; i < text.length(); i++) { + char ch = text.charAt(i); + if (ch == '\n') { + count++; + } else if (ch == '\r') { + count++; + if (i + 1 < text.length() && text.charAt(i + 1) == '\n') { + i++; + } + } + } + } + return count; + } + + @Override + public int getNumberOfLines() { + return lineCount; + } + + @Override + public int getNumberOfLines(int offset, int length) throws BadLocationException { + if (length == 0) { + return 1; + } + int startLine = findLineByOffset(offset); + int endLine = findLineByOffset(offset + length); + return endLine - startLine + 1; + } + + @Override + public int getLineOffset(int line) throws BadLocationException { + if (line < 0 || line >= lineCount) { + throw new BadLocationException(); + } + return lineStarts[line]; + } + + @Override + public int getLineLength(int line) throws BadLocationException { + if (line < 0 || line >= lineCount) { + throw new BadLocationException(); + } + if (line + 1 < lineCount) { + return lineStarts[line + 1] - lineStarts[line]; + } + return textLength - lineStarts[line]; + } + + @Override + public int getLineNumberOfOffset(int offset) throws BadLocationException { + return findLineByOffset(offset); + } + + @Override + public Position getPositionAt(int offset) throws BadLocationException { + int line = findLineByOffset(offset); + int character = offset - lineStarts[line]; + return new Position(line, character); + } + + @Override + public int getOffsetAt(Position position) throws BadLocationException { + int line = position.getLine(); + if (line < 0 || line >= lineCount) { + throw new BadLocationException("The line value, {" + line + "}, is out of bounds."); + } + int lineOffset = lineStarts[line]; + int lineLength = pureLength(line); + int character = position.getCharacter(); + int offset = lineOffset + character; + int endLineOffset = lineOffset + lineLength; + if (offset > endLineOffset) { + throw new BadLocationException( + "The character value, {" + character + "} of the line" + line + "}, is out of bounds."); + } + return offset; + } + + @Override + public Line getLineInformationOfOffset(int offset) throws BadLocationException { + int line = findLineByOffset(offset); + return new Line(lineStarts[line], pureLength(line)); + } + + @Override + public Line getLineInformation(int line) throws BadLocationException { + try { + if (line < 0 || line >= lineCount) { + throw new BadLocationException(); + } + return new Line(lineStarts[line], pureLength(line)); + } catch (BadLocationException x) { + if (line > 0 && line == lineCount) { + int lastLine = line - 1; + int lastLineEnd = lineStarts[lastLine] + getLineLength(lastLine); + if (getLineLength(lastLine) > 0) { + return new Line(lastLineEnd, 0); + } + } + throw x; + } + } + + private int pureLength(int line) { + int totalLength; + if (line + 1 < lineCount) { + totalLength = lineStarts[line + 1] - lineStarts[line]; + } else { + totalLength = textLength - lineStarts[line]; + } + return totalLength - delimLength(delimTypes[line]); + } + + private int findLineByOffset(int offset) throws BadLocationException { + if (offset < 0 || offset > textLength) { + throw new BadLocationException(); + } + int lo = 0, hi = lineCount - 1; + while (lo < hi) { + int mid = lo + (hi - lo + 1) / 2; + if (lineStarts[mid] <= offset) { + lo = mid; + } else { + hi = mid - 1; + } + } + return lo; + } + + private void ensureCapacity(int minCapacity) { + if (minCapacity > lineStarts.length) { + int newCapacity = Math.max(minCapacity, lineStarts.length + (lineStarts.length >> 1)); + int[] newStarts = new int[newCapacity]; + byte[] newDelims = new byte[newCapacity]; + System.arraycopy(lineStarts, 0, newStarts, 0, lineCount); + System.arraycopy(delimTypes, 0, newDelims, 0, lineCount); + lineStarts = newStarts; + delimTypes = newDelims; + } + } + + private static int delimLength(byte delimType) { + switch (delimType) { + case DELIM_LF: + case DELIM_CR: + return 1; + case DELIM_CRLF: + return 2; + default: + return 0; + } + } + + private static String delimiterTypeToString(byte delimiterType) { + switch (delimiterType) { + case DELIM_LF: + return DELIMITERS[1]; + case DELIM_CR: + return DELIMITERS[0]; + case DELIM_CRLF: + return DELIMITERS[2]; + default: + return NO_DELIM; + } + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java index e62a3db94..bc62642de 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java @@ -148,7 +148,7 @@ private synchronized ILineTracker createLineTracker() { if (lineTracker != null) { return lineTracker; } - ILineTracker lineTracker = isIncremental() ? new TreeLineTracker(new ListLineTracker()) : new ListLineTracker(); + ILineTracker lineTracker = isIncremental() ? new ArrayLineTracker() : new ListLineTracker(); lineTracker.set(super.getText()); return lineTracker; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java index b3cc42d60..564e53ec2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java @@ -26,10 +26,6 @@ */ public abstract class DOMCharacterData extends DOMNode implements org.w3c.dom.CharacterData { - private boolean isWhitespace; - - private String delimiter; - public DOMCharacterData(int start, int end) { super(start, end); } @@ -39,16 +35,14 @@ public boolean hasMultiLine() { } public String getDelimiter() { - if (delimiter != null) { - return delimiter; - } try { - delimiter = getOwnerDocument().getTextDocument().lineDelimiter(0); - return delimiter; + String d = getOwnerDocument().getTextDocument().lineDelimiter(0); + if (d != null) { + return d; + } } catch (BadLocationException e) { - delimiter = lineSeparator(); - return delimiter; } + return lineSeparator(); } /** @@ -150,20 +144,12 @@ public String getNodeValue() throws DOMException { return getData(); } - /** - * @return the isWhitespace - */ public boolean isWhitespace() { - return isWhitespace; + return hasFlag(FLAG_WHITESPACE); } - /** - * Set true if this node's data is all whitespace - * - * @param isWhitespace - */ public void setWhitespace(boolean isWhitespace) { - this.isWhitespace = isWhitespace; + setFlag(FLAG_WHITESPACE, isWhitespace); } /* diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index f0351c635..6f02007be 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -33,7 +33,6 @@ public class DOMElement extends DOMNode implements org.w3c.dom.Element { String tag; - boolean selfClosed; // DomElement.start == startTagOpenOffset int startTagOpenOffset = NULL_VALUE; // | @@ -235,7 +234,11 @@ public boolean isDocumentElement() { } public boolean isSelfClosed() { - return selfClosed; + return hasFlag(FLAG_SELF_CLOSED); + } + + void setSelfClosed(boolean selfClosed) { + setFlag(FLAG_SELF_CLOSED, selfClosed); } /** diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index eb922dd80..aaecf4309 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -61,11 +61,10 @@ public abstract class DOMNode implements Node, DOMRange { */ public static final short DTD_DECL_NODE = 105; - // Memory optimization: Use byte flags instead of multiple boolean fields - // This saves 7 bytes per node (boolean with padding = 8 bytes, byte = 1 byte) private byte flags = 0; private static final byte FLAG_CLOSED = 0x01; - // Reserved for future flags: 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 + static final byte FLAG_SELF_CLOSED = 0x02; + static final byte FLAG_WHITESPACE = 0x04; private XMLNamedNodeMap attributeNodes; private XMLNodeList children; @@ -75,8 +74,6 @@ public abstract class DOMNode implements Node, DOMRange { DOMNode parent; - // Cache the index in parent's children list to avoid O(n) indexOf() calls - // This is set to -1 when not cached, and updated when needed int cachedIndexInParent = -1; GreenNode lazyGreenNode; @@ -98,13 +95,9 @@ public int getLength() { static class XMLNodeList extends ArrayList implements NodeList { private static final long serialVersionUID = 1L; - - // Pre-allocate capacity to reduce ArrayList resizing overhead - // Most elements have 2-5 children, so start with capacity of 4 - private static final int INITIAL_CAPACITY = 4; XMLNodeList() { - super(INITIAL_CAPACITY); + super(2); } @Override @@ -116,35 +109,6 @@ public int getLength() { public DOMNode item(int index) { return super.get(index); } - - @Override - public boolean add(T node) { - boolean result = super.add(node); - // Invalidate cached indices for all nodes after this one - invalidateCachedIndices(size() - 1); - return result; - } - - @Override - public void add(int index, T node) { - super.add(index, node); - // Invalidate cached indices for all nodes from this index onwards - invalidateCachedIndices(index); - } - - @Override - public T remove(int index) { - T removed = super.remove(index); - // Invalidate cached indices for all nodes from this index onwards - invalidateCachedIndices(index); - return removed; - } - - private void invalidateCachedIndices(int fromIndex) { - for (int i = fromIndex; i < size(); i++) { - get(i).cachedIndexInParent = -1; - } - } } @@ -152,6 +116,10 @@ static class XMLNamedNodeMap extends ArrayList implements private static final long serialVersionUID = 1L; + XMLNamedNodeMap() { + super(4); + } + @Override public int getLength() { return super.size(); @@ -202,7 +170,18 @@ public T setNamedItemNS(org.w3c.dom.Node arg0) throws DOMException { public DOMNode(int start, int end) { this.start = start; this.end = end; - // flags is already initialized to 0, so FLAG_CLOSED is not set + } + + protected final boolean hasFlag(byte flag) { + return (flags & flag) != 0; + } + + protected final void setFlag(byte flag, boolean value) { + if (value) { + flags |= flag; + } else { + flags &= ~flag; + } } /** @@ -557,11 +536,19 @@ public void addChild(DOMNode child) { if (children == null) { children = new XMLNodeList<>(); } - // Cache the index when adding child.cachedIndexInParent = children.size(); children.add(child); } + void compactChildren() { + if (children != null) { + children.trimToSize(); + } + if (attributeNodes != null) { + attributeNodes.trimToSize(); + } + } + /** * Returns node child at the given index. * @@ -573,19 +560,11 @@ public DOMNode getChild(int index) { } public boolean isClosed() { - return (flags & FLAG_CLOSED) != 0; + return hasFlag(FLAG_CLOSED); } - /** - * Sets the closed flag for this node. - * Package-private to allow DOMParser to set it. - */ void setClosed(boolean closed) { - if (closed) { - flags |= FLAG_CLOSED; - } else { - flags &= ~FLAG_CLOSED; - } + setFlag(FLAG_CLOSED, closed); } public DOMElement getParentElement() { @@ -808,15 +787,11 @@ public DOMNode getNextSibling() { return null; } List children = parentNode.getChildren(); - - // Use cached index if available to avoid O(n) indexOf() call int currentIndex = cachedIndexInParent; if (currentIndex == -1) { - // Cache miss - compute and cache the index currentIndex = children.indexOf(this); cachedIndexInParent = currentIndex; } - int nextIndex = currentIndex + 1; return nextIndex < children.size() ? children.get(nextIndex) : null; } @@ -843,15 +818,11 @@ public DOMNode getPreviousSibling() { return null; } List children = parentNode.getChildren(); - - // Use cached index if available to avoid O(n) indexOf() call int currentIndex = cachedIndexInParent; if (currentIndex == -1) { - // Cache miss - compute and cache the index currentIndex = children.indexOf(this); cachedIndexInParent = currentIndex; } - int previousIndex = currentIndex - 1; return previousIndex >= 0 ? children.get(previousIndex) : null; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index e461382b1..73768da18 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -71,6 +71,7 @@ private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager) { DOMDocument domDoc = new DOMDocument(textDocument, resolverExtensionManager); addChildren(domDoc, greenDoc, 0); + domDoc.compactChildren(); return domDoc; } @@ -110,6 +111,7 @@ private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsSta } childAbsStart += greenChild.width(); } + parent.compactChildren(); } private static boolean hasNonWhitespaceChild(GreenNode[] children) { @@ -159,7 +161,7 @@ private DOMNode createRedNode(GreenNode green, int absStart) { private DOMElement createElement(GreenElement green, int absStart, int absEnd) { DOMElement elem = new DOMElement(absStart, absEnd); elem.tag = green.tag(); - elem.selfClosed = green.selfClosed(); + elem.setSelfClosed(green.selfClosed()); boolean isOrphanEndTag = green.endTagOpenRel() != GreenElement.NULL_VALUE && green.endTagOpenRel() == 0 && green.startTagCloseRel() == GreenElement.NULL_VALUE; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java index 1048cba78..cfc654c48 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenCDATA.java @@ -22,7 +22,7 @@ public final class GreenCDATA extends GreenNode { private final int endContentRel; public GreenCDATA(int width, boolean closed, int startContentRel, int endContentRel) { - super(width, closed); + super(width, closed ? CLOSED_FLAG : 0); this.startContentRel = startContentRel; this.endContentRel = endContentRel; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java index 070e30c21..8dafde6f0 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenComment.java @@ -18,14 +18,12 @@ */ public final class GreenComment extends GreenNode { - private final boolean commentSameLineEndTag; private final int startContentRel; private final int endContentRel; public GreenComment(int width, boolean closed, boolean commentSameLineEndTag, int startContentRel, int endContentRel) { - super(width, closed); - this.commentSameLineEndTag = commentSameLineEndTag; + super(width, (closed ? CLOSED_FLAG : 0) | (commentSameLineEndTag ? SUBCLASS_FLAG : 0)); this.startContentRel = startContentRel; this.endContentRel = endContentRel; } @@ -36,7 +34,7 @@ public short nodeType() { } public boolean commentSameLineEndTag() { - return commentSameLineEndTag; + return subclassFlag(); } public int startContentRel() { @@ -49,7 +47,7 @@ public int endContentRel() { @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { - return new GreenComment(newWidth, closed(), commentSameLineEndTag, + return new GreenComment(newWidth, closed(), commentSameLineEndTag(), startContentRel, endContentRel); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java index 67ee849d1..ddf2df0ea 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDTDDeclNode.java @@ -34,7 +34,7 @@ public GreenDTDDeclNode(int width, boolean closed, GreenDTDParam unrecognized, GreenDTDParam declType, GreenDTDParam name, GreenDTDParam[] parameters, GreenNode[] children) { - super(width, closed); + super(width, closed ? CLOSED_FLAG : 0); this.unrecognized = unrecognized; this.declType = declType; this.name = name; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java index 338a35b70..e351f33fb 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenDocument.java @@ -24,7 +24,7 @@ public final class GreenDocument extends GreenNode { private final GreenNode[] children; public GreenDocument(int width, GreenNode[] children) { - super(width, true); + super(width, CLOSED_FLAG); this.children = children != null ? children : EMPTY_CHILDREN; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 17323eff4..9d69f07e6 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -25,7 +25,6 @@ public final class GreenElement extends GreenNode { public static final int NULL_VALUE = -1; private final String tag; - private final boolean selfClosed; private final int startTagCloseRel; private final int endTagOpenRel; private final int endTagCloseRel; @@ -37,9 +36,8 @@ public GreenElement(int width, boolean closed, String tag, boolean selfClosed, int startTagCloseRel, int endTagOpenRel, int endTagCloseRel, int contentStartRel, GreenAttr[] attributes, GreenNode[] children) { - super(width, closed); + super(width, (closed ? CLOSED_FLAG : 0) | (selfClosed ? SUBCLASS_FLAG : 0)); this.tag = tag; - this.selfClosed = selfClosed; this.startTagCloseRel = startTagCloseRel; this.endTagOpenRel = endTagOpenRel; this.endTagCloseRel = endTagCloseRel; @@ -58,7 +56,7 @@ public String tag() { } public boolean selfClosed() { - return selfClosed; + return subclassFlag(); } public int startTagCloseRel() { @@ -103,7 +101,7 @@ public GreenNode[] children() { public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { return new GreenElement( - width() + widthDelta, closed(), tag, selfClosed, + width() + widthDelta, closed(), tag, selfClosed(), startTagCloseRel, endTagOpenRel != NULL_VALUE ? endTagOpenRel + widthDelta : NULL_VALUE, endTagCloseRel != NULL_VALUE ? endTagCloseRel + widthDelta : NULL_VALUE, @@ -112,7 +110,7 @@ public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { - return new GreenElement(newWidth, closed(), tag, selfClosed, + return new GreenElement(newWidth, closed(), tag, selfClosed(), startTagCloseRel, endTagOpenRel, endTagCloseRel, contentStartRel, attributes, newChildren); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java index 2c0e51e22..3d27f64ff 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java @@ -11,8 +11,7 @@ *******************************************************************************/ package org.eclipse.lemminx.dom.green; -import java.util.ArrayList; -import java.util.List; +import java.util.Arrays; /** * Mutable builder for {@link GreenElement}. @@ -31,8 +30,10 @@ public final class GreenElementBuilder { private int startTagCloseOffset = GreenElement.NULL_VALUE; private int endTagOpenOffset = GreenElement.NULL_VALUE; private int endTagCloseOffset = GreenElement.NULL_VALUE; - private List attributes; - private List children; + private GreenAttr[] attributes; + private int attrCount; + private GreenNode[] children; + private int childCount; public GreenElementBuilder(int nodeStart) { this.nodeStart = nodeStart; @@ -81,16 +82,24 @@ public void setEndTagCloseOffset(int offset) { public void addAttribute(GreenAttr attr) { if (attributes == null) { - attributes = new ArrayList<>(4); + attributes = new GreenAttr[4]; + attrCount = 0; } - attributes.add(attr); + if (attrCount == attributes.length) { + attributes = Arrays.copyOf(attributes, attributes.length * 2); + } + attributes[attrCount++] = attr; } public void addChild(GreenNode child) { if (children == null) { - children = new ArrayList<>(4); + children = new GreenNode[4]; + childCount = 0; + } + if (childCount == children.length) { + children = Arrays.copyOf(children, children.length * 2); } - children.add(child); + children[childCount++] = child; } public GreenElement build() { @@ -103,9 +112,11 @@ public GreenElement build() { ? endTagCloseOffset - nodeStart : GreenElement.NULL_VALUE; GreenAttr[] attrs = attributes != null - ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + ? (attrCount == attributes.length ? attributes : Arrays.copyOf(attributes, attrCount)) + : null; GreenNode[] kids = children != null - ? children.toArray(GreenNode.EMPTY_CHILDREN) : null; + ? (childCount == children.length ? children : Arrays.copyOf(children, childCount)) + : null; return new GreenElement(width, closed, tag, selfClosed, stcRel, etoRel, etcRel, GreenElement.NULL_VALUE, attrs, kids); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java index aec6f8493..3ac420869 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java @@ -27,22 +27,28 @@ public abstract class GreenNode { public static final GreenNode[] EMPTY_CHILDREN = new GreenNode[0]; public static final GreenAttr[] EMPTY_ATTRS = new GreenAttr[0]; - private final int width; - private final boolean closed; + static final int CLOSED_FLAG = 1 << 31; + static final int SUBCLASS_FLAG = 1 << 30; + private static final int WIDTH_MASK = 0x3FFFFFFF; - protected GreenNode(int width, boolean closed) { - this.width = width; - this.closed = closed; + private final int widthAndFlags; + + protected GreenNode(int width, int flags) { + this.widthAndFlags = width | flags; } public abstract short nodeType(); - public int width() { - return width; + public final int width() { + return widthAndFlags & WIDTH_MASK; + } + + public final boolean closed() { + return (widthAndFlags & CLOSED_FLAG) != 0; } - public boolean closed() { - return closed; + protected final boolean subclassFlag() { + return (widthAndFlags & SUBCLASS_FLAG) != 0; } public GreenNode[] children() { @@ -63,7 +69,7 @@ public GreenNode withReplacedChild(int index, GreenNode newChild) { System.arraycopy(old, 0, copy, 0, old.length); int deltaWidth = newChild.width() - old[index].width(); copy[index] = newChild; - return replaceChildren(copy, width + deltaWidth); + return replaceChildren(copy, width() + deltaWidth); } public int childrenStartRel() { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java index 07b23f7b1..422cde7a9 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenProcessingInstruction.java @@ -32,7 +32,7 @@ public GreenProcessingInstruction(int width, boolean closed, boolean startTagClo String target, boolean prolog, boolean processingInstruction, int startContentRel, int endContentRel, int endTagOpenRel, GreenAttr[] attributes) { - super(width, closed); + super(width, closed ? CLOSED_FLAG : 0); this.startTagClose = startTagClose; this.target = target; this.prolog = prolog; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java index 5608f3c9b..f6fabece2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenText.java @@ -18,11 +18,23 @@ */ public final class GreenText extends GreenNode { - private final boolean whitespace; + private static final int CACHE_SIZE = 128; + private static final GreenText[] WHITESPACE_CACHE = new GreenText[CACHE_SIZE]; + static { + for (int i = 0; i < CACHE_SIZE; i++) { + WHITESPACE_CACHE[i] = new GreenText(i, true); + } + } public GreenText(int width, boolean whitespace) { - super(width, true); - this.whitespace = whitespace; + super(width, CLOSED_FLAG | (whitespace ? SUBCLASS_FLAG : 0)); + } + + public static GreenText whitespace(int width) { + if (width >= 0 && width < CACHE_SIZE) { + return WHITESPACE_CACHE[width]; + } + return new GreenText(width, true); } @Override @@ -31,11 +43,11 @@ public short nodeType() { } public boolean whitespace() { - return whitespace; + return subclassFlag(); } @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { - return new GreenText(newWidth, whitespace); + return whitespace() ? whitespace(newWidth) : new GreenText(newWidth, false); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index efe3c37af..55600cd8a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -13,6 +13,7 @@ import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Arrays; import java.util.Deque; import java.util.List; @@ -439,7 +440,7 @@ public static GreenDocument parseRange(String text, String uri, break; } - GreenText textNode = new GreenText(end - start, isBlank); + GreenText textNode = isBlank ? GreenText.whitespace(end - start) : new GreenText(end - start, false); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, textNode, start); break; } @@ -831,8 +832,8 @@ public static GreenDocument parseRange(String text, String uri, } private static int lastParamEnd(NodeBuilder nb) { - if (nb.dtdParams != null && !nb.dtdParams.isEmpty()) { - return nb.dtdParams.get(nb.dtdParams.size() - 1)[1]; + if (nb.dtdParams != null && nb.paramCount > 0) { + return nb.dtdParams[nb.paramCount - 1][1]; } return nb.nodeEnd; } @@ -879,7 +880,7 @@ private static void addChildToCurrentOrRoot(Deque stack, stack.peek().addChild(child, childAbsStart); } else { if (childAbsStart > nextRootChildEnd[0]) { - rootChildren.add(new GreenText(childAbsStart - nextRootChildEnd[0], true)); + rootChildren.add(GreenText.whitespace(childAbsStart - nextRootChildEnd[0])); } rootChildren.add(child); nextRootChildEnd[0] = childAbsStart + child.width(); @@ -905,7 +906,8 @@ static final class NodeBuilder { int startTagCloseOffset = GreenElement.NULL_VALUE; int endTagOpenOffset = GreenElement.NULL_VALUE; int endTagCloseOffset = GreenElement.NULL_VALUE; - List attributes; + GreenAttr[] attributes; + int attrCount; // PI fields boolean startTagClose; @@ -933,10 +935,12 @@ static final class NodeBuilder { int[] dtdPercentParam; int[] dtdValueParam; int[] dtdUnrecognizedParam; - List dtdParams; + int[][] dtdParams; + int paramCount; // Children - List children; + GreenNode[] children; + int childCount; int firstChildAbsStart = GreenElement.NULL_VALUE; int nextChildAbsStart = GreenElement.NULL_VALUE; @@ -948,29 +952,51 @@ static final class NodeBuilder { void addChild(GreenNode child, int childAbsStart) { if (children == null) { - children = new ArrayList<>(4); + children = new GreenNode[4]; + childCount = 0; firstChildAbsStart = childAbsStart; nextChildAbsStart = childAbsStart; } if (childAbsStart > nextChildAbsStart) { - children.add(new GreenText(childAbsStart - nextChildAbsStart, true)); + appendChild(GreenText.whitespace(childAbsStart - nextChildAbsStart)); } - children.add(child); + appendChild(child); nextChildAbsStart = childAbsStart + child.width(); } + private void appendChild(GreenNode child) { + if (childCount == children.length) { + GreenNode[] grown = new GreenNode[children.length * 2]; + System.arraycopy(children, 0, grown, 0, childCount); + children = grown; + } + children[childCount++] = child; + } + void addAttribute(GreenAttr attr) { if (attributes == null) { - attributes = new ArrayList<>(4); + attributes = new GreenAttr[4]; + attrCount = 0; } - attributes.add(attr); + if (attrCount == attributes.length) { + GreenAttr[] grown = new GreenAttr[attributes.length * 2]; + System.arraycopy(attributes, 0, grown, 0, attrCount); + attributes = grown; + } + attributes[attrCount++] = attr; } void addParam(int start, int end) { if (dtdParams == null) { - dtdParams = new ArrayList<>(4); + dtdParams = new int[4][]; + paramCount = 0; + } + if (paramCount == dtdParams.length) { + int[][] grown = new int[dtdParams.length * 2][]; + System.arraycopy(dtdParams, 0, grown, 0, paramCount); + dtdParams = grown; } - dtdParams.add(new int[] { start, end }); + dtdParams[paramCount++] = new int[] { start, end }; } void addDeclType(int start, int end) { @@ -978,20 +1004,20 @@ void addDeclType(int start, int end) { } int[] lastParam() { - return dtdParams.get(dtdParams.size() - 1); + return dtdParams[paramCount - 1]; } void updateLastParamEnd(int end) { - if (dtdParams != null && !dtdParams.isEmpty()) { - int[] last = dtdParams.get(dtdParams.size() - 1); - last[1] = end; + if (dtdParams != null && paramCount > 0) { + dtdParams[paramCount - 1][1] = end; } } GreenNode buildGreen() { int width = nodeEnd - nodeStart; GreenNode[] kids = children != null - ? children.toArray(GreenNode.EMPTY_CHILDREN) : null; + ? (childCount == children.length ? children : Arrays.copyOf(children, childCount)) + : null; switch (kind) { case ELEMENT: @@ -1021,7 +1047,8 @@ GreenNode buildGreen() { private GreenElement buildElement(int width, GreenNode[] kids) { GreenAttr[] attrs = attributes != null - ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + ? (attrCount == attributes.length ? attributes : Arrays.copyOf(attributes, attrCount)) + : null; int contentStart = firstChildAbsStart != GreenElement.NULL_VALUE ? firstChildAbsStart - nodeStart : (startTagCloseOffset != GreenElement.NULL_VALUE @@ -1044,7 +1071,8 @@ private GreenCDATA buildCDATA(int width) { private GreenProcessingInstruction buildPI(int width) { GreenAttr[] attrs = attributes != null - ? attributes.toArray(GreenNode.EMPTY_ATTRS) : null; + ? (attrCount == attributes.length ? attributes : Arrays.copyOf(attributes, attrCount)) + : null; return new GreenProcessingInstruction(width, closed, startTagClose, target, prolog, processingInstruction, rel(startContentOffset), rel(endContentOffset), @@ -1076,7 +1104,7 @@ private GreenNode[] padChildrenForDocType(GreenNode[] kids) { return kids; } GreenNode[] padded = new GreenNode[kids.length + 1]; - padded[0] = new GreenText(leadingGap, true); + padded[0] = GreenText.whitespace(leadingGap); System.arraycopy(kids, 0, padded, 1, kids.length); return padded; } @@ -1152,12 +1180,12 @@ private GreenDTDParam toParam(int[] offsets) { } private GreenDTDParam[] buildDTDParams() { - if (dtdParams == null || dtdParams.isEmpty()) { + if (dtdParams == null || paramCount == 0) { return null; } - GreenDTDParam[] result = new GreenDTDParam[dtdParams.size()]; - for (int i = 0; i < dtdParams.size(); i++) { - int[] p = dtdParams.get(i); + GreenDTDParam[] result = new GreenDTDParam[paramCount]; + for (int i = 0; i < paramCount; i++) { + int[] p = dtdParams[i]; result[i] = new GreenDTDParam(p[0] - nodeStart, p[1] - nodeStart); } return result; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java index 48e9cb08b..ec0d3dfc5 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java @@ -227,7 +227,7 @@ private static GreenNode[] coalesceAdjacentText(GreenNode[] nodes) { i++; } result[j++] = (i - start == 1) ? nodes[start] - : new GreenText(w, allWhitespace); + : allWhitespace ? GreenText.whitespace(w) : new GreenText(w, false); } else { result[j++] = nodes[i++]; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ArrayLineTrackerTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ArrayLineTrackerTest.java new file mode 100644 index 000000000..495188ddd --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ArrayLineTrackerTest.java @@ -0,0 +1,263 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.commons; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.eclipse.lsp4j.Position; +import org.junit.jupiter.api.Test; + +public class ArrayLineTrackerTest { + + @Test + public void emptyText() throws BadLocationException { + ArrayLineTracker t = create(""); + assertEquals(1, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(0, t.getLineLength(0)); + assertNull(t.getLineDelimiter(0)); + } + + @Test + public void singleLine() throws BadLocationException { + ArrayLineTracker t = create("hello"); + assertEquals(1, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(5, t.getLineLength(0)); + assertNull(t.getLineDelimiter(0)); + + assertEquals(0, t.getLineNumberOfOffset(0)); + assertEquals(0, t.getLineNumberOfOffset(4)); + assertEquals(0, t.getLineNumberOfOffset(5)); + } + + @Test + public void twoLinesLF() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef"); + assertEquals(2, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(4, t.getLineLength(0)); + assertEquals("\n", t.getLineDelimiter(0)); + assertEquals(4, t.getLineOffset(1)); + assertEquals(3, t.getLineLength(1)); + assertNull(t.getLineDelimiter(1)); + + assertEquals(0, t.getLineNumberOfOffset(0)); + assertEquals(0, t.getLineNumberOfOffset(3)); + assertEquals(1, t.getLineNumberOfOffset(4)); + assertEquals(1, t.getLineNumberOfOffset(7)); + } + + @Test + public void twoLinesCRLF() throws BadLocationException { + ArrayLineTracker t = create("abc\r\ndef"); + assertEquals(2, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(5, t.getLineLength(0)); + assertEquals("\r\n", t.getLineDelimiter(0)); + assertEquals(5, t.getLineOffset(1)); + assertEquals(3, t.getLineLength(1)); + } + + @Test + public void trailingNewline() throws BadLocationException { + ArrayLineTracker t = create("abc\n"); + assertEquals(2, t.getNumberOfLines()); + assertEquals(4, t.getLineOffset(1)); + assertEquals(0, t.getLineLength(1)); + assertNull(t.getLineDelimiter(1)); + } + + @Test + public void positionAt() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + Position p = t.getPositionAt(0); + assertEquals(0, p.getLine()); + assertEquals(0, p.getCharacter()); + + p = t.getPositionAt(5); + assertEquals(1, p.getLine()); + assertEquals(1, p.getCharacter()); + + p = t.getPositionAt(11); + assertEquals(2, p.getLine()); + assertEquals(3, p.getCharacter()); + } + + @Test + public void offsetAt() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + assertEquals(0, t.getOffsetAt(new Position(0, 0))); + assertEquals(3, t.getOffsetAt(new Position(0, 3))); + assertEquals(4, t.getOffsetAt(new Position(1, 0))); + assertEquals(8, t.getOffsetAt(new Position(2, 0))); + } + + @Test + public void replaceInsertCharNoDelimiter() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef"); + t.replace(1, 0, "X"); + assertEquals(2, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(5, t.getLineLength(0)); + assertEquals(5, t.getLineOffset(1)); + assertEquals(3, t.getLineLength(1)); + } + + @Test + public void replaceInsertNewline() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef"); + t.replace(5, 0, "\n"); + assertEquals(3, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(4, t.getLineLength(0)); + assertEquals(4, t.getLineOffset(1)); + assertEquals(2, t.getLineLength(1)); + assertEquals("\n", t.getLineDelimiter(1)); + assertEquals(6, t.getLineOffset(2)); + assertEquals(2, t.getLineLength(2)); + assertNull(t.getLineDelimiter(2)); + } + + @Test + public void replaceDeleteNewline() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef"); + t.replace(3, 1, ""); + assertEquals(1, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(6, t.getLineLength(0)); + assertNull(t.getLineDelimiter(0)); + } + + @Test + public void replaceDeleteMultipleLines() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi\njkl"); + // Delete "ef\nghi" at offset 5, length 6 → "abc\nd\njkl" + t.replace(5, 6, ""); + assertEquals(3, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(4, t.getLineLength(0)); + assertEquals(4, t.getLineOffset(1)); + assertEquals(2, t.getLineLength(1)); + assertEquals(6, t.getLineOffset(2)); + assertEquals(3, t.getLineLength(2)); + } + + @Test + public void replaceWithMultipleNewlines() throws BadLocationException { + ArrayLineTracker t = create("abcdef"); + t.replace(2, 2, "X\nY\nZ"); + assertEquals(3, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(4, t.getLineLength(0)); + assertEquals("\n", t.getLineDelimiter(0)); + assertEquals(4, t.getLineOffset(1)); + assertEquals(2, t.getLineLength(1)); + assertEquals("\n", t.getLineDelimiter(1)); + assertEquals(6, t.getLineOffset(2)); + assertEquals(3, t.getLineLength(2)); + assertNull(t.getLineDelimiter(2)); + } + + @Test + public void replaceEntireContent() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef"); + t.replace(0, 7, "x\ny\nz"); + assertEquals(3, t.getNumberOfLines()); + assertEquals(0, t.getLineOffset(0)); + assertEquals(2, t.getLineLength(0)); + assertEquals(2, t.getLineOffset(1)); + assertEquals(2, t.getLineLength(1)); + assertEquals(4, t.getLineOffset(2)); + assertEquals(1, t.getLineLength(2)); + } + + @Test + public void computeNumberOfLines() { + ArrayLineTracker t = create(""); + assertEquals(0, t.computeNumberOfLines("")); + assertEquals(0, t.computeNumberOfLines("abc")); + assertEquals(1, t.computeNumberOfLines("abc\n")); + assertEquals(2, t.computeNumberOfLines("abc\ndef\n")); + assertEquals(1, t.computeNumberOfLines("\r\n")); + assertEquals(2, t.computeNumberOfLines("\r\n\r\n")); + } + + @Test + public void getNumberOfLinesRange() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + assertEquals(1, t.getNumberOfLines(0, 0)); + assertEquals(1, t.getNumberOfLines(0, 3)); + assertEquals(2, t.getNumberOfLines(0, 4)); + assertEquals(3, t.getNumberOfLines(0, 11)); + } + + @Test + public void lineInformationOfOffset() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + Line line = t.getLineInformationOfOffset(0); + assertEquals(0, line.offset); + assertEquals(3, line.length); + + line = t.getLineInformationOfOffset(5); + assertEquals(4, line.offset); + assertEquals(3, line.length); + } + + @Test + public void lineInformation() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + Line line = t.getLineInformation(0); + assertEquals(0, line.offset); + assertEquals(3, line.length); + + line = t.getLineInformation(1); + assertEquals(4, line.offset); + assertEquals(3, line.length); + + line = t.getLineInformation(2); + assertEquals(8, line.offset); + assertEquals(3, line.length); + } + + @Test + public void badOffsetThrows() { + ArrayLineTracker t = create("abc"); + assertThrows(BadLocationException.class, () -> t.getLineNumberOfOffset(-1)); + assertThrows(BadLocationException.class, () -> t.getLineNumberOfOffset(4)); + assertThrows(BadLocationException.class, () -> t.getLineOffset(-1)); + assertThrows(BadLocationException.class, () -> t.getLineOffset(2)); + } + + @Test + public void multipleSequentialReplacements() throws BadLocationException { + ArrayLineTracker t = create("abc\ndef\nghi"); + // Insert "X" at offset 4 → "abc\nXdef\nghi" + t.replace(4, 0, "X"); + assertEquals(3, t.getNumberOfLines()); + assertEquals(4, t.getLineOffset(1)); + // Insert "\n" at offset 5 → "abc\nX\ndef\nghi" + t.replace(5, 0, "\n"); + assertEquals(4, t.getNumberOfLines()); + assertEquals(4, t.getLineOffset(1)); + assertEquals(6, t.getLineOffset(2)); + assertEquals(10, t.getLineOffset(3)); + } + + private static ArrayLineTracker create(String text) { + ArrayLineTracker t = new ArrayLineTracker(); + t.set(text); + return t; + } +} From ab58dc7e441af1bfb42c21753fc73d7bfb5fe0b4 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 15:35:01 +0200 Subject: [PATCH 08/18] Reduce TextDocument.update allocation with persistent StringBuilder MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use a persistent StringBuilder buffer for incremental text updates instead of creating a new one on every edit. Lazy toString() caching defers String materialization until getText() is actually called. - Persistent textBuffer: eliminates ~2.7 GB of StringBuilder allocations - Lazy cachedText: halves toString() calls (114 → 51 per 30s session) - GC events reduced from 77 to 52 (-32%) - TextDocument.update no longer the #1 allocator Co-Authored-By: Claude Opus 4.6 --- .../eclipse/lemminx/commons/TextDocument.java | 48 ++++++++++++++----- 1 file changed, 37 insertions(+), 11 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java index bc62642de..9e37b847c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java @@ -39,6 +39,10 @@ public class TextDocument extends TextDocumentItem { private boolean incremental; + private StringBuilder textBuffer; + + private String cachedText; + public TextDocument(TextDocumentItem document) { this(document.getText(), document.getUri()); super.setVersion(document.getVersion()); @@ -50,6 +54,30 @@ public TextDocument(String text, String uri) { super.setText(text); } + @Override + public String getText() { + synchronized (lock) { + if (cachedText != null) { + return cachedText; + } + if (textBuffer != null) { + cachedText = textBuffer.toString(); + super.setText(cachedText); + return cachedText; + } + } + return super.getText(); + } + + @Override + public void setText(String text) { + synchronized (lock) { + super.setText(text); + textBuffer = null; + cachedText = null; + } + } + public void setIncremental(boolean incremental) { this.incremental = incremental; // reset line tracker @@ -74,7 +102,7 @@ public int offsetAt(Position position) throws BadLocationException { public String lineText(int lineNumber) throws BadLocationException { ILineTracker lineTracker = getLineTracker(); Line line = lineTracker.getLineInformation(lineNumber); - String text = super.getText(); + String text = getText(); return text.substring(line.offset, line.offset + line.length); } @@ -115,7 +143,7 @@ public Range getWordRangeAt(int textOffset, Pattern wordDefinition) { Position pos = positionAt(textOffset); ILineTracker lineTracker = getLineTracker(); Line line = lineTracker.getLineInformation(pos.getLine()); - String text = super.getText(); + String text = getText(); String lineText = text.substring(line.offset, textOffset); int position = lineText.length(); Matcher m = wordDefinition.matcher(lineText); @@ -149,7 +177,7 @@ private synchronized ILineTracker createLineTracker() { return lineTracker; } ILineTracker lineTracker = isIncremental() ? new ArrayLineTracker() : new ListLineTracker(); - lineTracker.set(super.getText()); + lineTracker.set(getText()); return lineTracker; } @@ -168,10 +196,10 @@ public void update(List changes) { try { long start = System.currentTimeMillis(); synchronized (lock) { - // Initialize buffer and line tracker from the current text document - StringBuilder buffer = new StringBuilder(getText()); + if (textBuffer == null) { + textBuffer = new StringBuilder(getText()); + } - // Loop for each changes and update the buffer for (int i = 0; i < changes.size(); i++) { TextDocumentContentChangeEvent changeEvent = changes.get(i); @@ -182,17 +210,15 @@ public void update(List changes) { Integer rangeLength = changeEvent.getRangeLength(); length = rangeLength != null ? rangeLength.intValue() : offsetAt(range.getEnd()) - offsetAt(range.getStart()); } else { - // range is optional and if not given, the whole file content is replaced - length = buffer.length(); + length = textBuffer.length(); range = new Range(positionAt(0), positionAt(length)); } String text = changeEvent.getText(); int startOffset = offsetAt(range.getStart()); - buffer.replace(startOffset, startOffset + length, text); + textBuffer.replace(startOffset, startOffset + length, text); lineTracker.replace(startOffset, length, text); } - // Update the new text content from the updated buffer - setText(buffer.toString()); + cachedText = null; } LOGGER.fine("Text document content updated in " + (System.currentTimeMillis() - start) + "ms"); } catch (BadLocationException e) { From 598b50d1bac79eb965c401a96f99ca64c744d911 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 21:13:47 +0200 Subject: [PATCH 09/18] Migrate getText() callers to CharSequence to eliminate toString() copies MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace getText() with getTextSequence() across 44 files so the parser, formatter, completions, and extensions read the StringBuilder directly via CharSequence — zero-copy during rapid typing. Only callers that need String for external APIs (Xerces InputSource, DOMParser.parse(String)) retain getText(). Also replace regex-based #region detection in XMLFoldings with char-by-char scanning. JFR profiling confirms LemMinX allocations dropped out of the top allocators entirely (0 GC events in 30s vs 77 before optimizations). Co-Authored-By: Claude Opus 4.6 --- .../relaxng/pattern/CMRelaxNGDocument.java | 2 +- .../eclipse/lemminx/commons/TextDocument.java | 13 +++++ .../lemminx/commons/TextEditUtils.java | 8 +-- .../java/org/eclipse/lemminx/dom/DOMAttr.java | 4 +- .../eclipse/lemminx/dom/DOMCharacterData.java | 2 +- .../org/eclipse/lemminx/dom/DOMDocument.java | 16 ++++-- .../eclipse/lemminx/dom/DOMDocumentType.java | 2 +- .../org/eclipse/lemminx/dom/DOMElement.java | 4 +- .../org/eclipse/lemminx/dom/DOMParser.java | 4 +- .../java/org/eclipse/lemminx/dom/DOMText.java | 2 +- .../eclipse/lemminx/dom/DTDElementDecl.java | 6 +-- .../lemminx/dom/green/GreenTreeBuilder.java | 6 +-- .../lemminx/dom/green/IncrementalParser.java | 6 +-- .../lemminx/dom/parser/MultiLineStream.java | 10 ++-- .../lemminx/dom/parser/XMLScanner.java | 18 +++---- .../ContentModelCompletionParticipant.java | 4 +- .../participants/XMLSyntaxErrorCode.java | 6 +-- .../codeactions/CloseTagCodeAction.java | 10 ++-- .../DownloadDisabledResourceCodeAction.java | 2 +- .../EntityNotDeclaredCodeAction.java | 2 +- .../FixMissingSpaceCodeAction.java | 3 +- ...MLCloseTagInlineCompletionParticipant.java | 4 +- .../FilePathCompletionParticipant.java | 2 +- .../FilePathCompletionResult.java | 6 +-- .../minify/XMLMinifierDocument.java | 8 +-- .../references/search/SearchNode.java | 12 ++--- .../references/search/SearchNodeFactory.java | 4 +- .../lemminx/services/XMLCompletions.java | 46 ++++++++--------- .../eclipse/lemminx/services/XMLFoldings.java | 49 +++++++++++++++---- .../lemminx/services/XMLFormatter.java | 4 +- .../eclipse/lemminx/services/XMLHover.java | 2 +- .../lemminx/services/XMLLanguageService.java | 2 +- .../eclipse/lemminx/services/XMLMinifier.java | 4 +- .../services/format/DOMCDATAFormatter.java | 2 +- .../services/format/DOMCommentFormatter.java | 2 +- .../services/format/DOMDocTypeFormatter.java | 6 +-- .../services/format/DOMElementFormatter.java | 4 +- .../services/format/DOMTextFormatter.java | 4 +- .../services/format/XMLFormatterDocument.java | 28 ++++++----- .../format/XMLFormatterDocumentOld.java | 9 ++-- .../snippets/SnippetContextUtils.java | 4 +- .../eclipse/lemminx/utils/StringUtils.java | 12 ++--- .../eclipse/lemminx/utils/TextEditUtils.java | 2 +- .../lemminx/utils/XMLPositionUtility.java | 14 +++--- 44 files changed, 207 insertions(+), 153 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/com/thaiopensource/relaxng/pattern/CMRelaxNGDocument.java b/org.eclipse.lemminx/src/main/java/com/thaiopensource/relaxng/pattern/CMRelaxNGDocument.java index 7441050f2..c077453b8 100644 --- a/org.eclipse.lemminx/src/main/java/com/thaiopensource/relaxng/pattern/CMRelaxNGDocument.java +++ b/org.eclipse.lemminx/src/main/java/com/thaiopensource/relaxng/pattern/CMRelaxNGDocument.java @@ -317,6 +317,6 @@ DOMNode findNodeAt(Locator locator) { private static String getTextContent(DOMElement element) { int start = element.getStartTagCloseOffset() + 1; int end = element.getEndTagOpenOffset(); - return element.getOwnerDocument().getText().substring(start, end); + return element.getOwnerDocument().getTextSequence().subSequence(start, end).toString(); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java index 9e37b847c..372a12485 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java @@ -54,6 +54,10 @@ public TextDocument(String text, String uri) { super.setText(text); } + /** + * Returns the text content as a {@link String}. Prefer + * {@link #getTextSequence()} which avoids costly string materialization. + */ @Override public String getText() { synchronized (lock) { @@ -69,6 +73,15 @@ public String getText() { return super.getText(); } + public CharSequence getTextSequence() { + synchronized (lock) { + if (textBuffer != null) { + return textBuffer; + } + } + return getText(); + } + @Override public void setText(String text) { synchronized (lock) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextEditUtils.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextEditUtils.java index d21b703a1..ea61a98d8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextEditUtils.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextEditUtils.java @@ -64,7 +64,7 @@ public static List> toEitherTextEdits(List edits) throws BadLocationException { - String text = document.getText(); + CharSequence text = document.getTextSequence(); Collections.sort(edits /* .map(getWellformedEdit) */, (a, b) -> { int diff = a.getRange().getStart().getLine() - b.getRange().getStart().getLine(); if (diff == 0) { @@ -155,7 +155,7 @@ public static String applyEdits(TextDocument document, List * @return the offset of the first whitespace that's found in the given range * [leftLimit,to] from the left of the to, and leftLimit otherwise. */ - public static int adjustOffsetWithLeftWhitespaces(int leftLimit, int to, String text) { + public static int adjustOffsetWithLeftWhitespaces(int leftLimit, int to, CharSequence text) { if (to == 0) { return -1; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java index 19c5419e4..1ba927f61 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java @@ -90,7 +90,7 @@ public String getName() { // Memory optimization: Extract name from document instead of caching if (nameStart != NULL_VALUE && nameEnd != NULL_VALUE) { // Name is in the document, extract it - return getOwnerDocument().getText().substring(nameStart, nameEnd); + return getOwnerDocument().getTextSequence().subSequence(nameStart, nameEnd).toString(); } // Name was set programmatically or doesn't exist return name; @@ -228,7 +228,7 @@ public boolean hasDelimiter() { public String getOriginalValue() { // Memory optimization: Extract from document instead of caching if (valueStart != NULL_VALUE && delimiter < valueStart) { - return getOwnerDocument().getText().substring(valueStart, valueEnd); + return getOwnerDocument().getTextSequence().subSequence(valueStart, valueEnd).toString(); } return value; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java index 564e53ec2..5ca564348 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMCharacterData.java @@ -131,7 +131,7 @@ public int getEndContent() { public String getData() { // No caching - extract directly from document to save memory // The document text is already in memory, so this is just a substring operation - return getOwnerDocument().getText().substring(getStartContent(), getEndContent()); + return getOwnerDocument().getTextSequence().subSequence(getStartContent(), getEndContent()).toString(); } /* diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java index ad33b1fee..a1e069e73 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java @@ -69,7 +69,7 @@ public class DOMDocument extends DOMNode implements Document { private volatile GreenDocument greenDocument; public DOMDocument(TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager) { - super(0, textDocument.getText().length()); + super(0, textDocument.getTextSequence().length()); this.textDocument = textDocument; this.resolverExtensionManager = resolverExtensionManager; resetGrammar(); @@ -142,14 +142,22 @@ public String getNamespaceURI() { } /** - * Returns the text content of the XML document. - * - * @return the text content of the XML document. + * Returns the text content as a {@link String}. Prefer + * {@link #getTextSequence()} which avoids costly string materialization. */ public String getText() { return textDocument.getText(); } + /** + * Returns the text content as a {@link CharSequence}, avoiding the + * allocation of a full {@link String} copy when the document is backed + * by a {@link StringBuilder}. + */ + public CharSequence getTextSequence() { + return textDocument.getTextSequence(); + } + public TextDocument getTextDocument() { return textDocument; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java index 25e0bf33c..0a53a3fa8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java @@ -47,7 +47,7 @@ public DOMDocumentType getOwnerDocType() { @Override public String getTextContent() { if (content == null) { - content = getOwnerDocument().getText().substring(getStart(), getEnd()); + content = getOwnerDocument().getTextSequence().subSequence(getStart(), getEnd()).toString(); } return content; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index 6f02007be..7da58aace 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -252,7 +252,7 @@ void setSelfClosed(boolean selfClosed) { * position after the character you want to start at. */ public Integer endsWith(char c, int startOffset) { - String text = this.getOwnerDocument().getText(); + CharSequence text = this.getOwnerDocument().getTextSequence(); if (startOffset > text.length() || startOffset < 0) { return null; } @@ -461,7 +461,7 @@ public boolean isOrphanEndTagOf(String tagName) { * with an angle bracket */ public int getUnclosedStartTagCloseOffset() { - String documentText = getOwnerDocument().getText(); + CharSequence documentText = getOwnerDocument().getTextSequence(); int i = getStart() + 1; for (; i < documentText.length() && documentText.charAt(i) != '/' && documentText.charAt(i) != '<'; i++) { } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java index 274a0f8b3..b0aaef526 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java @@ -60,7 +60,7 @@ public DOMDocument parse(TextDocument document, URIResolverExtensionManager reso public DOMDocument parse(TextDocument document, URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent, CancelChecker monitor) { - String text = document.getText(); + CharSequence text = document.getTextSequence(); String uri = document.getUri(); GreenDocument greenDoc = GreenTreeBuilder.parse(text, uri, monitor); return buildDocument(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent, monitor); @@ -70,7 +70,7 @@ public DOMDocument parseIncremental(TextDocument document, GreenDocument previousGreenDoc, int editStart, int deleteLength, int insertLength, URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent, CancelChecker monitor) { - String text = document.getText(); + CharSequence text = document.getTextSequence(); String uri = document.getUri(); GreenDocument greenDoc = IncrementalParser.incrementalParse( previousGreenDoc, text, editStart, deleteLength, insertLength, uri, monitor); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMText.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMText.java index ba408bc89..618f1befe 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMText.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMText.java @@ -62,7 +62,7 @@ public String getWholeText() { */ @Override public boolean isElementContentWhitespace() { - String text = getOwnerDocument().getOwnerDocument().getText(); + CharSequence text = getOwnerDocument().getOwnerDocument().getTextSequence(); return StringUtils.isWhitespace(text, getStart(), getEnd()); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDElementDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDElementDecl.java index a6f78d6d1..74df5eaa1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDElementDecl.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDElementDecl.java @@ -101,7 +101,7 @@ public DTDDeclParameter getParameterAt(int offset) { return null; } // We are after the wordStart offset and ends at wordEnd * matches the given searchName */ - private static boolean isMatchName(String searchWord, String text, int wordStart, int wordEnd) { + private static boolean isMatchName(String searchWord, CharSequence text, int wordStart, int wordEnd) { int length = wordEnd - wordStart; if (searchWord.length() != length) { return false; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index 55600cd8a..25f96d973 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -43,11 +43,11 @@ private GreenTreeBuilder() { * @param monitor optional cancel checker * @return the root green document node */ - public static GreenDocument parse(String text, String uri, CancelChecker monitor) { + public static GreenDocument parse(CharSequence text, String uri, CancelChecker monitor) { return parseRange(text, uri, 0, text.length(), monitor); } - public static GreenDocument parseRange(String text, String uri, + public static GreenDocument parseRange(CharSequence text, String uri, int rangeStart, int rangeEnd, CancelChecker monitor) { boolean isDTD = DOMUtils.isDTD(uri); Scanner scanner = XMLScanner.createScanner(text, rangeStart, isDTD); @@ -863,7 +863,7 @@ private static boolean hasMatchingElement(Deque stack, String tag) return false; } - private static boolean containsNewline(String text, int from, int to) { + private static boolean containsNewline(CharSequence text, int from, int to) { for (int i = from; i < to; i++) { char c = text.charAt(i); if (c == '\n' || c == '\r') { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java index ec0d3dfc5..32c33de6c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java @@ -50,7 +50,7 @@ private IncrementalParser() { * @return a new GreenDocument (never null) */ public static GreenDocument incrementalParse(GreenDocument oldDoc, - String newText, int editStart, int deleteLength, int insertLength, + CharSequence newText, int editStart, int deleteLength, int insertLength, String uri, CancelChecker monitor) { int delta = insertLength - deleteLength; int editEnd = editStart + deleteLength; @@ -68,7 +68,7 @@ public static GreenDocument incrementalParse(GreenDocument oldDoc, private static GreenNode[] tryIncrementalOnChildren( GreenNode[] oldChildren, int childrenAbsStart, int childrenAreaWidth, int editStart, int editEnd, int delta, - String newText, String uri, CancelChecker monitor) { + CharSequence newText, String uri, CancelChecker monitor) { if (oldChildren.length == 0) { return null; @@ -155,7 +155,7 @@ private static GreenNode[] tryIncrementalOnChildren( private static GreenElement tryDescentIntoElement( GreenElement elem, int elemAbsStart, int editStart, int editEnd, int delta, - String newText, String uri, CancelChecker monitor) { + CharSequence newText, String uri, CancelChecker monitor) { int csr = elem.childrenStartRel(); int childrenAbsStart = elemAbsStart + csr; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/MultiLineStream.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/MultiLineStream.java index 4af050409..eeb317026 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/MultiLineStream.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/MultiLineStream.java @@ -43,12 +43,12 @@ public class MultiLineStream { return ch == _WSP || ch == _TAB || ch == _NWL || ch == _LFD || ch == _CAR; }; - private final String source; + private final CharSequence source; private final int len; private int position; private final Map regexpCache; - public MultiLineStream(String source, int position) { + public MultiLineStream(CharSequence source, int position) { this.source = source; this.len = source.length(); this.position = position; @@ -59,7 +59,7 @@ public boolean eos() { return this.len <= this.position; } - public String getSource() { + public CharSequence getSource() { return this.source; } @@ -103,7 +103,7 @@ public int peekChar(int n) { if (pos >= len) { return -1; } - return this.source.codePointAt(pos); + return Character.codePointAt(this.source, pos); } /** @@ -115,7 +115,7 @@ public int peekCharAtOffset(int offset) { if (offset >= len || offset < 0) { return -1; } - return this.source.codePointAt(offset); + return Character.codePointAt(this.source, offset); } public boolean advanceIfChar(int ch) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/XMLScanner.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/XMLScanner.java index 377c42bcf..6afb42615 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/XMLScanner.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/parser/XMLScanner.java @@ -139,7 +139,7 @@ public class XMLScanner implements Scanner { boolean isInitialAttlistDeclCompleted = false; private int nbBraceOpened; - public XMLScanner(String input, int initialOffset, ScannerState initialState, boolean isDTDFile) { + public XMLScanner(CharSequence input, int initialOffset, ScannerState initialState, boolean isDTDFile) { stream = new MultiLineStream(input, initialOffset); state = initialState; tokenOffset = 0; @@ -1031,7 +1031,7 @@ public int getTokenEnd() { @Override public String getTokenText() { - return stream.getSource().substring(tokenOffset, stream.pos()); + return stream.getSource().subSequence(tokenOffset, stream.pos()).toString(); } @Override @@ -1050,31 +1050,31 @@ public String getTokenError() { } public String getTokenTextFromOffset(int offset) { - return stream.getSource().substring(offset, stream.pos()); + return stream.getSource().subSequence(offset, stream.pos()).toString(); } - public static Scanner createScanner(String input) { + public static Scanner createScanner(CharSequence input) { return createScanner(input, false); } - public static Scanner createScanner(String input, boolean isDTD) { + public static Scanner createScanner(CharSequence input, boolean isDTD) { return createScanner(input, 0, isDTD); } - public static Scanner createScanner(String input, int initialOffset) { + public static Scanner createScanner(CharSequence input, int initialOffset) { return createScanner(input, initialOffset, false); } - public static Scanner createScanner(String input, int initialOffset, boolean isDTDFile) { + public static Scanner createScanner(CharSequence input, int initialOffset, boolean isDTDFile) { return createScanner(input, initialOffset, isDTDFile ? ScannerState.DTDWithinContent : ScannerState.WithinContent, isDTDFile); } - public static Scanner createScanner(String input, int initialOffset, ScannerState initialState) { + public static Scanner createScanner(CharSequence input, int initialOffset, ScannerState initialState) { return new XMLScanner(input, initialOffset, initialState, false); } - public static Scanner createScanner(String input, int initialOffset, ScannerState initialState, boolean isDTDFile) { + public static Scanner createScanner(CharSequence input, int initialOffset, ScannerState initialState, boolean isDTDFile) { return new XMLScanner(input, initialOffset, initialState, isDTDFile); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/ContentModelCompletionParticipant.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/ContentModelCompletionParticipant.java index fcb689172..a21df0df2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/ContentModelCompletionParticipant.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/ContentModelCompletionParticipant.java @@ -240,7 +240,7 @@ private static void addTagName(NodeList list, Set tags, ICompletionReque CompletionItem item = new CompletionItem(tagName); item.setKind(CompletionItemKind.Property); item.setFilterText(request.getFilterForStartTagName(tagName)); - String xml = elt.getOwnerDocument().getText().substring(elt.getStart(), elt.getEnd()); + String xml = elt.getOwnerDocument().getTextSequence().subSequence(elt.getStart(), elt.getEnd()).toString(); item.setTextEdit(Either.forLeft(new TextEdit(request.getReplaceRange(), xml))); response.addCompletionItem(item); tags.add(item.getLabel()); @@ -456,7 +456,7 @@ public void onXMLContent(ICompletionRequest request, ICompletionResponse respons end = document.positionAt(endOffset); } int completionOffset = request.getOffset(); - String tokenStart = StringUtils.getWhitespaces(document.getText(), startOffset, + String tokenStart = StringUtils.getWhitespaces(document.getTextSequence(), startOffset, completionOffset); Range fullRange = new Range(start, end); values.forEach(value -> { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java index 13fd86b95..49ebc68b7 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java @@ -191,7 +191,7 @@ public static Range toLSPRange(XMLLocator location, XMLSyntaxErrorCode code, Obj * * = text.length()) { return text.length(); @@ -369,7 +369,7 @@ private static int removeLeftSpaces(final int initialOffset, String text) { * @return the proper range from the given node to the given offset. */ private static Range getRangeFromStartNodeToOffset(DOMNode fromNode, int toOffset, DOMDocument document) { - int endOffset = removeLeftSpaces(toOffset, document.getText()); + int endOffset = removeLeftSpaces(toOffset, document.getTextSequence()); int startOffset = fromNode.getStart(); if (fromNode.isElement()) { // The from node is a DOM element, adjust end and start offset diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/CloseTagCodeAction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/CloseTagCodeAction.java index 7626fdb51..a304ca0bc 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/CloseTagCodeAction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/CloseTagCodeAction.java @@ -98,7 +98,7 @@ private void doCodeActionsForEndTagUnclosed(DOMElement element, DOMDocument docu private void doCodeActionsForStartTagUnclosed(DOMElement element, DOMDocument document, Range diagnosticRange, Diagnostic diagnostic, List codeActions) throws BadLocationException { // Here start tag element is not closed with '>'. - String text = document.getText(); + CharSequence text = document.getTextSequence(); int closeAngleBracketOffset = element.getUnclosedStartTagCloseOffset(); final Position closeAngleBracketPosition = document.positionAt(closeAngleBracketOffset); if (!element.hasEndTag()) { @@ -150,7 +150,7 @@ private void doCodeActionsForStartTagUnclosed(DOMElement element, DOMDocument do private void doCodeActionsForStartTagClosed(DOMElement element, DOMDocument document, Range diagnosticRange, Diagnostic diagnostic, List codeActions) throws BadLocationException { // Here start tag element is closed with '>'. - String text = document.getText(); + CharSequence text = document.getTextSequence(); if (!element.hasEndTag()) { // The element has no an end tag // ex : @@ -261,10 +261,10 @@ private static CodeAction insertGreaterThanCharacterCodeAction(DOMDocument docum */ private static CodeAction removeTagCodeAction(DOMElement element, DOMDocument document, Diagnostic diagnostic) throws BadLocationException { - String text = document.getText(); + CharSequence text = document.getTextSequence(); Position startPosition = document.positionAt(element.getStart()); Position endPosition = document.positionAt(element.getEnd()); - String contentToRemove = text.substring(element.getStart(), element.getEnd()); + String contentToRemove = text.subSequence(element.getStart(), element.getEnd()).toString(); CodeAction removeAction = CodeActionFactory.remove("Remove '" + contentToRemove + "'", new Range(startPosition, endPosition), document.getTextDocument(), diagnostic); return removeAction; @@ -316,7 +316,7 @@ private static boolean hasElements(DOMElement element) { return false; } - private static boolean isCharAt(String text, int offset, char ch) { + private static boolean isCharAt(CharSequence text, int offset, char ch) { if (text.length() <= offset) { return false; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/DownloadDisabledResourceCodeAction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/DownloadDisabledResourceCodeAction.java index ae19c8d74..7de3ca24f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/DownloadDisabledResourceCodeAction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/DownloadDisabledResourceCodeAction.java @@ -53,7 +53,7 @@ public void doCodeAction(ICodeActionRequest request, List codeAction Range diagnosticRange = diagnostic.getRange(); int start = document.offsetAt(diagnosticRange.getStart()); int end = document.offsetAt(diagnosticRange.getEnd()); - String url = document.getText().substring(start, end); + String url = document.getTextSequence().subSequence(start, end).toString(); String title = MessageFormat.format(FORCE_DOWNLOAD_TITLE, url); CodeAction codeAction = new CodeAction(title); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/EntityNotDeclaredCodeAction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/EntityNotDeclaredCodeAction.java index 51c1bce87..7c1854009 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/EntityNotDeclaredCodeAction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/EntityNotDeclaredCodeAction.java @@ -225,7 +225,7 @@ private Position getEntityInsertPosition(DOMDocument document) throws BadLocatio */ private static String getEntityName(Diagnostic diagnostic, DOMDocument doc) throws BadLocationException { Range range = diagnostic.getRange(); - String name = doc.getText().substring(doc.offsetAt(range.getStart()), doc.offsetAt(range.getEnd())); + String name = doc.getTextSequence().subSequence(doc.offsetAt(range.getStart()), doc.offsetAt(range.getEnd())).toString(); String removedAmpAndSemiColon = name.substring(1, name.length() - 1); String message = DiagnosticUtils.getDiagnosticMessage(diagnostic); if (!message.contains("\"" + removedAmpAndSemiColon + "\"")) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/FixMissingSpaceCodeAction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/FixMissingSpaceCodeAction.java index 238efe0f0..6c951c772 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/FixMissingSpaceCodeAction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/codeactions/FixMissingSpaceCodeAction.java @@ -35,8 +35,7 @@ public void doCodeAction(ICodeActionRequest request, List codeAction try { int startOffset = document.offsetAt(diagnosticRange.getStart()); int endOffset = document.offsetAt(diagnosticRange.getEnd()); - String text = document.getText(); - String value = text.substring(startOffset, endOffset); + String value = document.getTextSequence().subSequence(startOffset, endOffset).toString(); codeActions.add(CodeActionFactory.insert("Add space after '" + value + "'", diagnosticRange.getEnd(), " ", document.getTextDocument(), diagnostic)); } catch (BadLocationException | IndexOutOfBoundsException e) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/core/participants/inlinecompletion/XMLCloseTagInlineCompletionParticipant.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/core/participants/inlinecompletion/XMLCloseTagInlineCompletionParticipant.java index 9bbc68bff..aac8e530f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/core/participants/inlinecompletion/XMLCloseTagInlineCompletionParticipant.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/core/participants/inlinecompletion/XMLCloseTagInlineCompletionParticipant.java @@ -49,9 +49,9 @@ public void onInlineCompletion(IInlineCompletionRequest request, IInlineCompleti } // Check if the cursor is at a position where we should suggest a closing tag - String text = document.getText(); + CharSequence text = document.getTextSequence(); if (offset > 0 && offset <= text.length()) { - int charBefore = text.codePointAt(offset - 1); + int charBefore = Character.codePointAt(text, offset - 1); // Suggest closing tag after '>' or after content if (charBefore == _RAN || Character.isLetterOrDigit(charBefore) || Character.isWhitespace(charBefore)) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionParticipant.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionParticipant.java index 9aed9f3b6..e3d60ae0b 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionParticipant.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionParticipant.java @@ -216,7 +216,7 @@ private static void addFileCompletionItems(DOMDocument xmlDocument, int startOff // ex: // base dir is equals for instance to C://path/to Character separator = expression != null ? expression.getSeparator() : null; - FilePathCompletionResult result = FilePathCompletionResult.create(xmlDocument.getText(), + FilePathCompletionResult result = FilePathCompletionResult.create(xmlDocument.getTextSequence(), xmlDocument.getDocumentURI(), startOffset, endOffset, completionOffset, separator); Path baseDir = result.getBaseDir(); if (baseDir == null) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionResult.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionResult.java index 174e55b8b..ece5936b8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionResult.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/filepath/participants/FilePathCompletionResult.java @@ -88,7 +88,7 @@ public Path getBaseDir() { * otherwise. * @return the file path completion result. */ - public static FilePathCompletionResult create(String content, String fileUri, int startNodeOffset, + public static FilePathCompletionResult create(CharSequence content, String fileUri, int startNodeOffset, int endNodeOffset, int completionOffset, Character separator) { boolean isMultiFilePath = separator != null; Predicate isStartValidChar = isStartValidCharForSimplePath; @@ -118,10 +118,10 @@ public static FilePathCompletionResult create(String content, String fileUri, in return new FilePathCompletionResult(startPathOffset, endPathOffset, baseDir); } - private static Path getBaseDir(String content, String fileUri, int start, int end) { + private static Path getBaseDir(CharSequence content, String fileUri, int start, int end) { if (end > start) { // ex : - String basePath = content.substring(start, end); + String basePath = content.subSequence(start, end).toString(); if (!hasPathBeginning(basePath)) { // Try to returns the absolute path // Ex basePath= diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/minify/XMLMinifierDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/minify/XMLMinifierDocument.java index b10bd2d65..5444ecdfe 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/minify/XMLMinifierDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/minify/XMLMinifierDocument.java @@ -81,7 +81,7 @@ public List minify() throws BadLocationException { public List minify(DOMDocument document, int start, int end) { // Pre-allocate list capacity based on document size - int estimatedCapacity = Math.min(textDocument.getText().length() / 100, 10000); + int estimatedCapacity = Math.min(textDocument.getTextSequence().length() / 100, 10000); List edits = new ArrayList<>(estimatedCapacity); // Get initial document region @@ -302,7 +302,7 @@ private void minifyAttributes(List edits, DOMElement element) { if (afterElementName < beforeFirstAttr) { int length = beforeFirstAttr - afterElementName; - if (StringUtils.isWhitespace(textDocument.getText(), afterElementName, beforeFirstAttr) && length > 1) { + if (StringUtils.isWhitespace(textDocument.getTextSequence(), afterElementName, beforeFirstAttr) && length > 1) { // Replace multiple spaces with single space try { Range range = new Range(textDocument.positionAt(afterElementName), @@ -325,7 +325,7 @@ private void minifyAttributes(List edits, DOMElement element) { if (afterAttr < beforeNextAttr) { int length = beforeNextAttr - afterAttr; - if (StringUtils.isWhitespace(textDocument.getText(), afterAttr, beforeNextAttr) && length > 1) { + if (StringUtils.isWhitespace(textDocument.getTextSequence(), afterAttr, beforeNextAttr) && length > 1) { // Replace multiple spaces with single space try { Range range = new Range(textDocument.positionAt(afterAttr), @@ -383,7 +383,7 @@ private void removeWhitespace(List edits, int start, int end) { if (start >= end) { return; } - if (StringUtils.isWhitespace(textDocument.getText(), start, end)) { + if (StringUtils.isWhitespace(textDocument.getTextSequence(), start, end)) { // Only whitespace, remove it removeContent(edits, start, end); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNode.java index 6b16adb4d..d9a0e988c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNode.java @@ -99,7 +99,7 @@ public String getValue(String forcedPrefix) { if (forcedPrefix != null) { value.append(forcedPrefix); } - String text = getOwnerDocument().getText(); + CharSequence text = getOwnerDocument().getTextSequence(); for (int i = getStart(); i < getEnd(); i++) { value.append(text.charAt(i)); } @@ -122,7 +122,7 @@ public String getPrefix() { public boolean matchesValue(SearchNode searchNode) { int fromStart = getStart(); int fromEnd = getEnd(); - String fromText = getOwnerDocument().getText(); + CharSequence fromText = getOwnerDocument().getTextSequence(); if (direction == Direction.FROM) { int adjust = adjustWithPrefix(this); if (adjust == -1) { @@ -132,7 +132,7 @@ public boolean matchesValue(SearchNode searchNode) { } int toStart = searchNode.getStart(); int toEnd = searchNode.getEnd(); - String toText = searchNode.getOwnerDocument().getText(); + CharSequence toText = searchNode.getOwnerDocument().getTextSequence(); if (direction == Direction.TO) { int adjust = adjustWithPrefix(searchNode); if (adjust == -1) { @@ -270,7 +270,7 @@ private boolean isValidPrefix() { if (prefix.length() > (end - start)) { return false; } - String text = node.getOwnerDocument().getText(); + CharSequence text = node.getOwnerDocument().getTextSequence(); for (int i = 0; i < prefix.length(); i++) { if (text.charAt(start + i) != prefix.charAt(i)) { return false; @@ -282,8 +282,8 @@ private boolean isValidPrefix() { @Override public String toString() { StringBuilder result = new StringBuilder(); - String text = node.getOwnerDocument().getText(); - result.append(text.substring(start, end)); + CharSequence text = node.getOwnerDocument().getTextSequence(); + result.append(text.subSequence(start, end)); result.append(direction == Direction.FROM ? " -->" : " <--"); return result.toString(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNodeFactory.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNodeFactory.java index d2fe34340..ad1a1550f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNodeFactory.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/references/search/SearchNodeFactory.java @@ -67,7 +67,7 @@ public static List findSearchNodes(DOMNode node, String prefix, bool } if (multiple) { - String text = node.getOwnerDocument().getText(); + CharSequence text = node.getOwnerDocument().getTextSequence(); List searchNodes = new ArrayList<>(); int itemStart = -1; for (int j = startNode; j < endNode; j++) { @@ -124,7 +124,7 @@ public static SearchNode getSearchNodeAt(DOMNode node, int offset, String prefix return null; } if (multiple) { - String text = node.getOwnerDocument().getText(); + CharSequence text = node.getOwnerDocument().getTextSequence(); if (offset != startNode) { int left = StringUtils.findStartWord(text, offset, startNode, NAME_PREDICATE); if (left != -1) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLCompletions.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLCompletions.java index f8ddb20bf..38c53650c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLCompletions.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLCompletions.java @@ -95,11 +95,11 @@ public CompletionList doComplete(DOMDocument xmlDocument, Position position, Sha return completionResponse; } - String text = xmlDocument.getText(); + CharSequence text = xmlDocument.getTextSequence(); int offset = completionRequest.getOffset(); DOMNode node = completionRequest.getNode(); try { - if (text.isEmpty()) { + if (text.length() == 0) { // When XML document is empty, try to collect root element (from file // association) collectInsideContent(completionRequest, completionResponse, cancelChecker); @@ -233,7 +233,7 @@ public CompletionList doComplete(DOMDocument xmlDocument, Position position, Sha case StartTagSelfClose: if (offset <= scanner.getTokenEnd()) { if (currentTag != null && currentTag.length() > 0 - && xmlDocument.getText().charAt(offset - 1) == '>') { // if the actual character + && xmlDocument.getTextSequence().charAt(offset - 1) == '>') { // if the actual character // typed // was // '>' @@ -358,7 +358,7 @@ public CompletionItem resolveCompletionItem(CompletionItem unresolved, DOMDocume */ private void collectSnippetSuggestions(CompletionRequest completionRequest, CompletionResponse completionResponse) { DOMDocument document = completionRequest.getXMLDocument(); - String text = document.getText(); + CharSequence text = document.getTextSequence(); int endExpr = completionRequest.getOffset(); // compute the from for search expression according to the node int fromSearchExpr = getExprLimitStart(completionRequest.getNode(), endExpr); @@ -407,7 +407,7 @@ private void collectSnippetSuggestions(CompletionRequest completionRequest, Comp } } - private static Integer getSuffixIndex(String text, String suffix, final int initOffset) { + private static Integer getSuffixIndex(CharSequence text, String suffix, final int initOffset) { int offset = initOffset; char ch = text.charAt(offset); // Try to search the first character which matches the suffix @@ -491,7 +491,7 @@ private static int getExprLimitStart(DOMNode currentNode, int offset) { return element.getStartTagCloseOffset() + 1; } - private static int getExprStart(String value, int from, int to) { + private static int getExprStart(CharSequence value, int from, int to) { if (to == 0) { return to; } @@ -556,8 +556,8 @@ public AutoCloseTagResponse doTagComplete(DOMDocument xmlDocument, Position posi if (offset <= 0) { return null; } - char c = xmlDocument.getText().charAt(offset - 1); - char cBefore = xmlDocument.getText().charAt(offset - 2); + char c = xmlDocument.getTextSequence().charAt(offset - 1); + char cBefore = xmlDocument.getTextSequence().charAt(offset - 2); String snippet = null; if (XMLPositionUtility.isInAttributeValue(xmlDocument, position)) { return null; @@ -598,7 +598,7 @@ public AutoCloseTagResponse doTagComplete(DOMDocument xmlDocument, Position posi return null; } } - String text = xmlDocument.getText(); + CharSequence text = xmlDocument.getTextSequence(); // After the slash is a close bracket boolean closeBracketAfterSlash = offset < text.length() ? text.charAt(offset) == '>' : false; @@ -684,7 +684,7 @@ private void collectOpenTagSuggestions(boolean hasOpenBracket, Range replaceRang CompletionRequest completionRequest, CompletionResponse completionResponse, CancelChecker cancelChecker) { try { DOMDocument document = completionRequest.getXMLDocument(); - String text = document.getText(); + CharSequence text = document.getTextSequence(); int tagNameEnd = document.offsetAt(replaceRange.getEnd()); int newOffset = getOffsetFollowedBy(text, tagNameEnd, ScannerState.WithinEndTag, TokenType.EndTagClose); if (newOffset != -1) { @@ -731,7 +731,7 @@ private void collectCloseTagSuggestions(int afterOpenBracket, boolean inOpenTag, CompletionRequest completionRequest, CompletionResponse completionResponse, CancelChecker cancelChecker) { try { Range range = getReplaceRange(afterOpenBracket, tagNameEnd, completionRequest); - String text = completionRequest.getXMLDocument().getText(); + CharSequence text = completionRequest.getXMLDocument().getTextSequence(); boolean hasCloseTag = isFollowedBy(text, tagNameEnd, ScannerState.WithinEndTag, TokenType.EndTagClose); collectCloseTagSuggestions(range, false, !hasCloseTag, inOpenTag, completionRequest, completionResponse); } catch (BadLocationException e) { @@ -742,7 +742,7 @@ private void collectCloseTagSuggestions(int afterOpenBracket, boolean inOpenTag, private void collectCloseTagSuggestions(Range range, boolean openEndTag, boolean closeEndTag, boolean inOpenTag, CompletionRequest completionRequest, CompletionResponse completionResponse) { try { - String text = completionRequest.getXMLDocument().getText(); + CharSequence text = completionRequest.getXMLDocument().getTextSequence(); DOMNode curr = completionRequest.getNode(); if (inOpenTag) { curr = curr.getParentNode(); // don't suggest the own tag, it's not yet open @@ -887,7 +887,7 @@ private void collectAttributeNameSuggestions(int nameStart, CompletionRequest co private void collectAttributeNameSuggestions(int nameStart, int nameEnd, CompletionRequest completionRequest, CompletionResponse completionResponse, CancelChecker cancelChecker) { int replaceEnd = completionRequest.getOffset(); - String text = completionRequest.getXMLDocument().getText(); + CharSequence text = completionRequest.getXMLDocument().getTextSequence(); while (replaceEnd < nameEnd && text.charAt(replaceEnd) != '<' && text.charAt(replaceEnd) != '?') { // < is a // valid // attribute @@ -928,7 +928,7 @@ private void collectAttributeValueSuggestions(int valueStart, int valueEnd, Comp boolean addQuotes = false; String valuePrefix; int offset = completionRequest.getOffset(); - String text = completionRequest.getXMLDocument().getText(); + CharSequence text = completionRequest.getXMLDocument().getTextSequence(); // Adjusts range to handle if quotations for the value exist if (offset > valueStart && offset <= valueEnd && StringUtils.isQuote(text.charAt(valueStart))) { @@ -940,13 +940,13 @@ private void collectAttributeValueSuggestions(int valueStart, int valueEnd, Comp valueContentEnd--; } valuePrefix = offset >= valueContentStart && offset <= valueContentEnd - ? text.substring(valueContentStart, offset) + ? text.subSequence(valueContentStart, offset).toString() : ""; valueStart = valueContentStart; valueEnd = valueContentEnd; addQuotes = false; } else { - valuePrefix = text.substring(valueStart, offset); + valuePrefix = text.subSequence(valueStart, offset).toString(); addQuotes = true; } @@ -992,11 +992,11 @@ private void collectAttributeValueSuggestions(int valueStart, int valueEnd, Comp private void collectDTDSystemIdSuggestions(int valueStart, int valueEnd, CompletionRequest completionRequest, CompletionResponse completionResponse, CancelChecker cancelChecker) { int offset = completionRequest.getOffset(); - String text = completionRequest.getXMLDocument().getText(); + CharSequence text = completionRequest.getXMLDocument().getTextSequence(); int valueContentStart = valueStart + 1; int valueContentEnd = valueEnd - 1; String valuePrefix = offset >= valueContentStart && offset <= valueContentEnd - ? text.substring(valueContentStart, offset) + ? text.subSequence(valueContentStart, offset).toString() : ""; Collection completionParticipants = getCompletionParticipants(); @@ -1046,7 +1046,7 @@ private Collection getCompletionParticipants() { return extensionsRegistry.getCompletionParticipants(); } - private static boolean isFollowedBy(String s, int offset, ScannerState intialState, TokenType expectedToken) { + private static boolean isFollowedBy(CharSequence s, int offset, ScannerState intialState, TokenType expectedToken) { return getOffsetFollowedBy(s, offset, intialState, expectedToken) != -1; } @@ -1060,7 +1060,7 @@ private static boolean isFollowedBy(String s, int offset, ScannerState intialSta * @param expectedToken * @return */ - public static int getOffsetFollowedBy(String s, int offset, ScannerState intialState, TokenType expectedToken) { + public static int getOffsetFollowedBy(CharSequence s, int offset, ScannerState intialState, TokenType expectedToken) { Scanner scanner = XMLScanner.createScanner(s, offset, intialState); TokenType token = scanner.scan(); while (token == TokenType.Whitespace) { @@ -1079,19 +1079,19 @@ private static Range getReplaceRange(int replaceStart, int replaceEnd, ICompleti return XMLPositionUtility.createRange(replaceStart, replaceEnd, document); } - private static String getLineIndent(int offset, String text) { + private static String getLineIndent(int offset, CharSequence text) { int start = offset; while (start > 0) { char ch = text.charAt(start - 1); if ("\n\r".indexOf(ch) >= 0) { - return text.substring(start, offset); + return text.subSequence(start, offset).toString(); } if (!isWhitespace(ch)) { return null; } start--; } - return text.substring(0, offset); + return text.subSequence(0, offset).toString(); } private boolean isEmptyElement(String tag) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFoldings.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFoldings.java index 65291bcfe..dfc738bc2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFoldings.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFoldings.java @@ -21,8 +21,6 @@ import java.util.Map.Entry; import java.util.logging.Level; import java.util.logging.Logger; -import java.util.regex.Matcher; -import java.util.regex.Pattern; import org.eclipse.lemminx.commons.BadLocationException; import org.eclipse.lemminx.commons.TextDocument; @@ -43,7 +41,6 @@ class XMLFoldings { private static Logger LOGGER = Logger.getLogger(XMLFoldings.class.getName()); private final XMLExtensionsRegistry extensionsRegistry; - private static final Pattern REGION_PATTERN = Pattern.compile("\\s*#(region\\b)|(endregion\\b)"); public XMLFoldings(XMLExtensionsRegistry extensionsRegistry) { this.extensionsRegistry = extensionsRegistry; @@ -63,10 +60,11 @@ public TagInfo(int startLine, String tagName) { public List getFoldingRanges(TextDocument document, XMLFoldingSettings context, CancelChecker cancelChecker) { - Scanner scanner = XMLScanner.createScanner(document.getText()); + CharSequence text = document.getTextSequence(); + Scanner scanner = XMLScanner.createScanner(text); TokenType token = scanner.scan(); // Pre-allocate capacity based on document size (estimate: 1 folding per 500 chars) - int estimatedCapacity = Math.min(document.getText().length() / 500, 1000); + int estimatedCapacity = Math.min(text.length() / 500, 1000); List ranges = new ArrayList<>(estimatedCapacity); // Pre-allocate stack capacity (estimate: max nesting depth of 50) @@ -124,10 +122,9 @@ public List getFoldingRanges(TextDocument document, XMLFoldingSett } case Comment: { int startLine = document.positionAt(scanner.getTokenOffset()).getLine(); - String text = scanner.getTokenText(); - Matcher m = REGION_PATTERN.matcher(text); - if (m.find()) { - if ("#region".equals(m.group().trim())) { // start pattern match + int regionKind = findRegionMarker(text, scanner.getTokenOffset(), scanner.getTokenOffset() + scanner.getTokenLength()); + if (regionKind != 0) { + if (regionKind == 1) { // #region stack.add(new TagInfo(startLine, "")); // empty tagName marks region } else { int i = stack.size() - 1; @@ -191,6 +188,40 @@ public List getFoldingRanges(TextDocument document, XMLFoldingSett return ranges; } + private static final char[] REGION = "#region".toCharArray(); + private static final char[] ENDREGION = "#endregion".toCharArray(); + + /** + * @return 1 for #region, 2 for #endregion, 0 if neither. + */ + private static int findRegionMarker(CharSequence text, int from, int to) { + int i = from; + while (i < to && Character.isWhitespace(text.charAt(i))) { + i++; + } + if (i < to && text.charAt(i) == '#') { + if (matches(text, i, to, REGION)) { + return 1; + } + if (matches(text, i, to, ENDREGION)) { + return 2; + } + } + return 0; + } + + private static boolean matches(CharSequence text, int offset, int limit, char[] word) { + if (offset + word.length > limit) { + return false; + } + for (int i = 0; i < word.length; i++) { + if (text.charAt(offset + i) != word[i]) { + return false; + } + } + return true; + } + private static boolean isIncludeClosingTagInFold(XMLFoldingSettings settings) { return settings.isIncludeClosingTagInFold(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFormatter.java index c9851e085..b1ecbc317 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLFormatter.java @@ -89,7 +89,7 @@ public List format(DOMDocument xmlDocument, Range range, Sha private boolean shouldMergeEdits(List edits, DOMDocument xmlDocument) { // Merge if there are many edits (> 1000) or if the document is large (> 100KB) int editCount = edits != null ? edits.size() : 0; - int documentSize = xmlDocument.getTextDocument().getText().length(); + int documentSize = xmlDocument.getTextDocument().getTextSequence().length(); return editCount > 1000 || documentSize > 100_000; } @@ -103,7 +103,7 @@ private boolean shouldMergeEdits(List edits, DOMDocument xml private Range getFullDocumentRange(DOMDocument xmlDocument) throws BadLocationException { TextDocument textDocument = xmlDocument.getTextDocument(); Position start = new Position(0, 0); - Position end = textDocument.positionAt(textDocument.getText().length()); + Position end = textDocument.positionAt(textDocument.getTextSequence().length()); return new Range(start, end); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLHover.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLHover.java index acacdb2a4..fdc606c42 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLHover.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLHover.java @@ -129,7 +129,7 @@ private Hover getTagHover(HoverRequest hoverRequest, Range tagRange, boolean ope } private Range getTagNameRange(TokenType tokenType, int startOffset, int offset, DOMDocument document) { - Scanner scanner = XMLScanner.createScanner(document.getText(), startOffset); + Scanner scanner = XMLScanner.createScanner(document.getTextSequence(), startOffset); TokenType token = scanner.scan(); while (token != TokenType.EOS && (scanner.getTokenEnd() < offset || scanner.getTokenEnd() == offset && token != tokenType)) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLLanguageService.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLLanguageService.java index ea71c25f7..92d5e185d 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLLanguageService.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLLanguageService.java @@ -337,7 +337,7 @@ public AutoCloseTagResponse doAutoClose(DOMDocument xmlDocument, Position positi XMLCompletionSettings completionSettings, CancelChecker cancelChecker) { try { int offset = xmlDocument.offsetAt(position); - String text = xmlDocument.getText(); + CharSequence text = xmlDocument.getTextSequence(); if (offset > 0) { char c = text.charAt(offset - 1); if (c == '>' || c == '/') { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLMinifier.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLMinifier.java index af1ba8571..5b82954d4 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLMinifier.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/XMLMinifier.java @@ -75,7 +75,7 @@ public List minify(DOMDocument xmlDocument, Range range, Sha private boolean shouldMergeEdits(List edits, DOMDocument xmlDocument) { // Merge if there are many edits (> 1000) or if the document is large (> 100KB) int editCount = edits != null ? edits.size() : 0; - int documentSize = xmlDocument.getTextDocument().getText().length(); + int documentSize = xmlDocument.getTextDocument().getTextSequence().length(); return editCount > 1000 || documentSize > 100_000; } @@ -89,7 +89,7 @@ private boolean shouldMergeEdits(List edits, DOMDocument xml private Range getFullDocumentRange(DOMDocument xmlDocument) throws BadLocationException { TextDocument textDocument = xmlDocument.getTextDocument(); Position start = new Position(0, 0); - Position end = textDocument.positionAt(textDocument.getText().length()); + Position end = textDocument.positionAt(textDocument.getTextSequence().length()); return new Range(start, end); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java index 2f05f8dd8..2d63718a4 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCDATAFormatter.java @@ -28,7 +28,7 @@ public DOMCDATAFormatter(XMLFormatterDocument formatterDocument) { public void formatCDATASection(DOMCDATASection cDATANode, XMLFormattingConstraints parentConstraints, List edits) { - String text = formatterDocument.getText(); + CharSequence text = formatterDocument.getTextSequence(); int start = cDATANode.getStart(); int leftWhitespaceOffset = start > 0 ? start - 1 : 0; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCommentFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCommentFormatter.java index 4492a2651..74287cdf8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCommentFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMCommentFormatter.java @@ -35,7 +35,7 @@ public void formatComment(DOMComment commentNode, XMLFormattingConstraints paren return; } - String text = formatterDocument.getText(); + CharSequence text = formatterDocument.getTextSequence(); int availableLineWidth = parentConstraints.getAvailableLineWidth(); int start = commentNode.getStart(); int leftWhitespaceOffset = start > 0 ? start - 1 : 0; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMDocTypeFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMDocTypeFormatter.java index 1b292e6b6..259c11669 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMDocTypeFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMDocTypeFormatter.java @@ -136,7 +136,7 @@ private void formatDTDNodeDecl(DTDDeclNode nodeDecl, XMLFormattingConstraints pa int nodeDeclStart = nodeDecl.getStart(); int indentLevel = parentConstraints.getIndentLevel(); int preservedNewLines = getPreservedNewlines(); - int currentNewLineCount = XMLFormatterDocument.getExistingNewLineCount(formatterDocument.getText(), + int currentNewLineCount = XMLFormatterDocument.getExistingNewLineCount(formatterDocument.getTextSequence(), nodeDeclStart, formatterDocument.getLineDelimiter()); if (currentNewLineCount > preservedNewLines) { // Reduce to number of new lines to the new line number specified by @@ -287,8 +287,8 @@ private static int getDocTypeIdEnd(DOMDocumentType docType) { private void replaceQuoteWithPreferred(DTDDeclNode nodeDecl, DTDDeclParameter parameter, List edits) { int paramStart = parameter.getStart(); int paramEnd = parameter.getEnd(); - if (StringUtils.isQuote(nodeDecl.getOwnerDocument().getText().charAt(paramStart)) - && StringUtils.isQuote(nodeDecl.getOwnerDocument().getText().charAt(paramEnd - 1))) { + if (StringUtils.isQuote(nodeDecl.getOwnerDocument().getTextSequence().charAt(paramStart)) + && StringUtils.isQuote(nodeDecl.getOwnerDocument().getTextSequence().charAt(paramEnd - 1))) { if (getEnforceQuoteStyle() == EnforceQuoteStyle.preferred) { formatterDocument.replaceQuoteWithPreferred(paramStart, paramStart + 1, edits); formatterDocument.replaceQuoteWithPreferred(paramEnd - 1, paramEnd, edits); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMElementFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMElementFormatter.java index ba6e58e0d..8904eaf30 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMElementFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMElementFormatter.java @@ -105,7 +105,7 @@ private int formatStartTagElement(DOMElement element, XMLFormattingConstraints p // after formatting: \n example text int parentStartCloseOffset = element.getParentElement() != null ? element.getParentElement().getStartTagCloseOffset() + 1 : 0; if ((parentStartCloseOffset != startTagOpenOffset - && StringUtils.isWhitespace(formatterDocument.getText(), parentStartCloseOffset, + && StringUtils.isWhitespace(formatterDocument.getTextSequence(), parentStartCloseOffset, startTagOpenOffset))) { replaceLeftSpacesWithIndentationPreservedNewLines(parentStartCloseOffset, startTagOpenOffset, indentLevel, edits); @@ -321,7 +321,7 @@ private int formatEndTagElement(DOMElement element, XMLFormattingConstraints par DOMNode lastChild = element.getLastChild(); if (lastChild != null && (lastChild.isElement() || lastChild.isComment()) - && Character.isWhitespace(formatterDocument.getText().charAt(endTagOpenOffset - 1))) { + && Character.isWhitespace(formatterDocument.getTextSequence().charAt(endTagOpenOffset - 1))) { replaceLeftSpacesWithIndentationPreservedNewLines(startTagCloseOffset, endTagOpenOffset, indentLevel, edits); width += indentLevel * getTabSize(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMTextFormatter.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMTextFormatter.java index 9dec08ad0..b2f084bcb 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMTextFormatter.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/DOMTextFormatter.java @@ -38,7 +38,7 @@ public void formatText(DOMText textNode, XMLFormattingConstraints parentConstrai // Don't format the spacing in text for case of preserve empty content setting FormatElementCategory formatElementCategory = parentConstraints.getFormatElementCategory(); if (formatElementCategory == FormatElementCategory.PreserveSpace && isTrimTrailingWhitespace()) { - String text = formatterDocument.getText(); + CharSequence text = formatterDocument.getTextSequence(); int i = text.length() - 1; char curr = text.charAt(i); boolean removeSpaces = true; @@ -68,7 +68,7 @@ public void formatText(DOMText textNode, XMLFormattingConstraints parentConstrai } else if (formatElementCategory == FormatElementCategory.PreserveSpace) { return; } - String text = formatterDocument.getText(); + CharSequence text = formatterDocument.getTextSequence(); int availableLineWidth = parentConstraints.getAvailableLineWidth(); int indentLevel = parentConstraints.getIndentLevel(); boolean isMixedContent = formatElementCategory == FormatElementCategory.MixedContent; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java index f5163ddf8..e84c2bf37 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java @@ -145,7 +145,7 @@ public List format() throws BadLocationException { public List format(DOMDocument document, int start, int end) { // Pre-allocate list capacity based on document size to reduce reallocations // Estimate: 1 edit per 100 characters for typical XML formatting - int estimatedCapacity = Math.min(textDocument.getText().length() / 100, 10000); + int estimatedCapacity = Math.min(textDocument.getTextSequence().length() / 100, 10000); List edits = new ArrayList<>(estimatedCapacity); // get initial document region @@ -179,7 +179,7 @@ public List format(DOMDocument document, int start, int end) } boolean insertFinalNewline = isInsertFinalNewline(); - String xml = textDocument.getText(); + CharSequence xml = textDocument.getTextSequence(); int endDocument = xml.length() - 1; if (isTrimFinalNewlines() && (end == -1 || endDocument < end)) { trimFinalNewlines(insertFinalNewline, edits); @@ -417,7 +417,7 @@ void replaceQuoteWithPreferred(int from, int to, List edits) { } public int adjustOffsetWithLeftWhitespaces(int leftLimit, int to) { - return TextEditUtils.adjustOffsetWithLeftWhitespaces(leftLimit, to, textDocument.getText()); + return TextEditUtils.adjustOffsetWithLeftWhitespaces(leftLimit, to, textDocument.getTextSequence()); } public int replaceLeftSpacesWithIndentation(int indentLevel, int leftLimit, int to, boolean addLineSeparator, @@ -457,7 +457,7 @@ public void replaceLeftSpacesWithIndentationPreservedNewLines(int spaceStart, in int indentLevel, List edits) { int preservedNewLines = getFormattingSettings().getPreservedNewlines(); int currentNewLineCount = XMLFormatterDocument.getExistingNewLineCount( - textDocument.getText(), spaceEnd, lineDelimiter); + textDocument.getTextSequence(), spaceEnd, lineDelimiter); if (currentNewLineCount > preservedNewLines) { replaceLeftSpacesWithIndentationWithMultiNewLines(indentLevel, spaceStart, spaceEnd, preservedNewLines + 1, edits); @@ -469,7 +469,7 @@ public void replaceLeftSpacesWithIndentationPreservedNewLines(int spaceStart, in } boolean hasLineBreak(int from, int to) { - String text = textDocument.getText(); + CharSequence text = textDocument.getTextSequence(); for (int i = from; i < to; i++) { char c = text.charAt(i); if (isLineSeparator(c)) { @@ -480,7 +480,7 @@ boolean hasLineBreak(int from, int to) { } public int getNormalizedLength(int from, int to) { - String text = textDocument.getText(); + CharSequence text = textDocument.getTextSequence(); int contentOffset = 0; for (int i = from; i < to; i++) { if (Character.isWhitespace(text.charAt(i)) && !Character.isWhitespace(text.charAt(i + 1))) { @@ -495,7 +495,7 @@ public int getNormalizedLength(int from, int to) { public int getOffsetWithPreserveLineBreaks(int from, int to, int tabSize, boolean isInsertSpaces) { int initialTo = to; - String text = textDocument.getText(); + CharSequence text = textDocument.getTextSequence(); for (int i = to; i > from; i--) { if (text.charAt(i) == '\t') { to -= tabSize; @@ -530,7 +530,7 @@ public int getOffsetWithPreserveLineBreaks(int from, int to, int tabSize, boolea // ------- Utilities method int updateLineWidthWithLastLine(DOMNode child, int availableLineWidth) { - String text = textDocument.getText(); + CharSequence text = textDocument.getTextSequence(); int lineWidth = availableLineWidth; int end = child.getEnd(); // Check if next char after the end of the DOM node is a new line feed. @@ -557,7 +557,7 @@ private static boolean isLineSeparator(char c) { } public int getLineBreakOffset(int startAttr, int start) { - String text = textDocument.getText(); + CharSequence text = textDocument.getTextSequence(); for (int i = startAttr; i < start; i++) { char c = text.charAt(i); if (isLineSeparator(c)) { @@ -736,7 +736,7 @@ private String getIndentSpacesWithOffsetSpaces(int spaceCount, boolean addLineSe } private void trimFinalNewlines(boolean insertFinalNewline, List edits) { - String xml = textDocument.getText(); + CharSequence xml = textDocument.getTextSequence(); int end = xml.length() - 1; int i = end; while (i >= 0 && isLineSeparator(xml.charAt(i))) { @@ -774,7 +774,7 @@ private void trimFinalNewlines(boolean insertFinalNewline, List edits) * @return the number of new lines in the whitespaces to the left of the given * offset. */ - public static int getExistingNewLineCount(String text, int offset, String delimiter) { + public static int getExistingNewLineCount(CharSequence text, int offset, String delimiter) { boolean delimiterHasTwoCharacters = delimiter.length() == 2; int newLineCounter = 0; for (int i = offset; i > 1; i--) { @@ -789,7 +789,7 @@ public static int getExistingNewLineCount(String text, int offset, String delimi return newLineCounter; } if (delimiterHasTwoCharacters) { - c = text.substring(i - 2, i); + c = text.subSequence(i - 2, i).toString(); if (delimiter.equals(c)) { newLineCounter++; i--; // skip the second char of the delimiter @@ -848,6 +848,10 @@ String getLineDelimiter() { return lineDelimiter; } + CharSequence getTextSequence() { + return textDocument.getTextSequence(); + } + String getText() { return textDocument.getText(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java index 58d6483dc..96d5f2c49 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocumentOld.java @@ -115,8 +115,7 @@ private void setupRangeFormatting(Range range) throws BadLocationException { this.startOffset = this.textDocument.offsetAt(startPosition); this.endOffset = this.textDocument.offsetAt(endPosition); - String fullText = this.textDocument.getText(); - String rangeText = fullText.substring(this.startOffset, this.endOffset); + String rangeText = this.textDocument.getTextSequence().subSequence(this.startOffset, this.endOffset).toString(); withinDTDContent = this.fullDomDocument.isWithinInternalDTD(startOffset); String uri = this.textDocument.getUri(); @@ -127,7 +126,7 @@ private void setupRangeFormatting(Range range) throws BadLocationException { if (containsTextWithinStartTag()) { adjustOffsetToStartTag(); - rangeText = fullText.substring(this.startOffset, this.endOffset); + rangeText = this.textDocument.getTextSequence().subSequence(this.startOffset, this.endOffset).toString(); this.rangeDomDocument = DOMParser.getInstance().parse(rangeText, uri, null, false); } @@ -167,7 +166,7 @@ private void adjustOffsetToStartTag() throws BadLocationException { private void setupFullFormatting(Range range) throws BadLocationException { this.startOffset = 0; - this.endOffset = textDocument.getText().length(); + this.endOffset = textDocument.getTextSequence().length(); this.rangeDomDocument = this.fullDomDocument; Position startPosition = textDocument.positionAt(startOffset); @@ -754,7 +753,7 @@ private List getFormatTextEdit() throws BadLocationException List edits = new ArrayList<>(); // check if format range reaches the end of the document - if (this.endOffset == this.textDocument.getText().length()) { + if (this.endOffset == this.textDocument.getTextSequence().length()) { if (this.sharedSettings.getFormattingSettings().isTrimFinalNewlines()) { this.xmlBuilder.trimFinalNewlines(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/snippets/SnippetContextUtils.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/snippets/SnippetContextUtils.java index 3c10c93a3..28e1ad463 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/snippets/SnippetContextUtils.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/snippets/SnippetContextUtils.java @@ -58,7 +58,7 @@ public static boolean canAcceptExpression(ICompletionRequest request) { if (element.isInInsideStartEndTag(offset)) { // | // - String text = request.getXMLDocument().getText(); + CharSequence text = request.getXMLDocument().getTextSequence(); if (text.charAt(offset - 1) == '/') { // -> should be ignore return false; @@ -78,7 +78,7 @@ public static boolean canAcceptExpression(ICompletionRequest request) { if (!element.hasEndTag()) { // | // should be ignore return false; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/StringUtils.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/StringUtils.java index 9147ada1a..992b83f15 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/StringUtils.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/StringUtils.java @@ -46,7 +46,7 @@ public static boolean isWhitespace(String value, int index) { return isWhitespace(value, index, value.length()); } - public static boolean isWhitespace(String value, int index, int end) { + public static boolean isWhitespace(CharSequence value, int index, int end) { if (value == null) { return false; } @@ -134,7 +134,7 @@ public static String getStartWhitespaces(String lineText) { * @param text the text * @return the whitespaces from the given range start/end of the given text. */ - public static String getWhitespaces(String text, int start, int end) { + public static String getWhitespaces(CharSequence text, int start, int end) { StringBuilder whitespaces = new StringBuilder(); for (int i = start; i < end; i++) { char c = text.charAt(i); @@ -421,7 +421,7 @@ public static String getString(Object obj) { * @return the start word offset from the left of the given offset * and -1 if no word. */ - public static int findStartWord(String text, int offset, Predicate isValidChar) { + public static int findStartWord(CharSequence text, int offset, Predicate isValidChar) { return findStartWord(text, offset, 0, isValidChar); } @@ -437,7 +437,7 @@ public static int findStartWord(String text, int offset, Predicate is * @return the start word offset from the left of the given offset * to the given min and -1 if no word. */ - public static int findStartWord(String text, int offset, int min, Predicate isValidChar) { + public static int findStartWord(CharSequence text, int offset, int min, Predicate isValidChar) { if (offset < 0 || offset >= text.length()) { return -1; } @@ -460,7 +460,7 @@ public static int findStartWord(String text, int offset, int min, Predicateoffset * and -1 if no word. */ - public static int findEndWord(String text, int offset, Predicate isValidChar) { + public static int findEndWord(CharSequence text, int offset, Predicate isValidChar) { return findEndWord(text, offset, text.length(), isValidChar); } @@ -475,7 +475,7 @@ public static int findEndWord(String text, int offset, Predicate isVa * @return the start word offset from the right of the given offset * and -1 if no word. */ - public static int findEndWord(String text, int offset, int max, Predicate isValidChar) { + public static int findEndWord(CharSequence text, int offset, int max, Predicate isValidChar) { if (offset < 0 || offset >= text.length() || !isValidChar.test(text.charAt(offset))) { return -1; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/TextEditUtils.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/TextEditUtils.java index 3f9779596..f577f85ac 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/TextEditUtils.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/TextEditUtils.java @@ -61,7 +61,7 @@ public static String applyEdits(TextDocument document, List * @deprecated Use {@link org.eclipse.lemminx.commons.TextEditUtils#adjustOffsetWithLeftWhitespaces(int, int, String)} */ @Deprecated - public static int adjustOffsetWithLeftWhitespaces(int leftLimit, int to, String text) { + public static int adjustOffsetWithLeftWhitespaces(int leftLimit, int to, CharSequence text) { return org.eclipse.lemminx.commons.TextEditUtils.adjustOffsetWithLeftWhitespaces(leftLimit, to, text); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/XMLPositionUtility.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/XMLPositionUtility.java index 58c280ac0..900bf7e1c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/XMLPositionUtility.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/XMLPositionUtility.java @@ -294,7 +294,7 @@ private static int adjustOffsetForAttribute(int offset, DOMDocument document) { // -> // -> // Remove spaces - String text = document.getText(); + CharSequence text = document.getTextSequence(); char c = text.charAt(offset); if (c == '>') { offset--; @@ -635,7 +635,7 @@ public static EntityReferenceRange selectEntityReference(int offset, DOMDocument */ public static EntityReferenceRange selectEntityReference(int offset, DOMDocument document, boolean endsWithSemicolon) { - String text = document.getText(); + CharSequence text = document.getTextSequence(); // Search '&' or '%' character on the left of the offset int entityReferenceStart = getEntityReferenceStartOffset(text, offset); if (entityReferenceStart == -1) { @@ -649,7 +649,7 @@ public static EntityReferenceRange selectEntityReference(int offset, DOMDocument } entityReferenceEnd = offset; } - String name = endsWithSemicolon ? document.getText().substring(entityReferenceStart + 1, entityReferenceEnd - 1) + String name = endsWithSemicolon ? text.subSequence(entityReferenceStart + 1, entityReferenceEnd - 1).toString() : null; return new EntityReferenceRange(name, createRange(entityReferenceStart, entityReferenceEnd, document)); } @@ -663,7 +663,7 @@ public static EntityReferenceRange selectEntityReference(int offset, DOMDocument * @return the start offset of the entity reference (ex : &am|p;) from the left * of the given offset and -1 if no entity reference. */ - public static int getEntityReferenceStartOffset(String text, int offset) { + public static int getEntityReferenceStartOffset(CharSequence text, int offset) { // adjust offset to get the left character of the offset offset--; if (offset < 0) { @@ -700,7 +700,7 @@ public static int getEntityReferenceStartOffset(String text, int offset) { * @return the end offset of the entity reference (ex : &am|p;) from the right * of the given offset and -1 if no entity reference. */ - public static int getEntityReferenceEndOffset(String text, int offset) { + public static int getEntityReferenceEndOffset(CharSequence text, int offset) { int endEntityOffset = StringUtils.findEndWord(text, offset, ENTITY_NAME_PREDICATE); if (endEntityOffset == -1) { return -1; @@ -721,7 +721,7 @@ public static Range selectFirstNonWhitespaceText(int offset, DOMDocument documen DOMCharacterData data = (DOMCharacterData) node; int start = data.getStartContent(); Integer end = null; - String text = document.getText(); + CharSequence text = document.getTextSequence(); for (int i = start; i < data.getEndContent(); i++) { char c = text.charAt(i); if (end == null) { @@ -1142,7 +1142,7 @@ public static boolean isBeforeOrEqual(Position pos1, Position pos2) { public static Range getTagNameRange(TokenType tokenType, int startOffset, DOMDocument xmlDocument) { - Scanner scanner = XMLScanner.createScanner(xmlDocument.getText(), startOffset); + Scanner scanner = XMLScanner.createScanner(xmlDocument.getTextSequence(), startOffset); TokenType token = scanner.scan(); while (token != TokenType.EOS && token != tokenType) { From 4ef57712a28e532d20e0fbfea60fee0d482a5776 Mon Sep 17 00:00:00 2001 From: azerr Date: Sat, 5 Sep 2026 22:46:33 +0200 Subject: [PATCH 10/18] Reduce DOM memory: tag interning, DOMNode[] children, GreenElement ref - Intern tag strings in GreenTreeBuilder to deduplicate ~1.7M Strings - Replace XMLNodeList (ArrayList) with DOMNode[] arrays - Store GreenElement reference in DOMElement instead of caching tag/startTagCloseOffset/endTagOpenOffset/endTagCloseOffset fields - Pre-allocate children array in RedTreeBuilder.addChildren() - Make lazyGreenNode volatile for thread-safe double-checked locking - Reduces DOM memory from ~700MB to ~260MB for 30MB XML files Co-Authored-By: Claude Opus 4.6 --- .../org/eclipse/lemminx/dom/DOMElement.java | 43 ++++++----- .../java/org/eclipse/lemminx/dom/DOMNode.java | 71 +++++++++---------- .../eclipse/lemminx/dom/RedTreeBuilder.java | 27 ++++--- .../lemminx/dom/green/GreenTreeBuilder.java | 7 +- .../eclipse/lemminx/dom/DOMParserTest.java | 11 ++- 5 files changed, 89 insertions(+), 70 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index 7da58aace..eae23a2ec 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -21,6 +21,7 @@ import java.util.List; import java.util.Objects; +import org.eclipse.lemminx.dom.green.GreenElement; import org.eclipse.lemminx.utils.StringUtils; import org.w3c.dom.DOMException; import org.w3c.dom.NodeList; @@ -32,15 +33,9 @@ */ public class DOMElement extends DOMNode implements org.w3c.dom.Element { - String tag; + GreenElement greenElement; - // DomElement.start == startTagOpenOffset int startTagOpenOffset = NULL_VALUE; // | - int startTagCloseOffset = NULL_VALUE; // - - int endTagOpenOffset = NULL_VALUE; // | - int endTagCloseOffset = NULL_VALUE;// - // DomElement.end = | , is always scanner.getTokenEnd() public DOMElement(int start, int end) { super(start, end); @@ -73,7 +68,7 @@ public String getNodeName() { */ @Override public String getTagName() { - return tag; + return greenElement != null ? greenElement.tag() : null; } /** @@ -84,7 +79,7 @@ public String getTagName() { * or ' startTagOpenOffset && offset <= startTagCloseOffset) { + if (offset > startTagOpenOffset && offset <= stcOffset) { // case return true; } @@ -300,11 +296,12 @@ public boolean isInEndTag(int offset) { } public boolean isInEndTag(int offset, boolean afterBackSlash) { - if (endTagOpenOffset == NULL_VALUE) { + int etoOffset = getEndTagOpenOffset(); + if (etoOffset == NULL_VALUE) { // case >| return false; } - if (offset > endTagOpenOffset + (afterBackSlash ? 1 : 0) && offset < getEnd()) { + if (offset > etoOffset + (afterBackSlash ? 1 : 0) && offset < getEnd()) { // case return true; } @@ -312,7 +309,7 @@ public boolean isInEndTag(int offset, boolean afterBackSlash) { } public boolean isInInsideStartEndTag(int offset) { - return offset > startTagCloseOffset && offset <= endTagOpenOffset; + return offset > getStartTagCloseOffset() && offset <= getEndTagOpenOffset(); } /** @@ -334,7 +331,9 @@ public int getStartTagOpenOffset() { * doesn't exist. */ public int getStartTagCloseOffset() { - return startTagCloseOffset; + if (greenElement == null) return NULL_VALUE; + int rel = greenElement.startTagCloseRel(); + return rel != GreenElement.NULL_VALUE ? start + rel : NULL_VALUE; } /** @@ -345,7 +344,9 @@ public int getStartTagCloseOffset() { * exist. */ public int getEndTagOpenOffset() { - return endTagOpenOffset; + if (greenElement == null) return NULL_VALUE; + int rel = greenElement.endTagOpenRel(); + return rel != GreenElement.NULL_VALUE ? start + rel : NULL_VALUE; } /** @@ -356,7 +357,9 @@ public int getEndTagOpenOffset() { * exist. */ public int getEndTagCloseOffset() { - return endTagCloseOffset; + if (greenElement == null) return NULL_VALUE; + int rel = greenElement.endTagCloseRel(); + return rel != GreenElement.NULL_VALUE ? start + rel : NULL_VALUE; } /** @@ -627,7 +630,9 @@ public boolean isEmpty() { * otherwise. */ public DOMText findTextAt(int offset) { - if (offset > startTagCloseOffset && startTagCloseOffset == endTagOpenOffset - 1) { + int stcOffset = getStartTagCloseOffset(); + int etoOffset = getEndTagOpenOffset(); + if (offset > stcOffset && stcOffset == etoOffset - 1) { // | // In this case, DOM text doesn't exists, create an empty DOM text DOMText text = new DOMText(offset, offset); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index aaecf4309..8230ed962 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -13,6 +13,7 @@ package org.eclipse.lemminx.dom; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Objects; @@ -67,7 +68,7 @@ public abstract class DOMNode implements Node, DOMRange { static final byte FLAG_WHITESPACE = 0x04; private XMLNamedNodeMap attributeNodes; - private XMLNodeList children; + DOMNode[] children; final int start; // | int end; // | @@ -76,7 +77,7 @@ public abstract class DOMNode implements Node, DOMRange { int cachedIndexInParent = -1; - GreenNode lazyGreenNode; + volatile GreenNode lazyGreenNode; int lazyAbsStart; private static final NodeList EMPTY_CHILDREN = new NodeList() { @@ -92,24 +93,15 @@ public int getLength() { } }; - static class XMLNodeList extends ArrayList implements NodeList { - - private static final long serialVersionUID = 1L; - - XMLNodeList() { - super(2); - } - + private static final class ArrayNodeList implements NodeList { + private final DOMNode[] nodes; + ArrayNodeList(DOMNode[] nodes) { this.nodes = nodes; } @Override - public int getLength() { - return super.size(); - } - + public int getLength() { return nodes.length; } @Override - public DOMNode item(int index) { - return super.get(index); + public Node item(int index) { + return index >= 0 && index < nodes.length ? nodes[index] : null; } - } static class XMLNamedNodeMap extends ArrayList implements NamedNodeMap { @@ -220,17 +212,17 @@ private String toString(int indent) { result.append(", closed: "); result.append(isClosed()); ensureChildren(); - if (children != null && children.size() > 0) { + if (children != null && children.length > 0) { result.append(", \n"); for (int i = 0; i < indent + 1; i++) { result.append("\t"); } result.append("children:["); - for (int i = 0; i < children.size(); i++) { - DOMNode node = children.get(i); + for (int i = 0; i < children.length; i++) { + DOMNode node = children[i]; result.append("\n"); result.append(node.toString(indent + 2)); - if (i < children.size() - 1) { + if (i < children.length - 1) { result.append(","); } } @@ -506,10 +498,14 @@ public List getChildrenWithAttributeValue(String name, String value) { private void ensureChildren() { if (lazyGreenNode != null) { - GreenNode green = lazyGreenNode; - int absStart = lazyAbsStart; - lazyGreenNode = null; - RedTreeBuilder.expandLazy(this, green, absStart); + synchronized (this) { + if (lazyGreenNode != null) { + GreenNode green = lazyGreenNode; + int absStart = lazyAbsStart; + lazyGreenNode = null; + RedTreeBuilder.expandLazy(this, green, absStart); + } + } } } @@ -520,10 +516,10 @@ private void ensureChildren() { */ public List getChildren() { ensureChildren(); - if (children == null) { + if (children == null || children.length == 0) { return Collections.emptyList(); } - return children; + return Arrays.asList(children); } /** @@ -534,16 +530,15 @@ public List getChildren() { public void addChild(DOMNode child) { child.parent = this; if (children == null) { - children = new XMLNodeList<>(); + children = new DOMNode[] { child }; + } else { + children = Arrays.copyOf(children, children.length + 1); + children[children.length - 1] = child; } - child.cachedIndexInParent = children.size(); - children.add(child); + child.cachedIndexInParent = children.length - 1; } void compactChildren() { - if (children != null) { - children.trimToSize(); - } if (attributeNodes != null) { attributeNodes.trimToSize(); } @@ -685,7 +680,7 @@ public DOMNode getParentNode() { @Override public DOMNode getFirstChild() { ensureChildren(); - return this.children != null && children.size() > 0 ? this.children.get(0) : null; + return children != null && children.length > 0 ? children[0] : null; } /* @@ -696,7 +691,7 @@ public DOMNode getFirstChild() { @Override public DOMNode getLastChild() { ensureChildren(); - return this.children != null && this.children.size() > 0 ? this.children.get(this.children.size() - 1) : null; + return children != null && children.length > 0 ? children[children.length - 1] : null; } /* @@ -717,7 +712,7 @@ public NamedNodeMap getAttributes() { @Override public NodeList getChildNodes() { ensureChildren(); - return children != null ? children : EMPTY_CHILDREN; + return children != null && children.length > 0 ? new ArrayNodeList(children) : EMPTY_CHILDREN; } /* @@ -911,7 +906,7 @@ public String getTextContent() throws DOMException { // concatenation of the textContent attribute value of every child node default: ensureChildren(); - if (this.children != null && children.size() > 0) { + if (this.children != null && children.length > 0) { final StringBuilder builder = new StringBuilder(); for (DOMNode child : children) { short nodeType = child.getNodeType(); @@ -946,7 +941,7 @@ public boolean hasChildNodes() { if (lazyGreenNode != null) { return true; } - return children != null && !children.isEmpty(); + return children != null && children.length > 0; } @Override diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 73768da18..1fc51cbb7 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -11,6 +11,8 @@ *******************************************************************************/ package org.eclipse.lemminx.dom; +import java.util.Arrays; + import org.eclipse.lemminx.commons.TextDocument; import org.eclipse.lemminx.dom.green.GreenAttr; import org.eclipse.lemminx.dom.green.GreenCDATA; @@ -85,17 +87,21 @@ private void addChildrenOrDefer(DOMNode node, GreenNode green, int absStart) { } private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsStart) { - GreenNode[] children = greenParent.children(); - if (children.length == 0) { + GreenNode[] greenChildren = greenParent.children(); + if (greenChildren.length == 0) { + parent.compactChildren(); return; } int childrenStartRel = greenParent.childrenStartRel(); int childAbsStart = parentAbsStart + childrenStartRel; boolean skipWhitespace = ignoreWhitespaceContent - && (hasNonWhitespaceChild(children) || greenParent instanceof GreenDocumentType); + && (hasNonWhitespaceChild(greenChildren) || greenParent instanceof GreenDocumentType); + + DOMNode[] redChildren = new DOMNode[greenChildren.length]; + int idx = 0; - for (GreenNode greenChild : children) { + for (GreenNode greenChild : greenChildren) { if (skipWhitespace && isWhitespaceText(greenChild)) { childAbsStart += greenChild.width(); continue; @@ -106,11 +112,17 @@ private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsSta ((DTDAttlistDecl) parent).addAdditionalAttDecl((DTDAttlistDecl) redChild); redChild.parent = parent; } else { - parent.addChild(redChild); + redChild.parent = parent; + redChild.cachedIndexInParent = idx; + redChildren[idx++] = redChild; } } childAbsStart += greenChild.width(); } + + if (idx > 0) { + parent.children = (idx == redChildren.length) ? redChildren : Arrays.copyOf(redChildren, idx); + } parent.compactChildren(); } @@ -160,15 +172,12 @@ private DOMNode createRedNode(GreenNode green, int absStart) { private DOMElement createElement(GreenElement green, int absStart, int absEnd) { DOMElement elem = new DOMElement(absStart, absEnd); - elem.tag = green.tag(); + elem.greenElement = green; elem.setSelfClosed(green.selfClosed()); boolean isOrphanEndTag = green.endTagOpenRel() != GreenElement.NULL_VALUE && green.endTagOpenRel() == 0 && green.startTagCloseRel() == GreenElement.NULL_VALUE; elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : absStart; - elem.startTagCloseOffset = abs(green.startTagCloseRel(), absStart); - elem.endTagOpenOffset = abs(green.endTagOpenRel(), absStart); - elem.endTagCloseOffset = abs(green.endTagCloseRel(), absStart); elem.setClosed(green.closed()); GreenAttr[] greenAttrs = green.attributes(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index 25f96d973..0e82bd254 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -15,7 +15,9 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Deque; +import java.util.HashMap; import java.util.List; +import java.util.Map; import org.eclipse.lemminx.dom.DOMNode; import org.eclipse.lemminx.dom.parser.Scanner; @@ -61,6 +63,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, stack.push(dtdRoot); } + Map tagIntern = new HashMap<>(); GreenAttrBuilder currentAttr = null; int endTagOpenOffset = -1; boolean previousTokenWasEndTagOpen = false; @@ -168,7 +171,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, case StartTag: { if (!stack.isEmpty()) { NodeBuilder top = stack.peek(); - top.tag = scanner.getTokenText(); + top.tag = tagIntern.computeIfAbsent(scanner.getTokenText(), k -> k); top.nodeEnd = scanner.getTokenEnd(); } break; @@ -201,7 +204,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, } case EndTag: { - String closeTag = scanner.getTokenText(); + String closeTag = tagIntern.computeIfAbsent(scanner.getTokenText(), k -> k); if (hasMatchingElement(stack, closeTag)) { while (!stack.isEmpty()) { NodeBuilder top = stack.peek(); diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java index ceb7a9b8f..38f1b1f38 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java @@ -26,6 +26,7 @@ import javax.xml.parsers.DocumentBuilderFactory; import org.eclipse.lemminx.dom.DOMDocumentType.DocumentTypeKind; +import org.eclipse.lemminx.dom.green.GreenElement; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.w3c.dom.Document; @@ -1217,8 +1218,14 @@ private static DOMNode createNode(short nodeType, int start, int end) { private static void setRestOfNode(DOMNode n, String tag, Integer endTagStart, boolean closed) { if (n.isElement()) { - ((DOMElement) n).tag = tag; - ((DOMElement) n).endTagOpenOffset = endTagStart != null ? endTagStart : DOMNode.NULL_VALUE; + DOMElement elem = (DOMElement) n; + int width = n.end - n.start; + int endTagOpenRel = endTagStart != null ? endTagStart - n.start : GreenElement.NULL_VALUE; + elem.greenElement = new GreenElement(width, closed, tag, false, + GreenElement.NULL_VALUE, endTagOpenRel, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, null, null); + boolean isOrphanEndTag = endTagOpenRel == 0; + elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : n.start; } else if (n instanceof DOMProcessingInstruction) { ((DOMProcessingInstruction) n).target = tag; ((DOMProcessingInstruction) n).endTagOpenOffset = endTagStart != null ? endTagStart : DOMNode.NULL_VALUE; From 08ea7731d996c6db86c598e0be6b2b29f8b73521 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 00:48:43 +0200 Subject: [PATCH 11/18] Release StringBuilder after text materialization to avoid double buffering When getText() materializes the cached String from the StringBuilder, null out textBuffer to free the duplicate byte[] backing array. Reduces byte[] memory from ~66MB to ~24MB for large XML files. Co-Authored-By: Claude Opus 4.6 --- .../src/main/java/org/eclipse/lemminx/commons/TextDocument.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java index 372a12485..b0cc57424 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java @@ -66,6 +66,7 @@ public String getText() { } if (textBuffer != null) { cachedText = textBuffer.toString(); + textBuffer = null; super.setText(cachedText); return cachedText; } From 158a598ddf3a3576fd1d5c1d9caf759633e150b7 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 01:50:21 +0200 Subject: [PATCH 12/18] Reduce memory spikes: lazy initial parse, compact GreenElement, early GC MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Use buildLazy for initial parse (not just incremental), so red tree nodes are materialized on demand instead of all at once - Remove unused contentStartRel field from GreenElement (48→40 bytes) - Clear previousIncrementalData right after incremental parse to allow earlier GC of old green tree (~58MB freed sooner) - Fix DTDAttlistDecl.getInternalChildren() and hasChildNodes() to properly trigger lazy expansion - Fall back to eager build when ignoreWhitespaceContent=false (tests) Co-Authored-By: Claude Opus 4.6 --- .../eclipse/lemminx/XMLTextDocumentService.java | 4 +++- .../eclipse/lemminx/commons/ModelTextDocument.java | 8 ++++++++ .../main/java/org/eclipse/lemminx/dom/DOMNode.java | 4 +--- .../java/org/eclipse/lemminx/dom/DOMParser.java | 5 +++-- .../org/eclipse/lemminx/dom/DTDAttlistDecl.java | 1 + .../org/eclipse/lemminx/dom/RedTreeBuilder.java | 5 +++++ .../eclipse/lemminx/dom/green/GreenElement.java | 14 ++------------ .../lemminx/dom/green/GreenElementBuilder.java | 2 +- .../lemminx/dom/green/GreenTreeBuilder.java | 11 +++-------- .../org/eclipse/lemminx/dom/DOMParserTest.java | 2 +- 10 files changed, 28 insertions(+), 28 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java index 957ffd10d..0d3816371 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/XMLTextDocumentService.java @@ -209,13 +209,15 @@ public XMLTextDocumentService(XMLLanguageServer xmlLanguageServer) { Object prevData = mtd.getPreviousIncrementalData(); ModelTextDocument.EditInfo editInfo = mtd.getPendingEdit(); if (prevData instanceof GreenDocument && editInfo != null) { - return parser.parseIncremental(document, + DOMDocument result = parser.parseIncremental(document, (GreenDocument) prevData, editInfo.getStartOffset(), editInfo.getDeleteLength(), editInfo.getInsertLength(), getXMLLanguageService().getResolverExtensionManager(), true, cancelChecker); + mtd.clearPreviousIncrementalData(); + return result; } } return parser.parse(document, getXMLLanguageService().getResolverExtensionManager(), true, cancelChecker); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java index 759663977..6c91dbc3b 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java @@ -180,6 +180,14 @@ public Object getPreviousIncrementalData() { return previousIncrementalData; } + /** + * Clears the previous incremental data to allow early GC of the old + * green tree after incremental parsing completes. + */ + public void clearPreviousIncrementalData() { + previousIncrementalData = null; + } + /** * Returns the pending edit info (offset, delete/insert lengths) for * the most recent single-change edit, or null if not available. diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index 8230ed962..d74802814 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -938,9 +938,7 @@ public Object getUserData(String arg0) { */ @Override public boolean hasChildNodes() { - if (lazyGreenNode != null) { - return true; - } + ensureChildren(); return children != null && children.length > 0; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java index b0aaef526..facc76555 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMParser.java @@ -83,8 +83,9 @@ public DOMDocument parseIncremental(TextDocument document, private static DOMDocument buildDocument(GreenDocument greenDoc, TextDocument document, URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent, CancelChecker monitor) { - DOMDocument xmlDocument = RedTreeBuilder.build(greenDoc, document, - resolverExtensionManager, ignoreWhitespaceContent); + DOMDocument xmlDocument = ignoreWhitespaceContent + ? RedTreeBuilder.buildLazy(greenDoc, document, resolverExtensionManager) + : RedTreeBuilder.build(greenDoc, document, resolverExtensionManager, ignoreWhitespaceContent); xmlDocument.setGreenDocument(greenDoc); xmlDocument.setCancelChecker(monitor); return xmlDocument; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDAttlistDecl.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDAttlistDecl.java index 7daf7d386..cc95f57d8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDAttlistDecl.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDAttlistDecl.java @@ -113,6 +113,7 @@ void addAdditionalAttDecl(DTDAttlistDecl child) { } public List getInternalChildren() { + getChildren(); return internalChildren; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 1fc51cbb7..5fbb83598 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -65,6 +65,11 @@ public static DOMDocument buildLazy(GreenDocument greenDoc, TextDocument textDoc return new RedTreeBuilder(true, true).doBuild(greenDoc, textDocument, resolverExtensionManager); } + public static DOMDocument buildLazy(GreenDocument greenDoc, TextDocument textDocument, + URIResolverExtensionManager resolverExtensionManager, boolean ignoreWhitespaceContent) { + return new RedTreeBuilder(ignoreWhitespaceContent, true).doBuild(greenDoc, textDocument, resolverExtensionManager); + } + static void expandLazy(DOMNode node, GreenNode green, int absStart) { new RedTreeBuilder(true, true).addChildren(node, green, absStart); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 9d69f07e6..988195026 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -28,20 +28,17 @@ public final class GreenElement extends GreenNode { private final int startTagCloseRel; private final int endTagOpenRel; private final int endTagCloseRel; - private final int contentStartRel; private final GreenAttr[] attributes; private final GreenNode[] children; public GreenElement(int width, boolean closed, String tag, boolean selfClosed, int startTagCloseRel, int endTagOpenRel, int endTagCloseRel, - int contentStartRel, GreenAttr[] attributes, GreenNode[] children) { super(width, (closed ? CLOSED_FLAG : 0) | (selfClosed ? SUBCLASS_FLAG : 0)); this.tag = tag; this.startTagCloseRel = startTagCloseRel; this.endTagOpenRel = endTagOpenRel; this.endTagCloseRel = endTagCloseRel; - this.contentStartRel = contentStartRel; this.attributes = attributes != null ? attributes : EMPTY_ATTRS; this.children = children != null ? children : EMPTY_CHILDREN; } @@ -71,10 +68,6 @@ public int endTagCloseRel() { return endTagCloseRel; } - public int contentStartRel() { - return contentStartRel; - } - public GreenAttr[] attributes() { return attributes; } @@ -85,9 +78,6 @@ public int attributeCount() { @Override public int childrenStartRel() { - if (contentStartRel != NULL_VALUE) { - return contentStartRel; - } if (startTagCloseRel != NULL_VALUE) { return startTagCloseRel + 1; } @@ -105,13 +95,13 @@ public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { startTagCloseRel, endTagOpenRel != NULL_VALUE ? endTagOpenRel + widthDelta : NULL_VALUE, endTagCloseRel != NULL_VALUE ? endTagCloseRel + widthDelta : NULL_VALUE, - contentStartRel, attributes, newChildren); + attributes, newChildren); } @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { return new GreenElement(newWidth, closed(), tag, selfClosed(), startTagCloseRel, endTagOpenRel, endTagCloseRel, - contentStartRel, attributes, newChildren); + attributes, newChildren); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java index 3d27f64ff..537535043 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java @@ -119,6 +119,6 @@ public GreenElement build() { : null; return new GreenElement(width, closed, tag, selfClosed, - stcRel, etoRel, etcRel, GreenElement.NULL_VALUE, attrs, kids); + stcRel, etoRel, etcRel, attrs, kids); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index 0e82bd254..f6b4f6e4e 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -120,7 +120,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, GreenElement fakeEndTag = new GreenElement( 2, false, null, false, GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, - GreenElement.NULL_VALUE, null, null); + null, null); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); } } @@ -809,7 +809,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, GreenElement fakeEndTag = new GreenElement( 2, false, null, false, GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, - GreenElement.NULL_VALUE, null, null); + null, null); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); } @@ -1052,14 +1052,9 @@ private GreenElement buildElement(int width, GreenNode[] kids) { GreenAttr[] attrs = attributes != null ? (attrCount == attributes.length ? attributes : Arrays.copyOf(attributes, attrCount)) : null; - int contentStart = firstChildAbsStart != GreenElement.NULL_VALUE - ? firstChildAbsStart - nodeStart - : (startTagCloseOffset != GreenElement.NULL_VALUE - ? startTagCloseOffset + 1 - nodeStart - : GreenElement.NULL_VALUE); return new GreenElement(width, closed, tag, selfClosed, rel(startTagCloseOffset), rel(endTagOpenOffset), - rel(endTagCloseOffset), contentStart, attrs, kids); + rel(endTagCloseOffset), attrs, kids); } private GreenComment buildComment(int width) { diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java index 38f1b1f38..bf8830ff1 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java @@ -1223,7 +1223,7 @@ private static void setRestOfNode(DOMNode n, String tag, Integer endTagStart, bo int endTagOpenRel = endTagStart != null ? endTagStart - n.start : GreenElement.NULL_VALUE; elem.greenElement = new GreenElement(width, closed, tag, false, GreenElement.NULL_VALUE, endTagOpenRel, GreenElement.NULL_VALUE, - GreenElement.NULL_VALUE, null, null); + null, null); boolean isOrphanEndTag = endTagOpenRel == 0; elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : n.start; } else if (n instanceof DOMProcessingInstruction) { From 1cca6f0c7ccaf15b92155613798054a3b4a357c6 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 11:31:12 +0200 Subject: [PATCH 13/18] Fix incremental parser corruption and reduce memory spikes - Merge rapid edits into a single dirty range against the original green tree instead of overwriting pendingEdit (which caused coordinate mismatch and DOM corruption after rapid typing) - Reduce validator thread pool from 2 to 1 to limit concurrent tree retention during reparse - Fix GreenElement.childrenStartRel() for unclosed start tags - Invalidate cached model in update() via cancelModel() Co-Authored-By: Claude Opus 4.6 --- .../lemminx/commons/ModelTextDocument.java | 65 +++++++-- .../commons/ModelValidatorDelayer.java | 2 +- .../lemminx/dom/green/GreenElement.java | 12 +- .../commons/ModelTextDocumentTest.java | 127 ++++++++++++++++++ 4 files changed, 192 insertions(+), 14 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java index 6c91dbc3b..107485bec 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelTextDocument.java @@ -147,15 +147,22 @@ public void update(List changes) { int delLen = rangeLength != null ? rangeLength.intValue() : offsetAt(range.getEnd()) - start; int insLen = change.getText() != null ? change.getText().length() : 0; - pendingEdit = new EditInfo(start, delLen, insLen); + if (pendingEdit != null) { + pendingEdit.merge(start, delLen, insLen); + } else { + pendingEdit = new EditInfo(start, delLen, insLen); + } } catch (BadLocationException e) { pendingEdit = null; + previousIncrementalData = null; } } } else { pendingEdit = null; + previousIncrementalData = null; } super.update(changes); + cancelModel(); } /** @@ -199,30 +206,64 @@ public EditInfo getPendingEdit() { } /** - * Information about a single text edit: where it started in the old text, - * how many characters were deleted, and how many were inserted. + * Tracks the cumulative dirty range across multiple edits, always expressed + * relative to the original text (T0) that matches previousIncrementalData. + * + *

When multiple edits arrive before the model is rebuilt, each new edit + * is merged into this range so the incremental parser receives correct + * coordinates against the original green tree.

*/ public static final class EditInfo { - private final int startOffset; - private final int deleteLength; - private final int insertLength; + private int startInOld; + private int endInOld; + private int totalDelta; public EditInfo(int startOffset, int deleteLength, int insertLength) { - this.startOffset = startOffset; - this.deleteLength = deleteLength; - this.insertLength = insertLength; + this.startInOld = startOffset; + this.endInOld = startOffset + deleteLength; + this.totalDelta = insertLength - deleteLength; + } + + /** + * Merge a new edit (in current-text coordinates) into this dirty range. + */ + public void merge(int s2, int d2, int i2) { + int dirtyEndCurrent = endInOld + totalDelta; + + int s2Old; + if (s2 <= startInOld) { + s2Old = s2; + } else if (s2 >= dirtyEndCurrent) { + s2Old = s2 - totalDelta; + } else { + s2Old = startInOld; + } + + int s2End = s2 + d2; + int s2EndOld; + if (s2End <= startInOld) { + s2EndOld = s2End; + } else if (s2End >= dirtyEndCurrent) { + s2EndOld = s2End - totalDelta; + } else { + s2EndOld = endInOld; + } + + startInOld = Math.min(startInOld, s2Old); + endInOld = Math.max(endInOld, s2EndOld); + totalDelta += (i2 - d2); } public int getStartOffset() { - return startOffset; + return startInOld; } public int getDeleteLength() { - return deleteLength; + return endInOld - startInOld; } public int getInsertLength() { - return insertLength; + return (endInOld - startInOld) + totalDelta; } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelValidatorDelayer.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelValidatorDelayer.java index 53d4cb748..f1c70d31a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelValidatorDelayer.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ModelValidatorDelayer.java @@ -39,7 +39,7 @@ public class ModelValidatorDelayer { private final long validationDelayMs; public ModelValidatorDelayer(Consumer> validator) { - this(Executors.newScheduledThreadPool(2), validator, DEFAULT_VALIDATION_DELAY_MS); + this(Executors.newScheduledThreadPool(1), validator, DEFAULT_VALIDATION_DELAY_MS); } public ModelValidatorDelayer(ScheduledExecutorService executorService, Consumer> validator, diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 988195026..5c2aa2a07 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -81,7 +81,17 @@ public int childrenStartRel() { if (startTagCloseRel != NULL_VALUE) { return startTagCloseRel + 1; } - return 0; + if (children.length == 0) { + return 0; + } + int childrenWidth = 0; + for (GreenNode child : children) { + childrenWidth += child.width(); + } + if (endTagOpenRel != NULL_VALUE) { + return endTagOpenRel - childrenWidth; + } + return width() - childrenWidth; } @Override diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java index 1873dc833..869e2b423 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/commons/ModelTextDocumentTest.java @@ -156,6 +156,133 @@ public void doubleCancelWithoutExtractorRemainsNull() { assertNull(doc.getPreviousIncrementalData()); } + // --- Edit merge tests --- + + @Test + public void mergeEditsAfterDirtyRegion() { + // T0 = "AABBCCDD", edit1 replaces "BB" with "YYY", edit2 replaces second "C" with "Z" + ModelTextDocument doc = createDoc("AABBCCDD"); + doc.getModel(); + + // Edit 1: replace "BB" (pos 2, len 2) with "YYY" → "AAYYYCCDD" + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 2, 0, 4, "YYY"))); + + // Edit 2: replace second "C" (pos 6 in T1, len 1) with "Z" → "AAYYYCZDD" + doc.setVersion(2); + doc.update(Collections.singletonList(createChange(0, 6, 0, 7, "Z"))); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + // Merged against T0: dirty region is [2, 6), so delete "BBCC" (4 chars), insert "YYYCZ" (5 chars) + assertEquals(2, edit.getStartOffset()); + assertEquals(4, edit.getDeleteLength()); + assertEquals(5, edit.getInsertLength()); + } + + @Test + public void mergeEditsBeforeDirtyRegion() { + // T0 = "AABBCCDD", edit1 at pos 4, edit2 at pos 1 + ModelTextDocument doc = createDoc("AABBCCDD"); + doc.getModel(); + + // Edit 1: replace "CC" (pos 4, len 2) with "YYY" → "AABBYYYТDD" + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 4, 0, 6, "YYY"))); + + // Edit 2: delete "A" at pos 1 (len 1) → "ABBYYYТDD" + doc.setVersion(2); + doc.update(Collections.singletonList(createChange(0, 1, 0, 2, ""))); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + // Merged against T0: dirty region is [1, 6), delete "ABBCC" (5 chars), insert "BBYYY" (5 chars) + assertEquals(1, edit.getStartOffset()); + assertEquals(5, edit.getDeleteLength()); + assertEquals(5, edit.getInsertLength()); + } + + @Test + public void mergeEditsWithinDirtyRegion() { + // T0 = "AABBCCDD", edit1 replaces "BB" with "YYY", edit2 within dirty region + ModelTextDocument doc = createDoc("AABBCCDD"); + doc.getModel(); + + // Edit 1: replace "BB" (pos 2, len 2) with "YYY" → "AAYYYCCDD" + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 2, 0, 4, "YYY"))); + + // Edit 2: replace "Y" at pos 3 (within dirty) with "ZZ" → "AAYZZYYCCDD"... wait + // T1 = "AAYYYCCDD", replace pos 3 len 1 with "ZZ" → "AAYZZYCCDD" + doc.setVersion(2); + doc.update(Collections.singletonList(createChange(0, 3, 0, 4, "ZZ"))); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + // Merged against T0: dirty region is [2, 4), delete "BB" (2 chars), insert "YZZY" (4 chars) + assertEquals(2, edit.getStartOffset()); + assertEquals(2, edit.getDeleteLength()); + assertEquals(4, edit.getInsertLength()); + } + + @Test + public void mergeThreeConsecutiveEdits() { + // Simulate rapid typing: insert 'a', 'b', 'c' at consecutive positions + ModelTextDocument doc = createDoc(""); + doc.getModel(); + + // Edit 1: insert "a" at pos 6 → "a" + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 6, 0, 6, "a"))); + + // Edit 2: insert "b" at pos 7 → "ab" + doc.setVersion(2); + doc.update(Collections.singletonList(createChange(0, 7, 0, 7, "b"))); + + // Edit 3: insert "c" at pos 8 → "abc" + doc.setVersion(3); + doc.update(Collections.singletonList(createChange(0, 8, 0, 8, "c"))); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + // Merged against T0: at pos 6, delete 0, insert 3 + assertEquals(6, edit.getStartOffset()); + assertEquals(0, edit.getDeleteLength()); + assertEquals(3, edit.getInsertLength()); + } + + @Test + public void singleEditNoMerge() { + ModelTextDocument doc = createDoc("text"); + doc.getModel(); + + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 6, 0, 10, "newtext"))); + + ModelTextDocument.EditInfo edit = doc.getPendingEdit(); + assertNotNull(edit); + assertEquals(6, edit.getStartOffset()); + assertEquals(4, edit.getDeleteLength()); + assertEquals(7, edit.getInsertLength()); + } + + @Test + public void mergeEditsPreviousIncrementalDataPreserved() { + ModelTextDocument doc = createDoc("AABBCCDD"); + String firstModel = doc.getModel(); + + doc.setVersion(1); + doc.update(Collections.singletonList(createChange(0, 2, 0, 4, "YYY"))); + + doc.setVersion(2); + doc.update(Collections.singletonList(createChange(0, 6, 0, 7, "Z"))); + + // previousIncrementalData should still be from the original model (T0) + Object prev = doc.getPreviousIncrementalData(); + assertNotNull(prev); + assertEquals(firstModel, prev); + } + private ModelTextDocument createDoc(String text) { ModelTextDocument doc = new ModelTextDocument<>(text, "test://test.xml", (document, cancelChecker) -> document.getText(), From 75dc6f49f2019cd621cf11fd358c1b2fbfbfaae6 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 12:50:05 +0200 Subject: [PATCH 14/18] Reduce DOM memory by 14.5 MB: compact attributes, DOMAttr fields, lazy node scope MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Replace XMLNamedNodeMap with DOMAttr[] to eliminate 240K wrapper objects (-5.7 MB) - Consolidate DOMAttr fields: reuse inherited start/end/parent instead of duplicate nameStart/nameEnd/ownerElement (80→64 bytes per attr, -8.7 MB) - Move lazyGreenNode/lazyAbsStart from DOMNode to DOMElement/DTDDeclNode so leaf nodes (DOMAttr, DOMText) don't carry unused fields - Use Predicate instead of Function in findFirst to avoid autoboxing - Use unsigned right shift for binary search midpoint calculation - Add DOMMemoryOptimizationsTest (21 tests) and MemoryBenchmark utility Co-Authored-By: Claude Opus 4.6 --- .../java/org/eclipse/lemminx/dom/DOMAttr.java | 52 +--- .../eclipse/lemminx/dom/DOMDocumentType.java | 29 +- .../org/eclipse/lemminx/dom/DOMElement.java | 24 ++ .../java/org/eclipse/lemminx/dom/DOMNode.java | 113 ++----- .../org/eclipse/lemminx/dom/DTDDeclNode.java | 29 +- .../eclipse/lemminx/dom/RedTreeBuilder.java | 21 +- .../dom/DOMMemoryOptimizationsTest.java | 277 ++++++++++++++++++ .../lemminx/performance/MemoryBenchmark.java | 174 +++++++++++ 8 files changed, 584 insertions(+), 135 deletions(-) create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java create mode 100644 org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java index 1ba927f61..224ebf794 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMAttr.java @@ -32,32 +32,23 @@ public class DOMAttr extends DOMNode implements org.w3c.dom.Attr { // For 546K attributes, this eliminates 1,092,576 objects (AttrName + AttrValue) // Saves ~35 MB of heap memory - private String name; // Only cached if set programmatically (rare) - - // Attribute name offsets (instead of AttrName object) - private int nameStart = NULL_VALUE; - private int nameEnd = NULL_VALUE; + private String name; private int delimiter; - // Attribute value offsets (instead of AttrValue object) - private String value; // Only cached if set programmatically (rare) + private String value; private int valueStart = NULL_VALUE; private int valueEnd = NULL_VALUE; - private final DOMNode ownerElement; - public DOMAttr(String name, DOMNode ownerElement) { this(name, NULL_VALUE, NULL_VALUE, ownerElement); } - public DOMAttr(String name, int start, int end, DOMNode ownerElement) { - super(NULL_VALUE, NULL_VALUE); + public DOMAttr(String name, int nameStart, int nameEnd, DOMNode ownerElement) { + super(nameStart, nameEnd); this.name = name; this.delimiter = NULL_VALUE; - this.nameStart = start; - this.nameEnd = end; - this.ownerElement = ownerElement; + this.parent = ownerElement; } /* @@ -87,12 +78,9 @@ public String getNodeName() { */ @Override public String getName() { - // Memory optimization: Extract name from document instead of caching - if (nameStart != NULL_VALUE && nameEnd != NULL_VALUE) { - // Name is in the document, extract it - return getOwnerDocument().getTextSequence().subSequence(nameStart, nameEnd).toString(); + if (start != NULL_VALUE && end != NULL_VALUE) { + return getOwnerDocument().getTextSequence().subSequence(start, end).toString(); } - // Name was set programmatically or doesn't exist return name; } @@ -117,12 +105,12 @@ public String getLocalName() { * @see org.w3c.dom.Attr#getOwnerElement() */ public DOMElement getOwnerElement() { - return ownerElement.isElement() ? (DOMElement) ownerElement : null; + return parent != null && parent.isElement() ? (DOMElement) parent : null; } @Override public DOMDocument getOwnerDocument() { - return ownerElement != null ? ownerElement.getOwnerDocument() : null; + return parent != null ? parent.getOwnerDocument() : null; } /* @@ -188,19 +176,18 @@ public void setValue(String value) throws DOMException { } public DOMRange getNodeAttrName() { - // Return a DOMRange implementation for the name - if (nameStart == NULL_VALUE) { + if (start == NULL_VALUE) { return null; } return new DOMRange() { @Override public int getStart() { - return nameStart; + return start; } @Override public int getEnd() { - return nameEnd; + return end; } @Override @@ -294,12 +281,11 @@ public String getPrefix() { */ @Override public String getNamespaceURI() { - if (ownerElement == null || ownerElement.getNodeType() != Node.ELEMENT_NODE) { + if (parent == null || parent.getNodeType() != Node.ELEMENT_NODE) { return null; } String prefix = getPrefix(); - // Try to get xmlns attribute from the element - return ((DOMElement) ownerElement).getNamespaceURI(prefix); + return ((DOMElement) parent).getNamespaceURI(prefix); } /** @@ -399,23 +385,15 @@ public boolean isIncluded(int offset) { return DOMNode.isIncluded(getStart(), getEnd(), offset); } - @Override - public int getStart() { - return nameStart; - } - @Override public int getEnd() { if (valueStart != NULL_VALUE) { - // return valueEnd; } if (hasDelimiter()) { - // return delimiter + 1; } - // - return nameEnd; + return end; } @Override diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java index 0a53a3fa8..35706f0c8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocumentType.java @@ -12,9 +12,12 @@ */ package org.eclipse.lemminx.dom; +import java.util.ArrayList; import java.util.List; +import org.w3c.dom.DOMException; import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; /** * A doctype node. @@ -26,7 +29,7 @@ public static enum DocumentTypeKind { PUBLIC, SYSTEM, INVALID } - private XMLNamedNodeMap entitiesNodes; + private List entitiesList; DTDDeclParameter kind; // SYSTEM || PUBLIC DTDDeclParameter publicId; @@ -104,16 +107,32 @@ public short getNodeType() { */ @Override public NamedNodeMap getEntities() { - if (entitiesNodes == null) { - entitiesNodes = new XMLNamedNodeMap<>(); + if (entitiesList == null) { + entitiesList = new ArrayList<>(); List children = super.getChildren(); for (DOMNode child : children) { if (child.getNodeType() == DOMNode.ENTITY_NODE) { - entitiesNodes.add((DTDEntityDecl) child); + entitiesList.add((DTDEntityDecl) child); } } } - return entitiesNodes; + return new EntityNamedNodeMap(entitiesList); + } + + private static final class EntityNamedNodeMap implements NamedNodeMap { + private final List entities; + EntityNamedNodeMap(List entities) { this.entities = entities; } + @Override public int getLength() { return entities.size(); } + @Override public Node item(int index) { return index >= 0 && index < entities.size() ? entities.get(index) : null; } + @Override public Node getNamedItem(String name) { + for (DTDEntityDecl e : entities) { if (name.equals(e.getNodeName())) return e; } + return null; + } + @Override public Node getNamedItemNS(String ns, String local) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node removeNamedItem(String n) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node removeNamedItemNS(String ns, String local) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node setNamedItem(Node n) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node setNamedItemNS(Node n) throws DOMException { throw new UnsupportedOperationException(); } } /* diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index eae23a2ec..04a5e0b44 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -22,6 +22,7 @@ import java.util.Objects; import org.eclipse.lemminx.dom.green.GreenElement; +import org.eclipse.lemminx.dom.green.GreenNode; import org.eclipse.lemminx.utils.StringUtils; import org.w3c.dom.DOMException; import org.w3c.dom.NodeList; @@ -35,12 +36,35 @@ public class DOMElement extends DOMNode implements org.w3c.dom.Element { GreenElement greenElement; + private volatile GreenNode lazyGreenNode; + private int lazyAbsStart; + int startTagOpenOffset = NULL_VALUE; // | public DOMElement(int start, int end) { super(start, end); } + @Override + void ensureChildren() { + if (lazyGreenNode != null) { + synchronized (this) { + if (lazyGreenNode != null) { + GreenNode green = lazyGreenNode; + int absStart = lazyAbsStart; + lazyGreenNode = null; + RedTreeBuilder.expandLazy(this, green, absStart); + } + } + } + } + + @Override + void setLazy(GreenNode green, int absStart) { + this.lazyGreenNode = green; + this.lazyAbsStart = absStart; + } + /* * (non-Javadoc) * diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index d74802814..649bf1a3c 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -17,7 +17,7 @@ import java.util.Collections; import java.util.List; import java.util.Objects; -import java.util.function.Function; +import java.util.function.Predicate; import org.eclipse.lemminx.dom.green.GreenNode; import org.w3c.dom.DOMException; @@ -67,7 +67,7 @@ public abstract class DOMNode implements Node, DOMRange { static final byte FLAG_SELF_CLOSED = 0x02; static final byte FLAG_WHITESPACE = 0x04; - private XMLNamedNodeMap attributeNodes; + DOMAttr[] attributeNodes; DOMNode[] children; final int start; // | @@ -77,9 +77,6 @@ public abstract class DOMNode implements Node, DOMRange { int cachedIndexInParent = -1; - volatile GreenNode lazyGreenNode; - int lazyAbsStart; - private static final NodeList EMPTY_CHILDREN = new NodeList() { @Override @@ -104,59 +101,20 @@ public Node item(int index) { } } - static class XMLNamedNodeMap extends ArrayList implements NamedNodeMap { - - private static final long serialVersionUID = 1L; - - XMLNamedNodeMap() { - super(4); - } - - @Override - public int getLength() { - return super.size(); - } - - @Override - public T getNamedItem(String name) { - for (T node : this) { - if (name.equals(node.getNodeName())) { - return node; - } - } + private static final class AttrNamedNodeMap implements NamedNodeMap { + private final DOMAttr[] attrs; + AttrNamedNodeMap(DOMAttr[] attrs) { this.attrs = attrs; } + @Override public int getLength() { return attrs.length; } + @Override public Node item(int index) { return index >= 0 && index < attrs.length ? attrs[index] : null; } + @Override public Node getNamedItem(String name) { + for (DOMAttr a : attrs) { if (name.equals(a.getNodeName())) return a; } return null; } - - @Override - public T getNamedItemNS(String name, String arg1) throws DOMException { - throw new UnsupportedOperationException(); - } - - @Override - public T item(int index) { - return super.get(index); - } - - @Override - public T removeNamedItem(String arg0) throws DOMException { - throw new UnsupportedOperationException(); - } - - @Override - public T removeNamedItemNS(String arg0, String arg1) throws DOMException { - throw new UnsupportedOperationException(); - } - - @Override - public T setNamedItem(org.w3c.dom.Node arg0) throws DOMException { - throw new UnsupportedOperationException(); - } - - @Override - public T setNamedItemNS(org.w3c.dom.Node arg0) throws DOMException { - throw new UnsupportedOperationException(); - } - + @Override public Node getNamedItemNS(String ns, String local) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node removeNamedItem(String n) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node removeNamedItemNS(String ns, String local) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node setNamedItem(Node n) throws DOMException { throw new UnsupportedOperationException(); } + @Override public Node setNamedItemNS(Node n) throws DOMException { throw new UnsupportedOperationException(); } } public DOMNode(int start, int end) { @@ -357,14 +315,14 @@ public static DOMNode findNodeOrAttrAt(DOMDocument document, int offset) { * @returns the least x for which p(x) is true or array.length if no element * full fills the given function. */ - private static int findFirst(List array, Function p) { + private static int findFirst(List array, Predicate p) { int low = 0, high = array.size(); if (high == 0) { - return 0; // no children + return 0; } while (low < high) { - int mid = (int) Math.floor((low + high) / 2); - if (p.apply(array.get(mid))) { + int mid = (low + high) >>> 1; + if (p.test(array.get(mid))) { high = mid; } else { low = mid + 1; @@ -434,11 +392,10 @@ public DOMAttr getAttributeAtIndex(int index) { if (!hasAttributes()) { return null; } - - if (index > attributeNodes.getLength() - 1) { + if (index < 0 || index >= attributeNodes.length) { return null; } - return attributeNodes.get(index); + return attributeNodes[index]; } public boolean hasAttribute(String name) { @@ -452,7 +409,7 @@ public boolean hasAttribute(String name) { */ @Override public boolean hasAttributes() { - return attributeNodes != null && attributeNodes.size() != 0; + return attributeNodes != null && attributeNodes.length > 0; } public void setAttribute(String name, String value) { @@ -466,13 +423,15 @@ public void setAttribute(String name, String value) { public void setAttributeNode(DOMAttr attr) { if (attributeNodes == null) { - attributeNodes = new XMLNamedNodeMap<>(); + attributeNodes = new DOMAttr[] { attr }; + } else { + attributeNodes = Arrays.copyOf(attributeNodes, attributeNodes.length + 1); + attributeNodes[attributeNodes.length - 1] = attr; } - attributeNodes.add(attr); } public List getAttributeNodes() { - return attributeNodes; + return attributeNodes != null ? Arrays.asList(attributeNodes) : null; } /** @@ -496,17 +455,10 @@ public List getChildrenWithAttributeValue(String name, String value) { return result; } - private void ensureChildren() { - if (lazyGreenNode != null) { - synchronized (this) { - if (lazyGreenNode != null) { - GreenNode green = lazyGreenNode; - int absStart = lazyAbsStart; - lazyGreenNode = null; - RedTreeBuilder.expandLazy(this, green, absStart); - } - } - } + void ensureChildren() { + } + + void setLazy(GreenNode green, int absStart) { } /** @@ -539,9 +491,6 @@ public void addChild(DOMNode child) { } void compactChildren() { - if (attributeNodes != null) { - attributeNodes.trimToSize(); - } } /** @@ -701,7 +650,7 @@ public DOMNode getLastChild() { */ @Override public NamedNodeMap getAttributes() { - return attributeNodes; + return attributeNodes != null ? new AttrNamedNodeMap(attributeNodes) : null; } /* diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java index 18dbde395..d1ad3debb 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java @@ -16,6 +16,7 @@ import java.util.ArrayList; import java.util.List; +import org.eclipse.lemminx.dom.green.GreenNode; import org.w3c.dom.Node; /** @@ -30,9 +31,11 @@ public class DTDDeclNode extends DOMNode { * ELEMENT, ATTLIST, ENTITY, or NOTATION */ - public DTDDeclParameter unrecognized; // holds all content after parsing goes wrong in a DTD declaration (ENTITY, - // ATTLIST, ...). - public DTDDeclParameter declType; // represents the actual name of the decl eg: ENTITY, ATTLIST, ... + public DTDDeclParameter unrecognized; + public DTDDeclParameter declType; + + private volatile GreenNode lazyGreenNode; + private int lazyAbsStart; private List parameters; private DTDDeclParameter name; @@ -41,6 +44,26 @@ public DTDDeclNode(int start, int end) { super(start, end); } + @Override + void ensureChildren() { + if (lazyGreenNode != null) { + synchronized (this) { + if (lazyGreenNode != null) { + GreenNode green = lazyGreenNode; + int absStart = lazyAbsStart; + lazyGreenNode = null; + RedTreeBuilder.expandLazy(this, green, absStart); + } + } + } + } + + @Override + void setLazy(GreenNode green, int absStart) { + this.lazyGreenNode = green; + this.lazyAbsStart = absStart; + } + public String getName() { DTDDeclParameter name = getNameParameter(); return name != null ? name.getParameter() : null; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 5fbb83598..2470b44f8 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -84,8 +84,7 @@ private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, private void addChildrenOrDefer(DOMNode node, GreenNode green, int absStart) { if (lazy && green.children().length > 0) { - node.lazyGreenNode = green; - node.lazyAbsStart = absStart; + node.setLazy(green, absStart); } else { addChildren(node, green, absStart); } @@ -186,9 +185,12 @@ private DOMElement createElement(GreenElement green, int absStart, int absEnd) { elem.setClosed(green.closed()); GreenAttr[] greenAttrs = green.attributes(); - for (GreenAttr ga : greenAttrs) { - DOMAttr attr = createAttr(ga, absStart, elem); - elem.setAttributeNode(attr); + if (greenAttrs.length > 0) { + DOMAttr[] attrs = new DOMAttr[greenAttrs.length]; + for (int i = 0; i < greenAttrs.length; i++) { + attrs[i] = createAttr(greenAttrs[i], absStart, elem); + } + elem.attributeNodes = attrs; } addChildrenOrDefer(elem, green, absStart); @@ -249,9 +251,12 @@ private static DOMProcessingInstruction createPI(GreenProcessingInstruction gree pi.setClosed(green.closed()); GreenAttr[] greenAttrs = green.attributes(); - for (GreenAttr ga : greenAttrs) { - DOMAttr attr = createAttr(ga, absStart, pi); - pi.setAttributeNode(attr); + if (greenAttrs.length > 0) { + DOMAttr[] attrs = new DOMAttr[greenAttrs.length]; + for (int i = 0; i < greenAttrs.length; i++) { + attrs[i] = createAttr(greenAttrs[i], absStart, pi); + } + pi.attributeNodes = attrs; } return pi; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java new file mode 100644 index 000000000..b1144b5e1 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java @@ -0,0 +1,277 @@ +/******************************************************************************* + * Copyright (c) 2026 Red Hat Inc. and others. + * All rights reserved. This program and the accompanying materials + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Red Hat Inc. - initial API and implementation + *******************************************************************************/ +package org.eclipse.lemminx.dom; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; + +import org.eclipse.lemminx.commons.TextDocument; +import org.junit.jupiter.api.Test; +import org.w3c.dom.NamedNodeMap; + +/** + * Tests for memory optimizations: DOMAttr field consolidation, + * DOMAttr[] attribute storage, lazy children deferred loading, + * and findFirst binary search. + */ +public class DOMMemoryOptimizationsTest { + + // --- DOMAttr field consolidation tests --- + + @Test + public void attrStartEndFromDocument() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("attr"); + assertNotNull(attr); + assertEquals(6, attr.getStart()); + assertEquals(18, attr.getEnd()); + } + + @Test + public void attrNameExtractedFromDocument() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("foo"); + assertNotNull(attr); + assertEquals("foo", attr.getName()); + } + + @Test + public void attrValueExtractedFromDocument() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("key"); + assertNotNull(attr); + assertEquals("val", attr.getValue()); + assertEquals("\"val\"", attr.getOriginalValue()); + } + + @Test + public void attrOwnerElementFromParent() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("attr"); + assertNotNull(attr); + assertEquals(root, attr.getOwnerElement()); + } + + @Test + public void attrOwnerDocumentFromParent() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("attr"); + assertNotNull(attr); + assertEquals(doc, attr.getOwnerDocument()); + } + + @Test + public void attrNodeAttrNameRange() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("myattr"); + assertNotNull(attr); + DOMRange nameRange = attr.getNodeAttrName(); + assertNotNull(nameRange); + assertEquals(6, nameRange.getStart()); + assertEquals(12, nameRange.getEnd()); + } + + @Test + public void attrWithoutValue() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("disabled"); + assertNotNull(attr); + assertEquals("disabled", attr.getName()); + assertNull(attr.getValue()); + assertEquals(6, attr.getStart()); + assertEquals(14, attr.getEnd()); + } + + @Test + public void attrWithDelimiterNoValue() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("attr"); + assertNotNull(attr); + assertTrue(attr.hasDelimiter()); + assertEquals(10, attr.getDelimiterOffset()); + } + + @Test + public void programmaticAttr() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + root.setAttribute("dynamic", "val"); + DOMAttr attr = root.getAttributeNode("dynamic"); + assertNotNull(attr); + assertEquals("dynamic", attr.getName()); + } + + @Test + public void attrNamespaceURI() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr nsAttr = root.getAttributeNode("ns:attr"); + assertNotNull(nsAttr); + assertEquals("ns", nsAttr.getPrefix()); + assertEquals("attr", nsAttr.getLocalName()); + } + + @Test + public void attrIsXmlns() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + DOMAttr attr = root.getAttributeNode("xmlns"); + assertNotNull(attr); + assertTrue(attr.isXmlns()); + assertTrue(attr.isDefaultXmlns()); + } + + // --- DOMAttr[] attribute storage tests --- + + @Test + public void attributeArrayMultipleAttrs() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertTrue(root.hasAttributes()); + List attrs = root.getAttributeNodes(); + assertEquals(3, attrs.size()); + assertEquals("a", attrs.get(0).getName()); + assertEquals("b", attrs.get(1).getName()); + assertEquals("c", attrs.get(2).getName()); + } + + @Test + public void attributeArrayGetByIndex() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertEquals("x", root.getAttributeAtIndex(0).getName()); + assertEquals("y", root.getAttributeAtIndex(1).getName()); + assertNull(root.getAttributeAtIndex(2)); + assertNull(root.getAttributeAtIndex(-1)); + } + + @Test + public void attributeArrayNamedNodeMap() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + NamedNodeMap map = root.getAttributes(); + assertNotNull(map); + assertEquals(2, map.getLength()); + assertNotNull(map.getNamedItem("id")); + assertNotNull(map.getNamedItem("class")); + assertNull(map.getNamedItem("nonexistent")); + assertEquals("id", map.item(0).getNodeName()); + } + + @Test + public void noAttributesReturnsNull() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertFalse(root.hasAttributes()); + assertNull(root.getAttributeNodes()); + assertNull(root.getAttributes()); + } + + @Test + public void attributeGetValue() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertEquals("hello world", root.getAttribute("key")); + assertNull(root.getAttribute("missing")); + } + + // --- Lazy children deferred loading tests --- + + @Test + public void lazyElementChildrenExpanded() { + DOMDocument doc = parseLazy(""); + DOMElement root = doc.getDocumentElement(); + assertTrue(root.hasChildNodes()); + List children = root.getChildren(); + assertEquals(2, children.size()); + assertTrue(children.get(0).isElement()); + assertEquals("child", ((DOMElement) children.get(0)).getTagName()); + } + + @Test + public void lazyNestedElements() { + DOMDocument doc = parseLazy(""); + DOMElement a = doc.getDocumentElement(); + assertEquals("a", a.getTagName()); + DOMElement b = (DOMElement) a.getFirstChild(); + assertEquals("b", b.getTagName()); + DOMElement c = (DOMElement) b.getFirstChild(); + assertEquals("c", c.getTagName()); + } + + @Test + public void lazyFindNodeAt() { + DOMDocument doc = parseLazy(""); + DOMNode node = doc.findNodeAt(7); + assertTrue(node.isElement()); + assertEquals("inner", ((DOMElement) node).getTagName()); + } + + @Test + public void lazyAttributesAccessible() { + DOMDocument doc = parseLazy(""); + DOMElement root = doc.getDocumentElement(); + DOMElement elem = (DOMElement) root.getFirstChild(); + assertTrue(elem.hasAttributes()); + assertEquals("val", elem.getAttribute("key")); + } + + // --- findFirst binary search tests --- + + @Test + public void findNodeBeforeInChildren() { + DOMDocument doc = parse(""); + DOMNode found = doc.findNodeBefore(12); + assertTrue(found.isElement()); + assertEquals("b", ((DOMElement) found).getTagName()); + } + + @Test + public void findNodeAtOffset() { + DOMDocument doc = parse(""); + DOMNode found = doc.findNodeAt(15); + assertTrue(found.isElement()); + assertEquals("second", ((DOMElement) found).getTagName()); + } + + @Test + public void findNodeBeforeAtDocStart() { + DOMDocument doc = parse(""); + DOMNode found = doc.findNodeBefore(1); + assertTrue(found.isElement()); + assertEquals("root", ((DOMElement) found).getTagName()); + } + + // --- Helpers --- + + private DOMDocument parse(String xml) { + return DOMParser.getInstance().parse(xml, "test://test.xml", null, true); + } + + private DOMDocument parseLazy(String xml) { + TextDocument textDoc = new TextDocument(xml, "test://test.xml"); + return DOMParser.getInstance().parse(textDoc, null, true, null); + } +} diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java new file mode 100644 index 000000000..aa990cd54 --- /dev/null +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java @@ -0,0 +1,174 @@ +package org.eclipse.lemminx.performance; + +import static org.eclipse.lemminx.utils.IOUtils.convertStreamToString; + +import java.io.InputStream; +import java.lang.management.ManagementFactory; +import java.util.Collections; + +import org.eclipse.lemminx.commons.ModelTextDocument; +import org.eclipse.lemminx.dom.DOMDocument; +import org.eclipse.lemminx.dom.DOMParser; +import org.eclipse.lemminx.dom.green.GreenDocument; +import org.eclipse.lsp4j.Position; +import org.eclipse.lsp4j.Range; +import org.eclipse.lsp4j.TextDocumentContentChangeEvent; + +public class MemoryBenchmark { + + public static void main(String[] args) throws Exception { + String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0]; + System.out.println("PID: " + pid); + System.out.println("Waiting 5s before start (attach profiler now)..."); + Thread.sleep(5000); + + InputStream in = MemoryBenchmark.class.getResourceAsStream("/xml/content.xml"); + String text = convertStreamToString(in); + System.out.println("File size: " + text.length() + " chars"); + + ModelTextDocument doc = new ModelTextDocument<>(text, "file:///content.xml", + (document, cancelChecker) -> { + if (document instanceof ModelTextDocument) { + @SuppressWarnings("unchecked") + ModelTextDocument mtd = (ModelTextDocument) document; + Object prevData = mtd.getPreviousIncrementalData(); + ModelTextDocument.EditInfo editInfo = mtd.getPendingEdit(); + if (prevData instanceof GreenDocument && editInfo != null) { + return DOMParser.getInstance().parseIncremental(document, + (GreenDocument) prevData, + editInfo.getStartOffset(), + editInfo.getDeleteLength(), + editInfo.getInsertLength(), + null, true, cancelChecker); + } + } + return DOMParser.getInstance().parse(document, null, true, cancelChecker); + }, + DOMDocument::getGreenDocument); + doc.setIncremental(true); + + // Phase 1: initial parse + System.out.println("\n=== Phase 1: Initial parse ==="); + long start = System.currentTimeMillis(); + DOMDocument model = doc.getModel(); + long parseTime = System.currentTimeMillis() - start; + System.out.println("Parse time: " + parseTime + " ms"); + System.out.println("Elements: " + countElements(model)); + System.gc(); + Thread.sleep(1000); + System.out.println(">> SNAPSHOT 1: after initial parse. Waiting 60s..."); + Thread.sleep(60000); + + // Phase 2: single edit + reparse + System.out.println("\n=== Phase 2: Single edit (insert 'X' at pos 100) ==="); + int version = 1; + doc.setVersion(version); + doc.update(Collections.singletonList( + new TextDocumentContentChangeEvent( + new Range(new Position(0, 100), new Position(0, 100)), "X"))); + start = System.currentTimeMillis(); + model = doc.getModel(); + parseTime = System.currentTimeMillis() - start; + System.out.println("Incremental parse time: " + parseTime + " ms"); + System.gc(); + Thread.sleep(1000); + System.out.println(">> SNAPSHOT 2: after 1 incremental edit. Press Enter to continue..."); + Thread.sleep(15000); + + // Phase 3: rapid edits (simulate typing) + System.out.println("\n=== Phase 3: 10 rapid edits (simulate fast typing) ==="); + for (int i = 0; i < 10; i++) { + version++; + doc.setVersion(version); + doc.update(Collections.singletonList( + new TextDocumentContentChangeEvent( + new Range(new Position(0, 100 + i), new Position(0, 100 + i)), "Y"))); + } + start = System.currentTimeMillis(); + model = doc.getModel(); + parseTime = System.currentTimeMillis() - start; + System.out.println("Parse time after 10 merged edits: " + parseTime + " ms"); + System.gc(); + Thread.sleep(1000); + System.out.println(">> SNAPSHOT 3: after 10 rapid edits. Press Enter to continue..."); + Thread.sleep(15000); + + // Phase 4: many edit cycles + System.out.println("\n=== Phase 4: 50 edit-parse cycles ==="); + long totalParseTime = 0; + for (int i = 0; i < 50; i++) { + version++; + doc.setVersion(version); + doc.update(Collections.singletonList( + new TextDocumentContentChangeEvent( + new Range(new Position(0, 100), new Position(0, 100)), "Z"))); + start = System.currentTimeMillis(); + model = doc.getModel(); + totalParseTime += System.currentTimeMillis() - start; + } + System.out.println("Avg incremental parse time: " + (totalParseTime / 50) + " ms"); + System.gc(); + Thread.sleep(1000); + System.out.println(">> SNAPSHOT 4: after 50 edit-parse cycles. Press Enter to continue..."); + Thread.sleep(15000); + + // Phase 5: steady state + System.out.println("\n=== Phase 5: Steady state (walk the tree) ==="); + start = System.currentTimeMillis(); + int nodeCount = walkTree(model); + System.out.println("Walked " + nodeCount + " nodes in " + (System.currentTimeMillis() - start) + " ms"); + System.gc(); + Thread.sleep(1000); + System.out.println(">> SNAPSHOT 5: after tree walk. Press Enter to exit..."); + Thread.sleep(15000); + + System.out.println("Done."); + } + + private static int countElements(DOMDocument doc) { + int count = 0; + for (int i = 0; i < doc.getChildren().size(); i++) { + count += countNodes(doc.getChildren().get(i)); + } + return count; + } + + private static int countNodes(org.eclipse.lemminx.dom.DOMNode node) { + int count = 1; + if (node.hasChildNodes()) { + for (int i = 0; i < node.getChildren().size(); i++) { + count += countNodes(node.getChildren().get(i)); + } + } + return count; + } + + private static int walkTree(DOMDocument doc) { + int count = 0; + for (int i = 0; i < doc.getChildren().size(); i++) { + count += walkNode(doc.getChildren().get(i)); + } + return count; + } + + private static int walkNode(org.eclipse.lemminx.dom.DOMNode node) { + int count = 1; + node.getStart(); + node.getEnd(); + if (node.isElement()) { + org.eclipse.lemminx.dom.DOMElement elem = (org.eclipse.lemminx.dom.DOMElement) node; + elem.getTagName(); + elem.getStartTagCloseOffset(); + elem.getEndTagOpenOffset(); + if (elem.hasAttributes()) { + elem.getAttributeNodes(); + } + } + if (node.hasChildNodes()) { + for (int i = 0; i < node.getChildren().size(); i++) { + count += walkNode(node.getChildren().get(i)); + } + } + return count; + } +} From 18515a91972947fb2fa41df8f31f7768ac7054f2 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 12:51:25 +0200 Subject: [PATCH 15/18] Derive endTagCloseRel from flag and optimize text-only incremental edits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Remove endTagCloseRel field from GreenElement, derive from width and extraFlag (GreenElement 40→32 bytes, saves ~2 MB for 246K elements) - Add EXTRA_FLAG to GreenNode for endTagHasClose boolean encoding - Optimize IncrementalParser to handle text-only edits without full reparse when the edited region contains no '<' characters - Update DOMParserTest helper to match new GreenElement constructor Co-Authored-By: Claude Opus 4.6 --- .../lemminx/dom/green/GreenElement.java | 16 +++++++++------- .../lemminx/dom/green/GreenElementBuilder.java | 10 ++++------ .../eclipse/lemminx/dom/green/GreenNode.java | 7 ++++++- .../lemminx/dom/green/GreenTreeBuilder.java | 13 ++++++------- .../lemminx/dom/green/IncrementalParser.java | 18 +++++++++++++++++- .../org/eclipse/lemminx/dom/DOMParserTest.java | 2 +- 6 files changed, 43 insertions(+), 23 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 5c2aa2a07..2daa203fd 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -27,18 +27,17 @@ public final class GreenElement extends GreenNode { private final String tag; private final int startTagCloseRel; private final int endTagOpenRel; - private final int endTagCloseRel; private final GreenAttr[] attributes; private final GreenNode[] children; public GreenElement(int width, boolean closed, String tag, boolean selfClosed, - int startTagCloseRel, int endTagOpenRel, int endTagCloseRel, + int startTagCloseRel, int endTagOpenRel, boolean endTagHasClose, GreenAttr[] attributes, GreenNode[] children) { - super(width, (closed ? CLOSED_FLAG : 0) | (selfClosed ? SUBCLASS_FLAG : 0)); + super(width, (closed ? CLOSED_FLAG : 0) | (selfClosed ? SUBCLASS_FLAG : 0) + | (endTagHasClose ? EXTRA_FLAG : 0)); this.tag = tag; this.startTagCloseRel = startTagCloseRel; this.endTagOpenRel = endTagOpenRel; - this.endTagCloseRel = endTagCloseRel; this.attributes = attributes != null ? attributes : EMPTY_ATTRS; this.children = children != null ? children : EMPTY_CHILDREN; } @@ -65,7 +64,10 @@ public int endTagOpenRel() { } public int endTagCloseRel() { - return endTagCloseRel; + if (!extraFlag()) { + return NULL_VALUE; + } + return width() - 1; } public GreenAttr[] attributes() { @@ -104,14 +106,14 @@ public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { width() + widthDelta, closed(), tag, selfClosed(), startTagCloseRel, endTagOpenRel != NULL_VALUE ? endTagOpenRel + widthDelta : NULL_VALUE, - endTagCloseRel != NULL_VALUE ? endTagCloseRel + widthDelta : NULL_VALUE, + extraFlag(), attributes, newChildren); } @Override protected GreenNode replaceChildren(GreenNode[] newChildren, int newWidth) { return new GreenElement(newWidth, closed(), tag, selfClosed(), - startTagCloseRel, endTagOpenRel, endTagCloseRel, + startTagCloseRel, endTagOpenRel, extraFlag(), attributes, newChildren); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java index 537535043..d8b66be43 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElementBuilder.java @@ -29,7 +29,7 @@ public final class GreenElementBuilder { private boolean closed; private int startTagCloseOffset = GreenElement.NULL_VALUE; private int endTagOpenOffset = GreenElement.NULL_VALUE; - private int endTagCloseOffset = GreenElement.NULL_VALUE; + private boolean endTagHasClose; private GreenAttr[] attributes; private int attrCount; private GreenNode[] children; @@ -76,8 +76,8 @@ public void setEndTagOpenOffset(int offset) { this.endTagOpenOffset = offset; } - public void setEndTagCloseOffset(int offset) { - this.endTagCloseOffset = offset; + public void setEndTagHasClose(boolean endTagHasClose) { + this.endTagHasClose = endTagHasClose; } public void addAttribute(GreenAttr attr) { @@ -108,8 +108,6 @@ public GreenElement build() { ? startTagCloseOffset - nodeStart : GreenElement.NULL_VALUE; int etoRel = endTagOpenOffset != GreenElement.NULL_VALUE ? endTagOpenOffset - nodeStart : GreenElement.NULL_VALUE; - int etcRel = endTagCloseOffset != GreenElement.NULL_VALUE - ? endTagCloseOffset - nodeStart : GreenElement.NULL_VALUE; GreenAttr[] attrs = attributes != null ? (attrCount == attributes.length ? attributes : Arrays.copyOf(attributes, attrCount)) @@ -119,6 +117,6 @@ public GreenElement build() { : null; return new GreenElement(width, closed, tag, selfClosed, - stcRel, etoRel, etcRel, attrs, kids); + stcRel, etoRel, endTagHasClose, attrs, kids); } } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java index 3ac420869..43ce1d7b6 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenNode.java @@ -29,7 +29,8 @@ public abstract class GreenNode { static final int CLOSED_FLAG = 1 << 31; static final int SUBCLASS_FLAG = 1 << 30; - private static final int WIDTH_MASK = 0x3FFFFFFF; + static final int EXTRA_FLAG = 1 << 29; + private static final int WIDTH_MASK = 0x1FFFFFFF; private final int widthAndFlags; @@ -51,6 +52,10 @@ protected final boolean subclassFlag() { return (widthAndFlags & SUBCLASS_FLAG) != 0; } + protected final boolean extraFlag() { + return (widthAndFlags & EXTRA_FLAG) != 0; + } + public GreenNode[] children() { return EMPTY_CHILDREN; } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java index f6b4f6e4e..79450119f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenTreeBuilder.java @@ -112,6 +112,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, linkToEmptyStartTag = true; top.closed = true; top.endTagOpenOffset = endTagOpenOffset; + top.endTagHasClose = true; top.nodeEnd = scanner.getTokenEnd(); } } @@ -119,7 +120,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, if (token != TokenType.EndTag && !linkToEmptyStartTag) { GreenElement fakeEndTag = new GreenElement( 2, false, null, false, - GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, 0, false, null, null); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); } @@ -263,9 +264,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, if (!stack.isEmpty()) { NodeBuilder top = stack.peek(); top.nodeEnd = scanner.getTokenEnd(); - if (top.kind == NodeKind.ELEMENT) { - top.endTagCloseOffset = scanner.getTokenOffset(); - } + top.endTagHasClose = true; if (top.kind == NodeKind.DOCUMENT_TYPE) { top.closed = true; } @@ -808,7 +807,7 @@ public static GreenDocument parseRange(CharSequence text, String uri, if (previousTokenWasEndTagOpen) { GreenElement fakeEndTag = new GreenElement( 2, false, null, false, - GreenElement.NULL_VALUE, 0, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, 0, false, null, null); addChildToCurrentOrRoot(stack, rootChildren, nextRootChildEnd, fakeEndTag, endTagOpenOffset); } @@ -908,7 +907,7 @@ static final class NodeBuilder { int startTagOpenOffset = GreenElement.NULL_VALUE; int startTagCloseOffset = GreenElement.NULL_VALUE; int endTagOpenOffset = GreenElement.NULL_VALUE; - int endTagCloseOffset = GreenElement.NULL_VALUE; + boolean endTagHasClose; GreenAttr[] attributes; int attrCount; @@ -1054,7 +1053,7 @@ private GreenElement buildElement(int width, GreenNode[] kids) { : null; return new GreenElement(width, closed, tag, selfClosed, rel(startTagCloseOffset), rel(endTagOpenOffset), - rel(endTagCloseOffset), attrs, kids); + endTagHasClose, attrs, kids); } private GreenComment buildComment(int width) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java index 32c33de6c..d39f30b3a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/IncrementalParser.java @@ -106,7 +106,14 @@ private static GreenNode[] tryIncrementalOnChildren( int middleCount = oldChildren.length - prefixCount - suffixCount; if (middleCount == 1) { GreenNode middleChild = oldChildren[prefixCount]; - if (middleChild instanceof GreenElement && middleChild.childCount() > 0) { + if (middleChild instanceof GreenText) { + int insertEnd = editEnd + delta; + if (!containsLessThan(newText, editStart, insertEnd)) { + GreenNode newText2 = new GreenText(middleChild.width() + delta, false); + return splice(oldChildren, prefixCount, suffixCount, + new GreenNode[] { newText2 }); + } + } else if (middleChild instanceof GreenElement && middleChild.childCount() > 0) { GreenElement elem = (GreenElement) middleChild; int elemAbsStart = childrenAbsStart + prefixWidth; GreenElement newElem = tryDescentIntoElement( @@ -235,6 +242,15 @@ private static GreenNode[] coalesceAdjacentText(GreenNode[] nodes) { return result; } + private static boolean containsLessThan(CharSequence text, int from, int to) { + for (int i = from; i < to; i++) { + if (text.charAt(i) == '<') { + return true; + } + } + return false; + } + private static int childrenWidth(GreenNode[] children) { int w = 0; for (GreenNode child : children) { diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java index bf8830ff1..b81573ed2 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java @@ -1222,7 +1222,7 @@ private static void setRestOfNode(DOMNode n, String tag, Integer endTagStart, bo int width = n.end - n.start; int endTagOpenRel = endTagStart != null ? endTagStart - n.start : GreenElement.NULL_VALUE; elem.greenElement = new GreenElement(width, closed, tag, false, - GreenElement.NULL_VALUE, endTagOpenRel, GreenElement.NULL_VALUE, + GreenElement.NULL_VALUE, endTagOpenRel, closed && endTagOpenRel != GreenElement.NULL_VALUE, null, null); boolean isOrphanEndTag = endTagOpenRel == 0; elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : n.start; From 649928db8645569eb34294803922b31cbe9f83b9 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 13:15:37 +0200 Subject: [PATCH 16/18] Move attributeNodes from DOMNode to DOMElement/PI saving 4.4 MB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit DOMAttr (546K instances) inherited an unused attributeNodes field from DOMNode. Moving it to DOMElement and DOMProcessingInstruction (the only types that use attributes) drops DOMAttr from 64 to 56 bytes per instance. Verified with heap histogram: 546K × 8B = 4.4 MB saved. Co-Authored-By: Claude Opus 4.6 --- .../org/eclipse/lemminx/dom/DOMElement.java | 39 ++++++++++++++++++ .../java/org/eclipse/lemminx/dom/DOMNode.java | 31 ++++---------- .../lemminx/dom/DOMProcessingInstruction.java | 41 +++++++++++++++++++ .../dom/DOMMemoryOptimizationsTest.java | 33 +++++++++++++++ .../lemminx/performance/MemoryBenchmark.java | 4 +- 5 files changed, 124 insertions(+), 24 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index 04a5e0b44..388f361a4 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -16,6 +16,7 @@ import static org.eclipse.lemminx.dom.DOMAttr.XMLNS_NO_DEFAULT_ATTR; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -25,6 +26,7 @@ import org.eclipse.lemminx.dom.green.GreenNode; import org.eclipse.lemminx.utils.StringUtils; import org.w3c.dom.DOMException; +import org.w3c.dom.NamedNodeMap; import org.w3c.dom.NodeList; import org.w3c.dom.TypeInfo; @@ -35,6 +37,7 @@ public class DOMElement extends DOMNode implements org.w3c.dom.Element { GreenElement greenElement; + DOMAttr[] attributeNodes; private volatile GreenNode lazyGreenNode; private int lazyAbsStart; @@ -65,6 +68,42 @@ void setLazy(GreenNode green, int absStart) { this.lazyAbsStart = absStart; } + @Override + public boolean hasAttributes() { + return attributeNodes != null && attributeNodes.length > 0; + } + + @Override + public void setAttributeNode(DOMAttr attr) { + if (attributeNodes == null) { + attributeNodes = new DOMAttr[] { attr }; + } else { + attributeNodes = Arrays.copyOf(attributeNodes, attributeNodes.length + 1); + attributeNodes[attributeNodes.length - 1] = attr; + } + } + + @Override + public List getAttributeNodes() { + return attributeNodes != null ? Arrays.asList(attributeNodes) : null; + } + + @Override + public DOMAttr getAttributeAtIndex(int index) { + if (!hasAttributes()) { + return null; + } + if (index < 0 || index >= attributeNodes.length) { + return null; + } + return attributeNodes[index]; + } + + @Override + public NamedNodeMap getAttributes() { + return attributeNodes != null ? new AttrNamedNodeMap(attributeNodes) : null; + } + /* * (non-Javadoc) * diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index 649bf1a3c..bdc35ef1f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -67,7 +67,6 @@ public abstract class DOMNode implements Node, DOMRange { static final byte FLAG_SELF_CLOSED = 0x02; static final byte FLAG_WHITESPACE = 0x04; - DOMAttr[] attributeNodes; DOMNode[] children; final int start; // | @@ -101,7 +100,7 @@ public Node item(int index) { } } - private static final class AttrNamedNodeMap implements NamedNodeMap { + static final class AttrNamedNodeMap implements NamedNodeMap { private final DOMAttr[] attrs; AttrNamedNodeMap(DOMAttr[] attrs) { this.attrs = attrs; } @Override public int getLength() { return attrs.length; } @@ -341,6 +340,9 @@ public DOMAttr getAttributeNode(String name) { * If there is no namespace, set prefix to null. */ public DOMAttr getAttributeNode(String prefix, String suffix) { + if (!hasAttributes()) { + return null; + } StringBuilder sb = new StringBuilder(); if (prefix != null) { sb.append(prefix); @@ -348,10 +350,7 @@ public DOMAttr getAttributeNode(String prefix, String suffix) { } sb.append(suffix); String name = sb.toString(); - if (!hasAttributes()) { - return null; - } - for (DOMAttr attr : attributeNodes) { + for (DOMAttr attr : getAttributeNodes()) { if (name.equals(attr.getName())) { return attr; } @@ -389,13 +388,7 @@ public String getAttribute(String name) { * @return */ public DOMAttr getAttributeAtIndex(int index) { - if (!hasAttributes()) { - return null; - } - if (index < 0 || index >= attributeNodes.length) { - return null; - } - return attributeNodes[index]; + return null; } public boolean hasAttribute(String name) { @@ -409,7 +402,7 @@ public boolean hasAttribute(String name) { */ @Override public boolean hasAttributes() { - return attributeNodes != null && attributeNodes.length > 0; + return false; } public void setAttribute(String name, String value) { @@ -422,16 +415,10 @@ public void setAttribute(String name, String value) { } public void setAttributeNode(DOMAttr attr) { - if (attributeNodes == null) { - attributeNodes = new DOMAttr[] { attr }; - } else { - attributeNodes = Arrays.copyOf(attributeNodes, attributeNodes.length + 1); - attributeNodes[attributeNodes.length - 1] = attr; - } } public List getAttributeNodes() { - return attributeNodes != null ? Arrays.asList(attributeNodes) : null; + return null; } /** @@ -650,7 +637,7 @@ public DOMNode getLastChild() { */ @Override public NamedNodeMap getAttributes() { - return attributeNodes != null ? new AttrNamedNodeMap(attributeNodes) : null; + return null; } /* diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMProcessingInstruction.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMProcessingInstruction.java index 1463e8809..34d3fb822 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMProcessingInstruction.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMProcessingInstruction.java @@ -12,7 +12,11 @@ */ package org.eclipse.lemminx.dom; +import java.util.Arrays; +import java.util.List; + import org.w3c.dom.DOMException; +import org.w3c.dom.NamedNodeMap; /** * A processing instruction node. @@ -20,6 +24,7 @@ */ public class DOMProcessingInstruction extends DOMCharacterData implements org.w3c.dom.ProcessingInstruction { + DOMAttr[] attributeNodes; boolean startTagClose; String target; boolean prolog = false; @@ -32,6 +37,42 @@ public DOMProcessingInstruction(int start, int end) { super(start, end); } + @Override + public boolean hasAttributes() { + return attributeNodes != null && attributeNodes.length > 0; + } + + @Override + public void setAttributeNode(DOMAttr attr) { + if (attributeNodes == null) { + attributeNodes = new DOMAttr[] { attr }; + } else { + attributeNodes = Arrays.copyOf(attributeNodes, attributeNodes.length + 1); + attributeNodes[attributeNodes.length - 1] = attr; + } + } + + @Override + public List getAttributeNodes() { + return attributeNodes != null ? Arrays.asList(attributeNodes) : null; + } + + @Override + public DOMAttr getAttributeAtIndex(int index) { + if (!hasAttributes()) { + return null; + } + if (index < 0 || index >= attributeNodes.length) { + return null; + } + return attributeNodes[index]; + } + + @Override + public NamedNodeMap getAttributes() { + return attributeNodes != null ? new AttrNamedNodeMap(attributeNodes) : null; + } + public boolean isProlog() { return prolog; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java index b1144b5e1..c7e0502c0 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java @@ -264,6 +264,39 @@ public void findNodeBeforeAtDocStart() { assertEquals("root", ((DOMElement) found).getTagName()); } + // --- attributeNodes field scoping tests --- + + @Test + public void textNodeHasNoAttributes() { + DOMDocument doc = parse("hello"); + DOMNode text = doc.getDocumentElement().getFirstChild(); + assertTrue(text.isText()); + assertFalse(text.hasAttributes()); + assertNull(text.getAttributeNodes()); + assertNull(text.getAttributes()); + assertNull(text.getAttributeAtIndex(0)); + } + + @Test + public void prologHasAttributes() { + DOMDocument doc = parse(""); + DOMNode prolog = doc.getFirstChild(); + assertTrue(prolog.isProlog()); + assertTrue(prolog.hasAttributes()); + assertEquals("1.0", prolog.getAttribute("version")); + assertEquals("UTF-8", prolog.getAttribute("encoding")); + } + + @Test + public void setAttributeOnElement() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertFalse(root.hasAttributes()); + root.setAttribute("key", "val"); + assertTrue(root.hasAttributes()); + assertEquals("val", root.getAttribute("key")); + } + // --- Helpers --- private DOMDocument parse(String xml) { diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java index aa990cd54..559e74bc1 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/performance/MemoryBenchmark.java @@ -119,8 +119,8 @@ public static void main(String[] args) throws Exception { System.out.println("Walked " + nodeCount + " nodes in " + (System.currentTimeMillis() - start) + " ms"); System.gc(); Thread.sleep(1000); - System.out.println(">> SNAPSHOT 5: after tree walk. Press Enter to exit..."); - Thread.sleep(15000); + System.out.println(">> SNAPSHOT 5: after tree walk. Waiting 120s..."); + Thread.sleep(120000); System.out.println("Done."); } From 44ab703392f8e4490f7aba2419b343277d83f601 Mon Sep 17 00:00:00 2001 From: azerr Date: Sun, 6 Sep 2026 20:22:07 +0200 Subject: [PATCH 17/18] Eliminate getText() materialization: use CharSequence throughout Migrate ILineTracker.set() and all implementations from String to CharSequence so createLineTracker() uses getTextSequence() instead of getText(), avoiding StringBuilder-to-String conversion. Add CharSequenceReader for SAX InputSource, migrate all hot-path getText() callers (DTDValidator, XSDValidator, DOMUtils, XMLSyntaxErrorCode, DOMDocument.getTrimmedRange) to getTextSequence(). Deprecate getText() on TextDocument and DOMDocument. Add compact children storage for GreenElement (null/single/array) to avoid GreenNode[] allocation for single-child elements. Co-Authored-By: Claude Opus 4.6 --- .../lemminx/commons/ArrayLineTracker.java | 2 +- .../lemminx/commons/CharSequenceReader.java | 50 +++++++++++ .../eclipse/lemminx/commons/ILineTracker.java | 2 +- .../lemminx/commons/ListLineTracker.java | 6 +- .../eclipse/lemminx/commons/TextDocument.java | 15 +++- .../lemminx/commons/TreeLineTracker.java | 4 +- .../org/eclipse/lemminx/dom/DOMDocument.java | 17 +++- .../org/eclipse/lemminx/dom/DOMElement.java | 33 ++++++-- .../java/org/eclipse/lemminx/dom/DOMNode.java | 52 +++++++----- .../org/eclipse/lemminx/dom/DTDDeclNode.java | 17 +++- .../eclipse/lemminx/dom/RedTreeBuilder.java | 25 +++--- .../lemminx/dom/green/GreenElement.java | 35 ++++++-- .../participants/XMLSyntaxErrorCode.java | 16 +++- .../diagnostics/DTDValidator.java | 7 +- .../diagnostics/XSDValidator.java | 7 +- .../services/format/XMLFormatterDocument.java | 4 - .../org/eclipse/lemminx/utils/DOMUtils.java | 6 +- .../dom/DOMMemoryOptimizationsTest.java | 70 ++++++++++++++++ .../eclipse/lemminx/dom/DOMParserTest.java | 2 - .../dom/green/GreenTreeBuilderTest.java | 84 +++++++++++++++++++ 20 files changed, 372 insertions(+), 82 deletions(-) create mode 100644 org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/CharSequenceReader.java diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java index c2f2316f4..4878dce8a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ArrayLineTracker.java @@ -50,7 +50,7 @@ public ArrayLineTracker() { } @Override - public void set(String text) { + public void set(CharSequence text) { textLength = text != null ? text.length() : 0; int count = 1; if (text != null) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/CharSequenceReader.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/CharSequenceReader.java new file mode 100644 index 000000000..23ea5ec3b --- /dev/null +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/CharSequenceReader.java @@ -0,0 +1,50 @@ +/** + * Copyright (c) 2026 Angelo ZERR. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v2.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v20.html + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Angelo Zerr - initial API and implementation + */ +package org.eclipse.lemminx.commons; + +import java.io.Reader; + +/** + * A {@link Reader} that reads from a {@link CharSequence} without + * materializing it to a {@link String}. This avoids a costly copy + * when the backing sequence is a {@link StringBuilder}. + */ +public final class CharSequenceReader extends Reader { + + private final CharSequence cs; + private int pos; + private final int length; + + public CharSequenceReader(CharSequence cs) { + this.cs = cs; + this.length = cs.length(); + } + + @Override + public int read(char[] cbuf, int off, int len) { + int remaining = length - pos; + if (remaining <= 0) { + return -1; + } + int n = Math.min(len, remaining); + for (int i = 0; i < n; i++) { + cbuf[off + i] = cs.charAt(pos + i); + } + pos += n; + return n; + } + + @Override + public void close() { + } +} diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ILineTracker.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ILineTracker.java index 455334bee..581e58ce2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ILineTracker.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ILineTracker.java @@ -142,7 +142,7 @@ public interface ILineTracker { * * @param text the new tracked text */ - void set(String text); + void set(CharSequence text); Position getPositionAt(int position) throws BadLocationException; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ListLineTracker.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ListLineTracker.java index fe7639011..ac46d39d1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ListLineTracker.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/ListLineTracker.java @@ -343,7 +343,7 @@ public final String getLineDelimiter(int line) throws BadLocationException { * @param offset the offset in the given text * @return the information of the first found delimiter or null */ - protected DelimiterInfo nextDelimiterInfo(String text, int offset) { + protected DelimiterInfo nextDelimiterInfo(CharSequence text, int offset) { char ch; int length = text.length(); for (int i = offset; i < length; i++) { @@ -389,7 +389,7 @@ protected DelimiterInfo nextDelimiterInfo(String text, int offset) { * @param offset the offset of all newly created lines * @return the number of newly created lines */ - private int createLines(String text, int insertPosition, int offset) { + private int createLines(CharSequence text, int insertPosition, int offset) { int count = 0; int start = 0; @@ -432,7 +432,7 @@ public final void replace(int position, int length, String text) throws BadLocat } @Override - public final void set(String text) { + public final void set(CharSequence text) { fLines.clear(); if (text != null) { fTextLength = text.length(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java index b0cc57424..140de50e1 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TextDocument.java @@ -57,7 +57,11 @@ public TextDocument(String text, String uri) { /** * Returns the text content as a {@link String}. Prefer * {@link #getTextSequence()} which avoids costly string materialization. + * + * @deprecated Use {@link #getTextSequence()} instead to avoid allocating + * a full String copy of the document text. */ + @Deprecated @Override public String getText() { synchronized (lock) { @@ -66,8 +70,6 @@ public String getText() { } if (textBuffer != null) { cachedText = textBuffer.toString(); - textBuffer = null; - super.setText(cachedText); return cachedText; } } @@ -191,7 +193,7 @@ private synchronized ILineTracker createLineTracker() { return lineTracker; } ILineTracker lineTracker = isIncremental() ? new ArrayLineTracker() : new ListLineTracker(); - lineTracker.set(getText()); + lineTracker.set(getTextSequence()); return lineTracker; } @@ -211,7 +213,12 @@ public void update(List changes) { long start = System.currentTimeMillis(); synchronized (lock) { if (textBuffer == null) { - textBuffer = new StringBuilder(getText()); + String currentText = getText(); + int len = currentText.length(); + textBuffer = new StringBuilder(len + Math.max(1024, len >> 3)); + textBuffer.append(currentText); + cachedText = null; + super.setText(""); } for (int i = 0; i < changes.size(); i++) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TreeLineTracker.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TreeLineTracker.java index 86a7cccdb..b3141cf70 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TreeLineTracker.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/commons/TreeLineTracker.java @@ -1416,10 +1416,10 @@ public final Line getLineInformation(int line) throws BadLocationException { } @Override - public final void set(String text) { + public final void set(CharSequence text) { fRoot = new Node(0, NO_DELIM); try { - replace(0, 0, text); + replace(0, 0, text.toString()); } catch (BadLocationException x) { throw new InternalError(); } diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java index a1e069e73..2d3b5539d 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMDocument.java @@ -67,6 +67,7 @@ public class DOMDocument extends DOMNode implements Document { private CancelChecker cancelChecker; private String externalGrammarFromNamespaceURI; private volatile GreenDocument greenDocument; + DOMNode[] children; public DOMDocument(TextDocument textDocument, URIResolverExtensionManager resolverExtensionManager) { super(0, textDocument.getTextSequence().length()); @@ -75,6 +76,16 @@ public DOMDocument(TextDocument textDocument, URIResolverExtensionManager resolv resetGrammar(); } + @Override + DOMNode[] getChildrenArray() { + return children; + } + + @Override + void setChildrenArray(DOMNode[] c) { + this.children = c; + } + public void setCancelChecker(CancelChecker cancelChecker) { this.cancelChecker = cancelChecker; } @@ -144,7 +155,11 @@ public String getNamespaceURI() { /** * Returns the text content as a {@link String}. Prefer * {@link #getTextSequence()} which avoids costly string materialization. + * + * @deprecated Use {@link #getTextSequence()} instead to avoid allocating + * a full String copy of the document text. */ + @Deprecated public String getText() { return textDocument.getText(); } @@ -910,7 +925,7 @@ public Range getTrimmedRange(Range range) { } public Range getTrimmedRange(int start, int end) { - String text = getText(); + CharSequence text = getTextSequence(); char c = text.charAt(start); while (Character.isWhitespace(c)) { start++; diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java index 388f361a4..e8560d06a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMElement.java @@ -38,25 +38,32 @@ public class DOMElement extends DOMNode implements org.w3c.dom.Element { GreenElement greenElement; DOMAttr[] attributeNodes; + DOMNode[] children; private volatile GreenNode lazyGreenNode; - private int lazyAbsStart; - - int startTagOpenOffset = NULL_VALUE; // | public DOMElement(int start, int end) { super(start, end); } + @Override + DOMNode[] getChildrenArray() { + return children; + } + + @Override + void setChildrenArray(DOMNode[] c) { + this.children = c; + } + @Override void ensureChildren() { if (lazyGreenNode != null) { synchronized (this) { if (lazyGreenNode != null) { GreenNode green = lazyGreenNode; - int absStart = lazyAbsStart; lazyGreenNode = null; - RedTreeBuilder.expandLazy(this, green, absStart); + RedTreeBuilder.expandLazy(this, green, start); } } } @@ -65,7 +72,6 @@ void ensureChildren() { @Override void setLazy(GreenNode green, int absStart) { this.lazyGreenNode = green; - this.lazyAbsStart = absStart; } @Override @@ -342,12 +348,13 @@ public boolean isSameTag(String tag) { } public boolean isInStartTag(int offset) { + int stoOffset = getStartTagOpenOffset(); int stcOffset = getStartTagCloseOffset(); - if (startTagOpenOffset == NULL_VALUE || stcOffset == NULL_VALUE) { + if (stoOffset == NULL_VALUE || stcOffset == NULL_VALUE) { // case <| return true; } - if (offset > startTagOpenOffset && offset <= stcOffset) { + if (offset > stoOffset && offset <= stcOffset) { // case return true; } @@ -383,7 +390,15 @@ public boolean isInInsideStartEndTag(int offset) { * doesn't exist. */ public int getStartTagOpenOffset() { - return startTagOpenOffset; + if (greenElement == null) { + return NULL_VALUE; + } + int eto = greenElement.endTagOpenRel(); + if (eto != GreenElement.NULL_VALUE && eto == 0 + && greenElement.startTagCloseRel() == GreenElement.NULL_VALUE) { + return NULL_VALUE; + } + return start; } /** diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java index bdc35ef1f..ff4fa25f2 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DOMNode.java @@ -67,8 +67,6 @@ public abstract class DOMNode implements Node, DOMRange { static final byte FLAG_SELF_CLOSED = 0x02; static final byte FLAG_WHITESPACE = 0x04; - DOMNode[] children; - final int start; // | int end; // | @@ -169,17 +167,18 @@ private String toString(int indent) { result.append(", closed: "); result.append(isClosed()); ensureChildren(); - if (children != null && children.length > 0) { + DOMNode[] arr = getChildrenArray(); + if (arr != null && arr.length > 0) { result.append(", \n"); for (int i = 0; i < indent + 1; i++) { result.append("\t"); } result.append("children:["); - for (int i = 0; i < children.length; i++) { - DOMNode node = children[i]; + for (int i = 0; i < arr.length; i++) { + DOMNode node = arr[i]; result.append("\n"); result.append(node.toString(indent + 2)); - if (i < children.length - 1) { + if (i < arr.length - 1) { result.append(","); } } @@ -442,6 +441,13 @@ public List getChildrenWithAttributeValue(String name, String value) { return result; } + DOMNode[] getChildrenArray() { + return null; + } + + void setChildrenArray(DOMNode[] c) { + } + void ensureChildren() { } @@ -455,10 +461,11 @@ void setLazy(GreenNode green, int absStart) { */ public List getChildren() { ensureChildren(); - if (children == null || children.length == 0) { + DOMNode[] arr = getChildrenArray(); + if (arr == null || arr.length == 0) { return Collections.emptyList(); } - return Arrays.asList(children); + return Arrays.asList(arr); } /** @@ -468,13 +475,15 @@ public List getChildren() { */ public void addChild(DOMNode child) { child.parent = this; - if (children == null) { - children = new DOMNode[] { child }; + DOMNode[] arr = getChildrenArray(); + if (arr == null) { + arr = new DOMNode[] { child }; } else { - children = Arrays.copyOf(children, children.length + 1); - children[children.length - 1] = child; + arr = Arrays.copyOf(arr, arr.length + 1); + arr[arr.length - 1] = child; } - child.cachedIndexInParent = children.length - 1; + setChildrenArray(arr); + child.cachedIndexInParent = arr.length - 1; } void compactChildren() { @@ -616,7 +625,8 @@ public DOMNode getParentNode() { @Override public DOMNode getFirstChild() { ensureChildren(); - return children != null && children.length > 0 ? children[0] : null; + DOMNode[] arr = getChildrenArray(); + return arr != null && arr.length > 0 ? arr[0] : null; } /* @@ -627,7 +637,8 @@ public DOMNode getFirstChild() { @Override public DOMNode getLastChild() { ensureChildren(); - return children != null && children.length > 0 ? children[children.length - 1] : null; + DOMNode[] arr = getChildrenArray(); + return arr != null && arr.length > 0 ? arr[arr.length - 1] : null; } /* @@ -648,7 +659,8 @@ public NamedNodeMap getAttributes() { @Override public NodeList getChildNodes() { ensureChildren(); - return children != null && children.length > 0 ? new ArrayNodeList(children) : EMPTY_CHILDREN; + DOMNode[] arr = getChildrenArray(); + return arr != null && arr.length > 0 ? new ArrayNodeList(arr) : EMPTY_CHILDREN; } /* @@ -842,9 +854,10 @@ public String getTextContent() throws DOMException { // concatenation of the textContent attribute value of every child node default: ensureChildren(); - if (this.children != null && children.length > 0) { + DOMNode[] arr = getChildrenArray(); + if (arr != null && arr.length > 0) { final StringBuilder builder = new StringBuilder(); - for (DOMNode child : children) { + for (DOMNode child : arr) { short nodeType = child.getNodeType(); if (nodeType == Node.COMMENT_NODE || nodeType == Node.PROCESSING_INSTRUCTION_NODE) { // excluding COMMENT_NODE and PROCESSING_INSTRUCTION_NODE nodes. @@ -875,7 +888,8 @@ public Object getUserData(String arg0) { @Override public boolean hasChildNodes() { ensureChildren(); - return children != null && children.length > 0; + DOMNode[] arr = getChildrenArray(); + return arr != null && arr.length > 0; } @Override diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java index d1ad3debb..7ffe27db5 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/DTDDeclNode.java @@ -34,8 +34,9 @@ public class DTDDeclNode extends DOMNode { public DTDDeclParameter unrecognized; public DTDDeclParameter declType; + DOMNode[] children; + private volatile GreenNode lazyGreenNode; - private int lazyAbsStart; private List parameters; private DTDDeclParameter name; @@ -44,15 +45,24 @@ public DTDDeclNode(int start, int end) { super(start, end); } + @Override + DOMNode[] getChildrenArray() { + return children; + } + + @Override + void setChildrenArray(DOMNode[] c) { + this.children = c; + } + @Override void ensureChildren() { if (lazyGreenNode != null) { synchronized (this) { if (lazyGreenNode != null) { GreenNode green = lazyGreenNode; - int absStart = lazyAbsStart; lazyGreenNode = null; - RedTreeBuilder.expandLazy(this, green, absStart); + RedTreeBuilder.expandLazy(this, green, start); } } } @@ -61,7 +71,6 @@ void ensureChildren() { @Override void setLazy(GreenNode green, int absStart) { this.lazyGreenNode = green; - this.lazyAbsStart = absStart; } public String getName() { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java index 2470b44f8..e9f64b325 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/RedTreeBuilder.java @@ -83,7 +83,7 @@ private DOMDocument doBuild(GreenDocument greenDoc, TextDocument textDocument, } private void addChildrenOrDefer(DOMNode node, GreenNode green, int absStart) { - if (lazy && green.children().length > 0) { + if (lazy && green.childCount() > 0) { node.setLazy(green, absStart); } else { addChildren(node, green, absStart); @@ -91,8 +91,8 @@ private void addChildrenOrDefer(DOMNode node, GreenNode green, int absStart) { } private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsStart) { - GreenNode[] greenChildren = greenParent.children(); - if (greenChildren.length == 0) { + int cc = greenParent.childCount(); + if (cc == 0) { parent.compactChildren(); return; } @@ -100,12 +100,13 @@ private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsSta int childrenStartRel = greenParent.childrenStartRel(); int childAbsStart = parentAbsStart + childrenStartRel; boolean skipWhitespace = ignoreWhitespaceContent - && (hasNonWhitespaceChild(greenChildren) || greenParent instanceof GreenDocumentType); + && (hasNonWhitespaceChild(greenParent, cc) || greenParent instanceof GreenDocumentType); - DOMNode[] redChildren = new DOMNode[greenChildren.length]; + DOMNode[] redChildren = new DOMNode[cc]; int idx = 0; - for (GreenNode greenChild : greenChildren) { + for (int i = 0; i < cc; i++) { + GreenNode greenChild = greenParent.child(i); if (skipWhitespace && isWhitespaceText(greenChild)) { childAbsStart += greenChild.width(); continue; @@ -125,14 +126,14 @@ private void addChildren(DOMNode parent, GreenNode greenParent, int parentAbsSta } if (idx > 0) { - parent.children = (idx == redChildren.length) ? redChildren : Arrays.copyOf(redChildren, idx); + parent.setChildrenArray((idx == redChildren.length) ? redChildren : Arrays.copyOf(redChildren, idx)); } parent.compactChildren(); } - private static boolean hasNonWhitespaceChild(GreenNode[] children) { - for (GreenNode child : children) { - if (!isWhitespaceText(child)) { + private static boolean hasNonWhitespaceChild(GreenNode parent, int cc) { + for (int i = 0; i < cc; i++) { + if (!isWhitespaceText(parent.child(i))) { return true; } } @@ -178,10 +179,6 @@ private DOMElement createElement(GreenElement green, int absStart, int absEnd) { DOMElement elem = new DOMElement(absStart, absEnd); elem.greenElement = green; elem.setSelfClosed(green.selfClosed()); - boolean isOrphanEndTag = green.endTagOpenRel() != GreenElement.NULL_VALUE - && green.endTagOpenRel() == 0 - && green.startTagCloseRel() == GreenElement.NULL_VALUE; - elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : absStart; elem.setClosed(green.closed()); GreenAttr[] greenAttrs = green.attributes(); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java index 2daa203fd..d28680826 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/dom/green/GreenElement.java @@ -28,7 +28,7 @@ public final class GreenElement extends GreenNode { private final int startTagCloseRel; private final int endTagOpenRel; private final GreenAttr[] attributes; - private final GreenNode[] children; + private final Object childrenData; public GreenElement(int width, boolean closed, String tag, boolean selfClosed, int startTagCloseRel, int endTagOpenRel, boolean endTagHasClose, @@ -39,7 +39,13 @@ public GreenElement(int width, boolean closed, String tag, boolean selfClosed, this.startTagCloseRel = startTagCloseRel; this.endTagOpenRel = endTagOpenRel; this.attributes = attributes != null ? attributes : EMPTY_ATTRS; - this.children = children != null ? children : EMPTY_CHILDREN; + if (children == null || children.length == 0) { + this.childrenData = null; + } else if (children.length == 1) { + this.childrenData = children[0]; + } else { + this.childrenData = children; + } } @Override @@ -83,12 +89,13 @@ public int childrenStartRel() { if (startTagCloseRel != NULL_VALUE) { return startTagCloseRel + 1; } - if (children.length == 0) { + int cc = childCount(); + if (cc == 0) { return 0; } int childrenWidth = 0; - for (GreenNode child : children) { - childrenWidth += child.width(); + for (int i = 0; i < cc; i++) { + childrenWidth += child(i).width(); } if (endTagOpenRel != NULL_VALUE) { return endTagOpenRel - childrenWidth; @@ -98,7 +105,23 @@ public int childrenStartRel() { @Override public GreenNode[] children() { - return children; + if (childrenData == null) return EMPTY_CHILDREN; + if (childrenData instanceof GreenNode[]) return (GreenNode[]) childrenData; + return new GreenNode[] { (GreenNode) childrenData }; + } + + @Override + public int childCount() { + if (childrenData == null) return 0; + if (childrenData instanceof GreenNode[]) return ((GreenNode[]) childrenData).length; + return 1; + } + + @Override + public GreenNode child(int index) { + if (childrenData instanceof GreenNode[]) return ((GreenNode[]) childrenData)[index]; + if (index == 0 && childrenData != null) return (GreenNode) childrenData; + throw new IndexOutOfBoundsException(index); } public GreenElement withNewChildren(GreenNode[] newChildren, int widthDelta) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java index 49ebc68b7..8ef465c1f 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/XMLSyntaxErrorCode.java @@ -257,8 +257,8 @@ public static Range toLSPRange(XMLLocator location, XMLSyntaxErrorCode code, Obj int startOffset = offset + 1; int endOffset = 0; int errorOffset = offset + 1; - String text = document.getText(); - int startPrologOffset = text.indexOf("<"); + CharSequence text = document.getTextSequence(); + int startPrologOffset = indexOf(text, '<', 0); if (errorOffset < startPrologOffset) { // Invalid content given before prolog. Prolog should be the first thing in the // file if given. @@ -267,7 +267,7 @@ public static Range toLSPRange(XMLLocator location, XMLSyntaxErrorCode code, Obj } else { // Invalid content given after prolog. Either root tag or comment should be // present - int firstStartTagOffset = text.indexOf("<", errorOffset); + int firstStartTagOffset = indexOf(text, '<', errorOffset); startOffset = errorOffset; endOffset = firstStartTagOffset != -1 ? firstStartTagOffset : text.length(); } @@ -411,6 +411,16 @@ private static DOMElement findChildTag(String tagName, DOMElement element) { return null; } + private static int indexOf(CharSequence cs, char ch, int from) { + int len = cs.length(); + for (int i = from; i < len; i++) { + if (cs.charAt(i) == ch) { + return i; + } + } + return -1; + } + public static void registerCodeActionParticipants(Map codeActions, SharedSettings sharedSettings) { codeActions.put(ETagUnterminated.getCode(), new ETagUnterminatedCodeAction()); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/dtd/participants/diagnostics/DTDValidator.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/dtd/participants/diagnostics/DTDValidator.java index 278e6b09a..064927bac 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/dtd/participants/diagnostics/DTDValidator.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/dtd/participants/diagnostics/DTDValidator.java @@ -14,8 +14,9 @@ import java.io.IOException; import java.io.Reader; -import java.io.StringReader; import java.util.HashMap; + +import org.eclipse.lemminx.commons.CharSequenceReader; import java.util.List; import java.util.concurrent.CancellationException; import java.util.logging.Level; @@ -52,10 +53,10 @@ public static void doDiagnostics(DOMDocument document, XMLEntityResolver entityR validationSettings); XMLDTDLoader loader = new LSPXML11DTDProcessor(entityManager, reporterForXML, entityResolver); - String content = document.getText(); + CharSequence content = document.getTextSequence(); String uri = document.getDocumentURI(); - Reader inputStream = new StringReader(content); + Reader inputStream = new CharSequenceReader(content); XMLInputSource source = new XMLInputSource(null, uri, uri, inputStream, null); loader.loadGrammar(source); } catch (IOException | CancellationException exception) { diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/xsd/participants/diagnostics/XSDValidator.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/xsd/participants/diagnostics/XSDValidator.java index 7090ea8f3..8406a8a10 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/xsd/participants/diagnostics/XSDValidator.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/xsd/participants/diagnostics/XSDValidator.java @@ -14,8 +14,9 @@ import java.io.IOException; import java.io.Reader; -import java.io.StringReader; import java.util.HashMap; + +import org.eclipse.lemminx.commons.CharSequenceReader; import java.util.List; import java.util.Map; import java.util.concurrent.CancellationException; @@ -101,9 +102,9 @@ public static void doDiagnostics(DOMDocument document, XMLEntityResolver entityR grammarPreparser.setEntityResolver(entityResolver); } - String content = document.getText(); + CharSequence content = document.getTextSequence(); String uri = document.getDocumentURI(); - Reader inputStream = new StringReader(content); + Reader inputStream = new CharSequenceReader(content); XMLInputSource source = new XMLInputSource(null, uri, uri, inputStream, null); grammarPreparser.getLoader(XMLGrammarDescription.XML_SCHEMA); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java index e84c2bf37..22f94cc15 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/services/format/XMLFormatterDocument.java @@ -852,10 +852,6 @@ CharSequence getTextSequence() { return textDocument.getTextSequence(); } - String getText() { - return textDocument.getText(); - } - public int getLineAtOffset(int offset) { try { return textDocument.lineOffsetAt(offset); diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/DOMUtils.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/DOMUtils.java index 80df91a8f..0a9f146f3 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/DOMUtils.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/utils/DOMUtils.java @@ -11,12 +11,12 @@ *******************************************************************************/ package org.eclipse.lemminx.utils; -import java.io.StringReader; import java.net.URL; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParserFactory; +import org.eclipse.lemminx.commons.CharSequenceReader; import org.eclipse.lemminx.dom.DOMDocument; import org.eclipse.lemminx.dom.DOMElement; import org.eclipse.lemminx.dom.DOMNode; @@ -281,10 +281,10 @@ public static boolean isDOMElement(DOMNode node, String tagName) { } public static InputSource createInputSource(DOMDocument document) { - String content = document.getText(); + CharSequence content = document.getTextSequence(); String uri = document.getDocumentURI(); InputSource inputSource = new InputSource(); - inputSource.setCharacterStream(new StringReader(content)); + inputSource.setCharacterStream(new CharSequenceReader(content)); inputSource.setSystemId(uri); return inputSource; } diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java index c7e0502c0..13dafa641 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMMemoryOptimizationsTest.java @@ -238,6 +238,42 @@ public void lazyAttributesAccessible() { assertEquals("val", elem.getAttribute("key")); } + @Test + public void lazySingleChildExpanded() { + DOMDocument doc = parseLazy(""); + DOMElement root = doc.getDocumentElement(); + assertTrue(root.hasChildNodes()); + assertEquals(1, root.getChildren().size()); + DOMElement only = (DOMElement) root.getFirstChild(); + assertEquals("only", only.getTagName()); + } + + @Test + public void lazySingleTextChildExpanded() { + DOMDocument doc = parseLazy("content"); + DOMElement root = doc.getDocumentElement(); + assertTrue(root.hasChildNodes()); + DOMNode text = root.getFirstChild(); + assertTrue(text.isText()); + } + + @Test + public void lazyEmptyElementNoChildren() { + DOMDocument doc = parseLazy(""); + DOMElement root = doc.getDocumentElement(); + DOMElement empty = (DOMElement) root.getFirstChild(); + assertFalse(empty.hasChildNodes()); + assertEquals(0, empty.getChildren().size()); + } + + @Test + public void findNodeAtSingleChild() { + DOMDocument doc = parseLazy(""); + DOMNode node = doc.findNodeAt(7); + assertTrue(node.isElement()); + assertEquals("child", ((DOMElement) node).getTagName()); + } + // --- findFirst binary search tests --- @Test @@ -297,6 +333,40 @@ public void setAttributeOnElement() { assertEquals("val", root.getAttribute("key")); } + @Test + public void textNodeHasNoChildrenArray() { + DOMDocument doc = parse("hello"); + DOMNode text = doc.getDocumentElement().getFirstChild(); + assertTrue(text.isText()); + assertNull(text.getChildrenArray()); + assertFalse(text.hasChildNodes()); + } + + @Test + public void commentNodeHasNoChildrenArray() { + DOMDocument doc = parse(""); + DOMNode comment = doc.getDocumentElement().getFirstChild(); + assertTrue(comment.isComment()); + assertNull(comment.getChildrenArray()); + assertFalse(comment.hasChildNodes()); + } + + @Test + public void elementHasChildrenArray() { + DOMDocument doc = parse(""); + DOMElement root = doc.getDocumentElement(); + assertTrue(root.hasChildNodes()); + assertNotNull(root.getChildrenArray()); + assertEquals(1, root.getChildren().size()); + } + + @Test + public void documentHasChildrenArray() { + DOMDocument doc = parse(""); + assertNotNull(doc.getChildrenArray()); + assertTrue(doc.hasChildNodes()); + } + // --- Helpers --- private DOMDocument parse(String xml) { diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java index b81573ed2..80354b4e6 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/DOMParserTest.java @@ -1224,8 +1224,6 @@ private static void setRestOfNode(DOMNode n, String tag, Integer endTagStart, bo elem.greenElement = new GreenElement(width, closed, tag, false, GreenElement.NULL_VALUE, endTagOpenRel, closed && endTagOpenRel != GreenElement.NULL_VALUE, null, null); - boolean isOrphanEndTag = endTagOpenRel == 0; - elem.startTagOpenOffset = isOrphanEndTag ? DOMNode.NULL_VALUE : n.start; } else if (n instanceof DOMProcessingInstruction) { ((DOMProcessingInstruction) n).target = tag; ((DOMProcessingInstruction) n).endTagOpenOffset = endTagStart != null ? endTagStart : DOMNode.NULL_VALUE; diff --git a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java index ee32a0fdf..b7ff2cb57 100644 --- a/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java +++ b/org.eclipse.lemminx/src/test/java/org/eclipse/lemminx/dom/green/GreenTreeBuilderTest.java @@ -15,6 +15,7 @@ import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import org.junit.jupiter.api.Test; @@ -487,6 +488,89 @@ public void withReplacedChildLast() { assertInstanceOf(GreenText.class, newRoot.child(2)); } + // --- Compact children storage tests --- + + @Test + public void compactChildrenZero() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement empty = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(0, empty.childCount()); + assertEquals(0, empty.children().length); + assertThrows(IndexOutOfBoundsException.class, () -> empty.child(0)); + } + + @Test + public void compactChildrenOne() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement parent = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, parent.childCount()); + GreenNode only = parent.child(0); + assertInstanceOf(GreenElement.class, only); + assertEquals("only", ((GreenElement) only).tag()); + + GreenNode[] arr = parent.children(); + assertEquals(1, arr.length); + assertEquals(only.width(), arr[0].width()); + + assertThrows(IndexOutOfBoundsException.class, () -> parent.child(1)); + assertThrows(IndexOutOfBoundsException.class, () -> parent.child(-1)); + } + + @Test + public void compactChildrenTwo() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement parent = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(2, parent.childCount()); + assertEquals("a", ((GreenElement) parent.child(0)).tag()); + assertEquals("b", ((GreenElement) parent.child(1)).tag()); + assertEquals(2, parent.children().length); + } + + @Test + public void compactChildrenSingleText() { + String xml = "

text

"; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement p = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, p.childCount()); + assertInstanceOf(GreenText.class, p.child(0)); + assertEquals(4, p.child(0).width()); + } + + @Test + public void withReplacedChildOnSingleChild() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement parent = assertInstanceOf(GreenElement.class, doc.child(0)); + assertEquals(1, parent.childCount()); + + GreenText replacement = new GreenText(10, false); + GreenNode newParent = parent.withReplacedChild(0, replacement); + GreenElement newElem = assertInstanceOf(GreenElement.class, newParent); + assertEquals(1, newElem.childCount()); + assertInstanceOf(GreenText.class, newElem.child(0)); + assertEquals(10, newElem.child(0).width()); + } + + @Test + public void withNewChildrenCompactsCorrectly() { + String xml = ""; + GreenDocument doc = GreenTreeBuilder.parse(xml, "test.xml", null); + GreenElement root = assertInstanceOf(GreenElement.class, doc.child(0)); + + GreenNode[] singleChild = new GreenNode[] { new GreenText(5, false) }; + GreenElement withOne = root.withNewChildren(singleChild, + 5 - (root.child(0).width() + root.child(1).width())); + assertEquals(1, withOne.childCount()); + assertInstanceOf(GreenText.class, withOne.child(0)); + + GreenElement withNone = root.withNewChildren(new GreenNode[0], + -(root.child(0).width() + root.child(1).width())); + assertEquals(0, withNone.childCount()); + } + private void assertTotalWidthConsistent(GreenNode node) { GreenNode[] kids = node.children(); if (kids.length > 0) { From 18e3da38915da0c9ef33838445c29a2c45d08108 Mon Sep 17 00:00:00 2001 From: azerr Date: Mon, 7 Sep 2026 08:14:37 +0200 Subject: [PATCH 18/18] Reduce GC pressure: replace LinkedHashSet with array in MultipleContentHandler LinkedHashSet created a new iterator object on every SAX event (startElement, endElement, characters, etc.) during Xerces validation. For a 117K-element XML file, this produced ~350K iterator allocations per validation run, totaling ~1.7 GB of transient allocations. Using a plain ContentHandler[] array with index-based iteration eliminates all iterator allocations and reduces peak heap during validation from ~900 MB to ~610 MB. Co-Authored-By: Claude Opus 4.6 --- .../diagnostics/MultipleContentHandler.java | 74 +++++++++++-------- 1 file changed, 44 insertions(+), 30 deletions(-) diff --git a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/diagnostics/MultipleContentHandler.java b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/diagnostics/MultipleContentHandler.java index 617893842..f188f624a 100644 --- a/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/diagnostics/MultipleContentHandler.java +++ b/org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/contentmodel/participants/diagnostics/MultipleContentHandler.java @@ -11,9 +11,6 @@ *******************************************************************************/ package org.eclipse.lemminx.extensions.contentmodel.participants.diagnostics; -import java.util.LinkedHashSet; -import java.util.Set; - import org.xml.sax.Attributes; import org.xml.sax.ContentHandler; import org.xml.sax.Locator; @@ -21,99 +18,116 @@ /** * Multiple SAX {@link ContentHandler}. - * + * * @author Angelo ZERR * */ public class MultipleContentHandler implements ContentHandler { - private final Set handlers; + private ContentHandler[] handlers = new ContentHandler[0]; public MultipleContentHandler() { - this.handlers = new LinkedHashSet<>(); } @Override public void setDocumentLocator(Locator locator) { - for (ContentHandler contentHandler : handlers) { - contentHandler.setDocumentLocator(locator); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].setDocumentLocator(locator); } } @Override public void startDocument() throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.startDocument(); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].startDocument(); } } @Override public void endDocument() throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.endDocument(); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].endDocument(); } } @Override public void startPrefixMapping(String prefix, String uri) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.startPrefixMapping(prefix, uri); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].startPrefixMapping(prefix, uri); } } @Override public void endPrefixMapping(String prefix) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.endPrefixMapping(prefix); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].endPrefixMapping(prefix); } } @Override public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.startElement(uri, localName, qName, atts); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].startElement(uri, localName, qName, atts); } } @Override public void endElement(String uri, String localName, String qName) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.endElement(uri, localName, qName); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].endElement(uri, localName, qName); } } @Override public void characters(char[] ch, int start, int length) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.characters(ch, start, length); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].characters(ch, start, length); } } @Override public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.ignorableWhitespace(ch, start, length); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].ignorableWhitespace(ch, start, length); } } @Override public void processingInstruction(String target, String data) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.processingInstruction(target, data); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].processingInstruction(target, data); } } @Override public void skippedEntity(String name) throws SAXException { - for (ContentHandler contentHandler : handlers) { - contentHandler.skippedEntity(name); + ContentHandler[] h = handlers; + for (int i = 0; i < h.length; i++) { + h[i].skippedEntity(name); } } public void addContentHandler(ContentHandler contentHandler) { - if (!handlers.contains(contentHandler)) { - handlers.add(contentHandler); + ContentHandler[] old = handlers; + for (int i = 0; i < old.length; i++) { + if (old[i] == contentHandler) { + return; + } } + ContentHandler[] newHandlers = new ContentHandler[old.length + 1]; + System.arraycopy(old, 0, newHandlers, 0, old.length); + newHandlers[old.length] = contentHandler; + handlers = newHandlers; } }