Don't reuse bracket pair AST nodes that touch the edit, as brackets at the end could be extended.

Author: hediet

src/vs/editor/common/model/bracketPairs/impl/ast.ts

@@ -65,8 +65,7 @@ abstract class BaseAstNode {
 	 * @param openBracketIds The set of all opening brackets that have not yet been closed.
 	 */
 	public abstract canBeReused(
-		openBracketIds: SmallImmutableSet<OpeningBracketId>,
-		endLineDidChange: boolean
+		openBracketIds: SmallImmutableSet<OpeningBracketId>
 	): boolean;
 
 	/**
@@ -146,10 +145,7 @@ export class PairAstNode extends BaseAstNode {
 		super(length);
 	}
 
-	public canBeReused(
-		openBracketIds: SmallImmutableSet<OpeningBracketId>,
-		_endLineDidChange: boolean
-	) {
+	public canBeReused(openBracketIds: SmallImmutableSet<OpeningBracketId>) {
 		if (this.closingBracket === null) {
 			// Unclosed pair ast nodes only
 			// end at the end of the document
@@ -293,10 +289,7 @@ export abstract class ListAstNode extends BaseAstNode {
 		return mutable;
 	}
 
-	public canBeReused(
-		openBracketIds: SmallImmutableSet<OpeningBracketId>,
-		endLineDidChange: boolean
-	): boolean {
+	public canBeReused(openBracketIds: SmallImmutableSet<OpeningBracketId>): boolean {
 		if (openBracketIds.intersects(this.missingOpeningBracketIds)) {
 			return false;
 		}
@@ -307,10 +300,7 @@ export abstract class ListAstNode extends BaseAstNode {
 			lastChild = lastChild.getChild(lastLength! - 1) as ListAstNode;
 		}
 
-		return lastChild.canBeReused(
-			openBracketIds,
-			endLineDidChange
-		);
+		return lastChild.canBeReused(openBracketIds);
 	}
 
 	public handleChildrenChanged(): void {
@@ -605,13 +595,8 @@ export class TextAstNode extends ImmutableLeafAstNode {
 		return SmallImmutableSet.getEmpty();
 	}
 
-	public canBeReused(
-		_openedBracketIds: SmallImmutableSet<OpeningBracketId>,
-		endLineDidChange: boolean
-	) {
-		// Don't reuse text from a line that got changed.
-		// Otherwise, long brackets might not be detected.
-		return !endLineDidChange;
+	public canBeReused(_openedBracketIds: SmallImmutableSet<OpeningBracketId>) {
+		return true;
 	}
 
 	public computeMinIndentation(offset: Length, textModel: ITextModel): number {
@@ -665,10 +650,7 @@ export class BracketAstNode extends ImmutableLeafAstNode {
 		super(length);
 	}
 
-	public canBeReused(
-		_openedBracketIds: SmallImmutableSet<OpeningBracketId>,
-		_endLineDidChange: boolean
-	) {
+	public canBeReused(_openedBracketIds: SmallImmutableSet<OpeningBracketId>) {
 		// These nodes could be reused,
 		// but not in a general way.
 		// Their parent may be reused.
@@ -692,10 +674,7 @@ export class InvalidBracketAstNode extends ImmutableLeafAstNode {
 		this.missingOpeningBracketIds = closingBrackets;
 	}
 
-	public canBeReused(
-		openedBracketIds: SmallImmutableSet<OpeningBracketId>,
-		_endLineDidChange: boolean
-	) {
+	public canBeReused(openedBracketIds: SmallImmutableSet<OpeningBracketId>) {
 		return !openedBracketIds.intersects(this.missingOpeningBracketIds);
 	}
 

src/vs/editor/common/model/bracketPairs/impl/parser.ts

@@ -6,7 +6,7 @@
 import { AstNode, AstNodeKind, BracketAstNode, InvalidBracketAstNode, ListAstNode, PairAstNode, TextAstNode } from './ast';
 import { BeforeEditPositionMapper, TextEditInfo } from './beforeEditPositionMapper';
 import { SmallImmutableSet } from './smallImmutableSet';
-import { lengthGetLineCount, lengthIsZero, lengthLessThanEqual } from './length';
+import { lengthIsZero, lengthLessThan } from './length';
 import { concat23Trees, concat23TreesOfSameHeight } from './concat23Trees';
 import { NodeReader } from './nodeReader';
 import { OpeningBracketId, Tokenizer, TokenKind } from './tokenizer';
@@ -103,12 +103,12 @@ class Parser {
 			const maxCacheableLength = this.positionMapper.getDistanceToNextChange(this.tokenizer.offset);
 			if (!lengthIsZero(maxCacheableLength)) {
 				const cachedNode = this.oldNodeReader.readLongestNodeAt(this.positionMapper.getOffsetBeforeChange(this.tokenizer.offset), curNode => {
-					if (!lengthLessThanEqual(curNode.length, maxCacheableLength)) {
+					if (!lengthLessThan(curNode.length, maxCacheableLength)) {
+						// Either the node contains edited text or touches edited text.
+						// In the latter case, brackets might have been extended (`end` -> `ending`), so even touching nodes cannot be reused.
 						return false;
 					}
-
-					const endLineDidChange = lengthGetLineCount(curNode.length) === lengthGetLineCount(maxCacheableLength);
-					const canBeReused = curNode.canBeReused(openedBracketIds, endLineDidChange);
+					const canBeReused = curNode.canBeReused(openedBracketIds);
 					return canBeReused;
 				});