Refactoring editor sticky scroll (microsoft#248131)

* refactor: enhance documentation for StickyLineCandidateProvider methods microsoft#248082

* Removed unusued statement causing hygiene build to fail microsoft#244845

* polish

---------

Co-authored-by: Aiday Marlen Kyzy <[email protected]>
Co-authored-by: Aiday Marlen Kyzy <[email protected]>

Author: raffaeu

src/vs/editor/contrib/stickyScroll/browser/stickyScrollProvider.ts

@@ -9,7 +9,6 @@ import { ILanguageFeaturesService } from '../../../common/services/languageFeatu
 import { CancellationToken, CancellationTokenSource, } from '../../../../base/common/cancellation.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { RunOnceScheduler } from '../../../../base/common/async.js';
-import { Range } from '../../../common/core/range.js';
 import { binarySearch } from '../../../../base/common/arrays.js';
 import { Event, Emitter } from '../../../../base/common/event.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
@@ -27,17 +26,33 @@ export class StickyLineCandidate {
 }
 
 export interface IStickyLineCandidateProvider {
-
+	/**
+	 * Dispose resources used by the provider.
+	 */
 	dispose(): void;
+
+	/**
+	 * Get the version ID of the sticky model.
+	 */
 	getVersionId(): number | undefined;
+
+	/**
+	 * Update the sticky line candidates.
+	 */
 	update(): Promise<void>;
+
+	/**
+	 * Get sticky line candidates intersecting a given range.
+	 */
 	getCandidateStickyLinesIntersecting(range: StickyRange): StickyLineCandidate[];
-	onDidChangeStickyScroll: Event<void>;
 
+	/**
+	 * Event triggered when sticky scroll changes.
+	 */
+	onDidChangeStickyScroll: Event<void>;
 }
 
 export class StickyLineCandidateProvider extends Disposable implements IStickyLineCandidateProvider {
-
 	static readonly ID = 'store.contrib.stickyScrollController';
 
 	private readonly _onDidChangeStickyScroll = this._register(new Emitter<void>());
@@ -69,19 +84,19 @@ export class StickyLineCandidateProvider extends Disposable implements IStickyLi
 		this.readConfiguration();
 	}
 
+	/**
+	 * Read and apply the sticky scroll configuration.
+	 */
 	private readConfiguration() {
 		this._sessionStore.clear();
 		const options = this._editor.getOption(EditorOption.stickyScroll);
 		if (!options.enabled) {
 			return;
 		}
 		this._sessionStore.add(this._editor.onDidChangeModel(() => {
-			// We should not show an old model for a different file, it will always be wrong.
-			// So we clear the model here immediately and then trigger an update.
 			this._model = null;
 			this.updateStickyModelProvider();
 			this._onDidChangeStickyScroll.fire();
-
 			this.update();
 		}));
 		this._sessionStore.add(this._editor.onDidChangeHiddenAreas(() => this.update()));
@@ -95,54 +110,69 @@ export class StickyLineCandidateProvider extends Disposable implements IStickyLi
 		this.update();
 	}
 
+	/**
+	 * Get the version ID of the sticky model.
+	 */
 	public getVersionId(): number | undefined {
 		return this._model?.version;
 	}
 
+	/**
+	 * Update the sticky model provider.
+	 */
 	private updateStickyModelProvider() {
 		this._stickyModelProvider?.dispose();
 		this._stickyModelProvider = null;
-		const editor = this._editor;
-		if (editor.hasModel()) {
+		if (this._editor.hasModel()) {
 			this._stickyModelProvider = new StickyModelProvider(
-				editor,
+				this._editor,
 				() => this._updateSoon.schedule(),
 				this._languageConfigurationService,
 				this._languageFeaturesService
 			);
 		}
 	}
 
+	/**
+	 * Update the sticky line candidates.
+	 */
 	public async update(): Promise<void> {
 		this._cts?.dispose(true);
 		this._cts = new CancellationTokenSource();
 		await this.updateStickyModel(this._cts.token);
 		this._onDidChangeStickyScroll.fire();
 	}
 
+	/**
+	 * Update the sticky model based on the current editor state.
+	 */
 	private async updateStickyModel(token: CancellationToken): Promise<void> {
 		if (!this._editor.hasModel() || !this._stickyModelProvider || this._editor.getModel().isTooLargeForTokenization()) {
 			this._model = null;
 			return;
 		}
 		const model = await this._stickyModelProvider.update(token);
-		if (token.isCancellationRequested) {
-			// the computation was canceled, so do not overwrite the model
-			return;
+		if (!token.isCancellationRequested) {
+			this._model = model;
 		}
-		this._model = model;
 	}
 
-	private updateIndex(index: number) {
-		if (index === -1) {
-			index = 0;
-		} else if (index < 0) {
-			index = -index - 2;
+	/**
+	 * Get sticky line candidates intersecting a given range.
+	 */
+	public getCandidateStickyLinesIntersecting(range: StickyRange): StickyLineCandidate[] {
+		if (!this._model?.element) {
+			return [];
 		}
-		return index;
+		const stickyLineCandidates: StickyLineCandidate[] = [];
+		this.getCandidateStickyLinesIntersectingFromStickyModel(range, this._model.element, stickyLineCandidates, 0, 0, -1);
+		return this.filterHiddenRanges(stickyLineCandidates);
 	}
 
-	public getCandidateStickyLinesIntersectingFromStickyModel(
+	/**
+	 * Get sticky line candidates intersecting a given range from the sticky model.
+	 */
+	private getCandidateStickyLinesIntersectingFromStickyModel(
 		range: StickyRange,
 		outlineModel: StickyElement,
 		result: StickyLineCandidate[],
@@ -167,38 +197,44 @@ export class StickyLineCandidateProvider extends Disposable implements IStickyLi
 
 		for (let i = lowerBound; i <= upperBound; i++) {
 			const child = outlineModel.children[i];
-			if (!child) {
-				return;
+			if (!child || !child.range) {
+				continue;
 			}
-			const childRange = child.range;
-			if (childRange) {
-				const childStartLine = childRange.startLineNumber;
-				const childEndLine = childRange.endLineNumber;
-				if (range.startLineNumber <= childEndLine + 1 && childStartLine - 1 <= range.endLineNumber && childStartLine !== lastLine) {
-					lastLine = childStartLine;
-					const lineHeight = this._editor.getLineHeightForPosition(new Position(childStartLine, 1));
-					result.push(new StickyLineCandidate(childStartLine, childEndLine - 1, top, lineHeight));
-					this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth + 1, top + lineHeight, childStartLine);
-				}
-			} else {
-				this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth, top, lastStartLineNumber);
+			const { startLineNumber, endLineNumber } = child.range;
+			if (range.startLineNumber <= endLineNumber + 1 && startLineNumber - 1 <= range.endLineNumber && startLineNumber !== lastLine) {
+				lastLine = startLineNumber;
+				const lineHeight = this._editor.getLineHeightForPosition(new Position(startLineNumber, 1));
+				result.push(new StickyLineCandidate(startLineNumber, endLineNumber - 1, top, lineHeight));
+				this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth + 1, top + lineHeight, startLineNumber);
 			}
 		}
 	}
 
-	public getCandidateStickyLinesIntersecting(range: StickyRange): StickyLineCandidate[] {
-		if (!this._model?.element) {
-			return [];
+	/**
+	 * Filter out sticky line candidates that are within hidden ranges.
+	 */
+	private filterHiddenRanges(stickyLineCandidates: StickyLineCandidate[]): StickyLineCandidate[] {
+		const hiddenRanges = this._editor._getViewModel()?.getHiddenAreas();
+		if (!hiddenRanges) {
+			return stickyLineCandidates;
 		}
-		let stickyLineCandidates: StickyLineCandidate[] = [];
-		this.getCandidateStickyLinesIntersectingFromStickyModel(range, this._model.element, stickyLineCandidates, 0, 0, -1);
-		const hiddenRanges: Range[] | undefined = this._editor._getViewModel()?.getHiddenAreas();
+		return stickyLineCandidates.filter(candidate => {
+			return !hiddenRanges.some(hiddenRange =>
+				candidate.startLineNumber >= hiddenRange.startLineNumber &&
+				candidate.endLineNumber <= hiddenRange.endLineNumber + 1
+			);
+		});
+	}
 
-		if (hiddenRanges) {
-			for (const hiddenRange of hiddenRanges) {
-				stickyLineCandidates = stickyLineCandidates.filter(stickyLine => !(stickyLine.startLineNumber >= hiddenRange.startLineNumber && stickyLine.endLineNumber <= hiddenRange.endLineNumber + 1));
-			}
+	/**
+	 * Update the binary search index.
+	 */
+	private updateIndex(index: number): number {
+		if (index === -1) {
+			return 0;
+		} else if (index < 0) {
+			return -index - 2;
 		}
-		return stickyLineCandidates;
+		return index;
 	}
 }