Adopt runWhenIdle

src/vs/base/common/async.ts

@@ -9,6 +9,7 @@ import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, IDisposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { extUri as defaultExtUri, IExtUri } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
+import { setTimeout0 } from 'vs/base/common/platform';
 
 export function isThenable<T>(obj: unknown): obj is Promise<T> {
 	return !!obj && typeof (obj as unknown as Promise<T>).then === 'function';
@@ -968,6 +969,7 @@ export interface IdleDeadline {
 	readonly didTimeout: boolean;
 	timeRemaining(): number;
 }
+
 /**
  * Execute the callback the next time the browser is idle
  */
@@ -979,8 +981,11 @@ declare function cancelIdleCallback(handle: number): void;
 (function () {
 	if (typeof requestIdleCallback !== 'function' || typeof cancelIdleCallback !== 'function') {
 		runWhenIdle = (runner) => {
-			const handle = setTimeout(() => {
-				const end = Date.now() + 15; // one frame at 64fps
+			setTimeout0(() => {
+				if (disposed) {
+					return;
+				}
+				const end = Date.now() + 3; // yield often
 				runner(Object.freeze({
 					didTimeout: true,
 					timeRemaining() {
@@ -995,7 +1000,6 @@ declare function cancelIdleCallback(handle: number): void;
 						return;
 					}
 					disposed = true;
-					clearTimeout(handle);
 				}
 			};
 		};

src/vs/base/common/platform.ts

@@ -190,21 +190,24 @@ interface ISetImmediate {
 	(callback: (...args: unknown[]) => void): void;
 }
 
-export const setImmediate: ISetImmediate = (function defineSetImmediate() {
-	if (globals.setImmediate) {
-		return globals.setImmediate.bind(globals);
-	}
+/**
+ * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.
+ *
+ * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay
+ * that browsers set when the nesting level is > 5.
+ */
+export const setTimeout0 = (() => {
 	if (typeof globals.postMessage === 'function' && !globals.importScripts) {
 		interface IQueueElement {
 			id: number;
 			callback: () => void;
 		}
 		let pending: IQueueElement[] = [];
 		globals.addEventListener('message', (e: MessageEvent) => {
-			if (e.data && e.data.vscodeSetImmediateId) {
+			if (e.data && e.data.vscodeScheduleAsyncWork) {
 				for (let i = 0, len = pending.length; i < len; i++) {
 					const candidate = pending[i];
-					if (candidate.id === e.data.vscodeSetImmediateId) {
+					if (candidate.id === e.data.vscodeScheduleAsyncWork) {
 						pending.splice(i, 1);
 						candidate.callback();
 						return;
@@ -219,9 +222,19 @@ export const setImmediate: ISetImmediate = (function defineSetImmediate() {
 				id: myId,
 				callback: callback
 			});
-			globals.postMessage({ vscodeSetImmediateId: myId }, '*');
+			globals.postMessage({ vscodeScheduleAsyncWork: myId }, '*');
 		};
 	}
+	return (callback: () => void) => setTimeout(callback);
+})();
+
+export const setImmediate: ISetImmediate = (function defineSetImmediate() {
+	if (globals.setImmediate) {
+		return globals.setImmediate.bind(globals);
+	}
+	if (typeof globals.postMessage === 'function' && !globals.importScripts) {
+		return setTimeout0;
+	}
 	if (typeof nodeProcess?.nextTick === 'function') {
 		return nodeProcess.nextTick.bind(nodeProcess);
 	}

src/vs/editor/common/model/textModelTokens.ts

@@ -15,7 +15,7 @@ import { TextModel } from 'vs/editor/common/model/textModel';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { StopWatch } from 'vs/base/common/stopwatch';
 import { MultilineTokensBuilder, countEOL } from 'vs/editor/common/model/tokensStore';
-import * as platform from 'vs/base/common/platform';
+import { runWhenIdle, IdleDeadline } from 'vs/base/common/async';
 
 const enum Constants {
 	CHEAP_TOKENIZATION_LENGTH_LIMIT = 2048
@@ -255,27 +255,34 @@ export class TextModelTokenization extends Disposable {
 		this._beginBackgroundTokenization();
 	}
 
+	private _isScheduled = false;
 	private _beginBackgroundTokenization(): void {
-		if (this._textModel.isAttachedToEditor() && this._hasLinesToTokenize()) {
-			platform.setImmediate(() => {
-				if (this._isDisposed) {
-					// disposed in the meantime
-					return;
-				}
-				this._revalidateTokensNow();
-			});
+		if (this._isScheduled || !this._textModel.isAttachedToEditor() || !this._hasLinesToTokenize()) {
+			return;
 		}
+
+		this._isScheduled = true;
+		runWhenIdle((deadline) => {
+			this._isScheduled = false;
+
+			if (this._isDisposed) {
+				// disposed in the meantime
+				return;
+			}
+
+			this._revalidateTokensNow(deadline);
+		});
 	}
 
-	private _revalidateTokensNow(): void {
+	private _revalidateTokensNow(deadline: IdleDeadline): void {
 		const textModelLastLineNumber = this._textModel.getLineCount();
 
 		const MAX_ALLOWED_TIME = 1;
 		const builder = new MultilineTokensBuilder();
 		const sw = StopWatch.create(false);
 		let tokenizedLineNumber = -1;
 
-		while (this._hasLinesToTokenize()) {
+		do {
 			if (sw.elapsed() > MAX_ALLOWED_TIME) {
 				// Stop if MAX_ALLOWED_TIME is reached
 				break;
@@ -286,7 +293,7 @@ export class TextModelTokenization extends Disposable {
 			if (tokenizedLineNumber >= textModelLastLineNumber) {
 				break;
 			}
-		}
+		} while (this._hasLinesToTokenize() && deadline.timeRemaining() > 0);
 
 		this._beginBackgroundTokenization();
 		this._textModel.setTokens(builder.tokens, !this._hasLinesToTokenize());