Merge from vscode fcf3346a8e9f5ee1e00674461d9e2c2292a14ee3 (#12295)

* Merge from vscode fcf3346a8e9f5ee1e00674461d9e2c2292a14ee3

* Fix test build break

* Update distro

* Fix build errors

* Update distro

* Update REH build file

* Update build task names for REL

* Fix product build yaml

* Fix product REH task name

* Fix type in task name

* Update linux build step

* Update windows build tasks

* Turn off server publish

* Disable REH

* Fix typo

* Bump distro

* Update vscode tests

* Bump distro

* Fix type in disto

* Bump distro

* Turn off docker build

* Remove docker step from release

Co-authored-by: ADS Merger <andresse@microsoft.com>
Co-authored-by: Karl Burtram <karlb@microsoft.com>

src/vs/editor/browser/controller/pointerHandler.ts

@@ -50,7 +50,7 @@ class StandardPointerHandler extends MouseHandler implements IDisposable {
 			this._installGestureHandlerTimeout = -1;
 
 			// TODO@Alex: replace the usage of MSGesture here with something that works across all browsers
-			if ((<any>window).MSGesture) {
+			if (window.MSGesture) {
 				const touchGesture = new MSGesture();
 				const penGesture = new MSGesture();
 				touchGesture.target = this.viewHelper.linesContentDomNode;
@@ -226,9 +226,9 @@ export class PointerHandler extends Disposable {
 		super();
 		if ((platform.isIOS && BrowserFeatures.pointerEvents)) {
 			this.handler = this._register(new PointerEventHandler(context, viewController, viewHelper));
-		} else if ((<any>window).TouchEvent) {
+		} else if (window.TouchEvent) {
 			this.handler = this._register(new TouchHandler(context, viewController, viewHelper));
-		} else if (window.navigator.pointerEnabled || (<any>window).PointerEvent) {
+		} else if (window.navigator.pointerEnabled || window.PointerEvent) {
 			this.handler = this._register(new StandardPointerHandler(context, viewController, viewHelper));
 		} else {
 			this.handler = this._register(new MouseHandler(context, viewController, viewHelper));

src/vs/editor/browser/services/openerService.ts

@@ -74,7 +74,8 @@ class EditorOpener implements IOpener {
 		}
 
 		await this._editorService.openCodeEditor(
-			{ resource: target, options: { selection, context: options?.fromUserGesture ? EditorOpenContext.USER : EditorOpenContext.API } },
+			// {{SQL CARBON EDIT}} - cast target to fix hygine break
+			{ resource: <any>target, options: { selection, context: options?.fromUserGesture ? EditorOpenContext.USER : EditorOpenContext.API } },
 			this._editorService.getFocusedCodeEditor(),
 			options?.openToSide
 		);

src/vs/editor/browser/viewParts/lines/viewLine.ts

@@ -15,7 +15,7 @@ import { LineDecoration } from 'vs/editor/common/viewLayout/lineDecorations';
 import { CharacterMapping, ForeignElementType, RenderLineInput, renderViewLine, LineRange } from 'vs/editor/common/viewLayout/viewLineRenderer';
 import { ViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
 import { InlineDecorationType } from 'vs/editor/common/viewModel/viewModel';
-import { HIGH_CONTRAST, ThemeType } from 'vs/platform/theme/common/themeService';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 import { EditorOption, EditorFontLigatures } from 'vs/editor/common/config/editorOptions';
 
 const canUseFastRenderedViewLine = (function () {
@@ -71,7 +71,7 @@ export class DomReadingContext {
 }
 
 export class ViewLineOptions {
-	public readonly themeType: ThemeType;
+	public readonly themeType: ColorScheme;
 	public readonly renderWhitespace: 'none' | 'boundary' | 'selection' | 'trailing' | 'all';
 	public readonly renderControlCharacters: boolean;
 	public readonly spaceWidth: number;
@@ -83,7 +83,7 @@ export class ViewLineOptions {
 	public readonly stopRenderingLineAfter: number;
 	public readonly fontLigatures: string;
 
-	constructor(config: IConfiguration, themeType: ThemeType) {
+	constructor(config: IConfiguration, themeType: ColorScheme) {
 		this.themeType = themeType;
 		const options = config.options;
 		const fontInfo = options.get(EditorOption.fontInfo);
@@ -163,7 +163,7 @@ export class ViewLine implements IVisibleLine {
 		this._options = newOptions;
 	}
 	public onSelectionChanged(): boolean {
-		if (alwaysRenderInlineSelection || this._options.themeType === HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
+		if (alwaysRenderInlineSelection || this._options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
 			this._isMaybeInvalid = true;
 			return true;
 		}
@@ -184,7 +184,7 @@ export class ViewLine implements IVisibleLine {
 
 		// Only send selection information when needed for rendering whitespace
 		let selectionsOnLine: LineRange[] | null = null;
-		if (alwaysRenderInlineSelection || options.themeType === HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
+		if (alwaysRenderInlineSelection || options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace === 'selection') {
 			const selections = viewportData.selections;
 			for (const selection of selections) {
 
@@ -197,7 +197,7 @@ export class ViewLine implements IVisibleLine {
 				const endColumn = (selection.endLineNumber === lineNumber ? selection.endColumn : lineData.maxColumn);
 
 				if (startColumn < endColumn) {
-					if (options.themeType === HIGH_CONTRAST || this._options.renderWhitespace !== 'selection') {
+					if (options.themeType === ColorScheme.HIGH_CONTRAST || this._options.renderWhitespace !== 'selection') {
 						actualInlineDecorations.push(new LineDecoration(startColumn, endColumn, 'inline-selected-text', InlineDecorationType.Regular));
 					} else {
 						if (!selectionsOnLine) {

src/vs/editor/common/modes/languageFeatureRegistry.ts

@@ -4,7 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Emitter, Event } from 'vs/base/common/event';
+import { hash } from 'vs/base/common/hash';
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { LRUCache } from 'vs/base/common/map';
+import { MovingAverage } from 'vs/base/common/numbers';
 import { ITextModel } from 'vs/editor/common/model';
 import { LanguageSelector, score } from 'vs/editor/common/modes/languageSelector';
 import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
@@ -174,3 +177,48 @@ export class LanguageFeatureRegistry<T> {
 		}
 	}
 }
+
+
+/**
+ * Keeps moving average per model and set of providers so that requests
+ * can be debounce according to the provider performance
+ */
+export class LanguageFeatureRequestDelays {
+
+	private readonly _cache = new LRUCache<string, MovingAverage>(50, 0.7);
+
+	constructor(
+		private readonly _registry: LanguageFeatureRegistry<any>,
+		readonly min: number,
+		readonly max: number = Number.MAX_SAFE_INTEGER,
+	) { }
+
+	private _key(model: ITextModel): string {
+		return model.id + hash(this._registry.all(model));
+	}
+
+	private _clamp(value: number | undefined): number {
+		if (value === undefined) {
+			return this.min;
+		} else {
+			return Math.min(this.max, Math.max(this.min, Math.floor(value * 1.3)));
+		}
+	}
+
+	get(model: ITextModel): number {
+		const key = this._key(model);
+		const avg = this._cache.get(key);
+		return this._clamp(avg?.value);
+	}
+
+	update(model: ITextModel, value: number): number {
+		const key = this._key(model);
+		let avg = this._cache.get(key);
+		if (!avg) {
+			avg = new MovingAverage();
+			this._cache.set(key, avg);
+		}
+		avg.update(value);
+		return this.get(model);
+	}
+}

src/vs/editor/common/modes/supports/tokenization.ts

@@ -395,14 +395,14 @@ export class ThemeTrieElement {
 	}
 }
 
-export function generateTokensCSSForColorMap(colorMap: Color[]): string {
+export function generateTokensCSSForColorMap(colorMap: readonly Color[]): string {
 	let rules: string[] = [];
 	for (let i = 1, len = colorMap.length; i < len; i++) {
 		let color = colorMap[i];
-		rules[i] = `.monaco-editor .mtk${i} { color: ${color}; }`;
+		rules[i] = `.mtk${i} { color: ${color}; }`;
 	}
-	rules.push('.monaco-editor .mtki { font-style: italic; }');
-	rules.push('.monaco-editor .mtkb { font-weight: bold; }');
-	rules.push('.monaco-editor .mtku { text-decoration: underline; text-underline-position: under; }');
+	rules.push('.mtki { font-style: italic; }');
+	rules.push('.mtkb { font-weight: bold; }');
+	rules.push('.mtku { text-decoration: underline; text-underline-position: under; }');
 	return rules.join('\n');
 }

src/vs/editor/common/services/markerDecorationsServiceImpl.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IMarkerService, IMarker, MarkerSeverity, MarkerTag } from 'vs/platform/markers/common/markers';
-import { Disposable, toDisposable, IDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { IModelDeltaDecoration, ITextModel, IModelDecorationOptions, TrackedRangeStickiness, OverviewRulerLane, IModelDecoration, MinimapPosition, IModelDecorationMinimapOptions } from 'vs/editor/common/model';
 import { ClassName } from 'vs/editor/common/model/intervalTree';
@@ -16,7 +16,6 @@ import { IMarkerDecorationsService } from 'vs/editor/common/services/markersDeco
 import { Schemas } from 'vs/base/common/network';
 import { Emitter, Event } from 'vs/base/common/event';
 import { minimapWarning, minimapError } from 'vs/platform/theme/common/colorRegistry';
-import { Delayer } from 'vs/base/common/async';
 
 function MODEL_ID(resource: URI): string {
 	return resource.toString();
@@ -36,10 +35,6 @@ class MarkerDecorations extends Disposable {
 		}));
 	}
 
-	register<T extends IDisposable>(t: T): T {
-		return super._register(t);
-	}
-
 	public update(markers: IMarker[], newDecorations: IModelDeltaDecoration[]): boolean {
 		const oldIds = [...this._markersData.keys()];
 		this._markersData.clear();
@@ -114,8 +109,6 @@ export class MarkerDecorationsService extends Disposable implements IMarkerDecor
 	private _onModelAdded(model: ITextModel): void {
 		const markerDecorations = new MarkerDecorations(model);
 		this._markerDecorations.set(MODEL_ID(model.uri), markerDecorations);
-		const delayer = markerDecorations.register(new Delayer(100));
-		markerDecorations.register(model.onDidChangeContent(() => delayer.trigger(() => this._updateDecorations(markerDecorations))));
 		this._updateDecorations(markerDecorations);
 	}
 

src/vs/editor/common/view/viewContext.ts

@@ -6,15 +6,16 @@
 import { IConfiguration } from 'vs/editor/common/editorCommon';
 import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
 import { IViewLayout, IViewModel } from 'vs/editor/common/viewModel/viewModel';
-import { IColorTheme, ThemeType } from 'vs/platform/theme/common/themeService';
+import { IColorTheme } from 'vs/platform/theme/common/themeService';
 import { ColorIdentifier } from 'vs/platform/theme/common/colorRegistry';
 import { Color } from 'vs/base/common/color';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 
 export class EditorTheme {
 
 	private _theme: IColorTheme;
 
-	public get type(): ThemeType {
+	public get type(): ColorScheme {
 		return this._theme.type;
 	}
 

src/vs/editor/contrib/codelens/codelens.ts

@@ -36,44 +36,47 @@ export class CodeLensModel {
 	}
 }
 
-export function getCodeLensData(model: ITextModel, token: CancellationToken): Promise<CodeLensModel> {
+export async function getCodeLensModel(model: ITextModel, token: CancellationToken): Promise<CodeLensModel> {
 
 	const provider = CodeLensProviderRegistry.ordered(model);
 	const providerRanks = new Map<CodeLensProvider, number>();
 	const result = new CodeLensModel();
 
-	const promises = provider.map((provider, i) => {
+	const promises = provider.map(async (provider, i) => {
 
 		providerRanks.set(provider, i);
 
-		return Promise.resolve(provider.provideCodeLenses(model, token))
-			.then(list => list && result.add(list, provider))
-			.catch(onUnexpectedExternalError);
-	});
-
-	return Promise.all(promises).then(() => {
-
-		result.lenses = mergeSort(result.lenses, (a, b) => {
-			// sort by lineNumber, provider-rank, and column
-			if (a.symbol.range.startLineNumber < b.symbol.range.startLineNumber) {
-				return -1;
-			} else if (a.symbol.range.startLineNumber > b.symbol.range.startLineNumber) {
-				return 1;
-			} else if (providerRanks.get(a.provider)! < providerRanks.get(b.provider)!) {
-				return -1;
-			} else if (providerRanks.get(a.provider)! > providerRanks.get(b.provider)!) {
-				return 1;
-			} else if (a.symbol.range.startColumn < b.symbol.range.startColumn) {
-				return -1;
-			} else if (a.symbol.range.startColumn > b.symbol.range.startColumn) {
-				return 1;
-			} else {
-				return 0;
+		try {
+			const list = await Promise.resolve(provider.provideCodeLenses(model, token));
+			if (list) {
+				result.add(list, provider);
 			}
-		});
-
-		return result;
+		} catch (err) {
+			onUnexpectedExternalError(err);
+		}
 	});
+
+	await Promise.all(promises);
+
+	result.lenses = mergeSort(result.lenses, (a, b) => {
+		// sort by lineNumber, provider-rank, and column
+		if (a.symbol.range.startLineNumber < b.symbol.range.startLineNumber) {
+			return -1;
+		} else if (a.symbol.range.startLineNumber > b.symbol.range.startLineNumber) {
+			return 1;
+		} else if ((providerRanks.get(a.provider)!) < (providerRanks.get(b.provider)!)) {
+			return -1;
+		} else if ((providerRanks.get(a.provider)!) > (providerRanks.get(b.provider)!)) {
+			return 1;
+		} else if (a.symbol.range.startColumn < b.symbol.range.startColumn) {
+			return -1;
+		} else if (a.symbol.range.startColumn > b.symbol.range.startColumn) {
+			return 1;
+		} else {
+			return 0;
+		}
+	});
+	return result;
 }
 
 registerLanguageCommand('_executeCodeLensProvider', function (accessor, args) {
@@ -90,7 +93,7 @@ registerLanguageCommand('_executeCodeLensProvider', function (accessor, args) {
 
 	const result: CodeLens[] = [];
 	const disposables = new DisposableStore();
-	return getCodeLensData(model, CancellationToken.None).then(value => {
+	return getCodeLensModel(model, CancellationToken.None).then(value => {
 
 		disposables.add(value);
 		let resolve: Promise<any>[] = [];

src/vs/editor/contrib/codelens/codelensController.ts

@@ -5,14 +5,14 @@
 
 import { CancelablePromise, RunOnceScheduler, createCancelablePromise, disposableTimeout } from 'vs/base/common/async';
 import { onUnexpectedError, onUnexpectedExternalError } from 'vs/base/common/errors';
-import { toDisposable, DisposableStore, dispose } from 'vs/base/common/lifecycle';
+import { toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { StableEditorScrollState } from 'vs/editor/browser/core/editorState';
 import { ICodeEditor, MouseTargetType, IViewZoneChangeAccessor, IActiveCodeEditor } from 'vs/editor/browser/editorBrowser';
 import { registerEditorContribution, ServicesAccessor, registerEditorAction, EditorAction } from 'vs/editor/browser/editorExtensions';
 import { IEditorContribution } from 'vs/editor/common/editorCommon';
 import { IModelDecorationsChangeAccessor } from 'vs/editor/common/model';
 import { CodeLensProviderRegistry, CodeLens, Command } from 'vs/editor/common/modes';
-import { CodeLensModel, getCodeLensData, CodeLensItem } from 'vs/editor/contrib/codelens/codelens';
+import { CodeLensModel, getCodeLensModel, CodeLensItem } from 'vs/editor/contrib/codelens/codelens';
 import { CodeLensWidget, CodeLensHelper } from 'vs/editor/contrib/codelens/codelensWidget';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { INotificationService } from 'vs/platform/notification/common/notification';
@@ -23,24 +23,25 @@ import { hash } from 'vs/base/common/hash';
 import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
 import { localize } from 'vs/nls';
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
+import { LanguageFeatureRequestDelays } from 'vs/editor/common/modes/languageFeatureRegistry';
 
 export class CodeLensContribution implements IEditorContribution {
 
-	public static readonly ID: string = 'css.editor.codeLens';
+	static readonly ID: string = 'css.editor.codeLens';
 
-	private _isEnabled: boolean;
-
-	private readonly _globalToDispose = new DisposableStore();
+	private readonly _disposables = new DisposableStore();
 	private readonly _localToDispose = new DisposableStore();
 	private readonly _styleElement: HTMLStyleElement;
 	private readonly _styleClassName: string;
-	private _lenses: CodeLensWidget[] = [];
-	private _currentFindCodeLensSymbolsPromise: CancelablePromise<CodeLensModel> | undefined;
+	private readonly _lenses: CodeLensWidget[] = [];
+
+	private readonly _getCodeLensModelDelays = new LanguageFeatureRequestDelays(CodeLensProviderRegistry, 250, 2500);
+	private _getCodeLensModelPromise: CancelablePromise<CodeLensModel> | undefined;
 	private _oldCodeLensModels = new DisposableStore();
 	private _currentCodeLensModel: CodeLensModel | undefined;
-	private _modelChangeCounter: number = 0;
-	private _currentResolveCodeLensSymbolsPromise: CancelablePromise<any> | undefined;
-	private _detectVisibleLenses: RunOnceScheduler | undefined;
+	private readonly _resolveCodeLensesDelays = new LanguageFeatureRequestDelays(CodeLensProviderRegistry, 250, 2500);
+	private readonly _resolveCodeLensesScheduler = new RunOnceScheduler(() => this._resolveCodeLensesInViewport(), this._resolveCodeLensesDelays.min);
+	private _resolveCodeLensesPromise: CancelablePromise<any> | undefined;
 
 	constructor(
 		private readonly _editor: ICodeEditor,
@@ -48,23 +49,18 @@ export class CodeLensContribution implements IEditorContribution {
 		@INotificationService private readonly _notificationService: INotificationService,
 		@ICodeLensCache private readonly _codeLensCache: ICodeLensCache
 	) {
-		this._isEnabled = this._editor.getOption(EditorOption.codeLens);
 
-		this._globalToDispose.add(this._editor.onDidChangeModel(() => this._onModelChange()));
-		this._globalToDispose.add(this._editor.onDidChangeModelLanguage(() => this._onModelChange()));
-		this._globalToDispose.add(this._editor.onDidChangeConfiguration(() => {
-			const prevIsEnabled = this._isEnabled;
-			this._isEnabled = this._editor.getOption(EditorOption.codeLens);
-			if (prevIsEnabled !== this._isEnabled) {
-				this._onModelChange();
-			}
-		}));
-		this._globalToDispose.add(CodeLensProviderRegistry.onDidChange(this._onModelChange, this));
-		this._globalToDispose.add(this._editor.onDidChangeConfiguration(e => {
+		this._disposables.add(this._editor.onDidChangeModel(() => this._onModelChange()));
+		this._disposables.add(this._editor.onDidChangeModelLanguage(() => this._onModelChange()));
+		this._disposables.add(this._editor.onDidChangeConfiguration((e) => {
 			if (e.hasChanged(EditorOption.fontInfo)) {
 				this._updateLensStyle();
 			}
+			if (e.hasChanged(EditorOption.codeLens)) {
+				this._onModelChange();
+			}
 		}));
+		this._disposables.add(CodeLensProviderRegistry.onDidChange(this._onModelChange, this));
 		this._onModelChange();
 
 		this._styleClassName = '_' + hash(this._editor.getId()).toString(16);
@@ -78,9 +74,9 @@ export class CodeLensContribution implements IEditorContribution {
 
 	dispose(): void {
 		this._localDispose();
-		this._globalToDispose.dispose();
+		this._disposables.dispose();
 		this._oldCodeLensModels.dispose();
-		dispose(this._currentCodeLensModel);
+		this._currentCodeLensModel?.dispose();
 	}
 
 	private _updateLensStyle(): void {
@@ -99,18 +95,13 @@ export class CodeLensContribution implements IEditorContribution {
 	}
 
 	private _localDispose(): void {
-		if (this._currentFindCodeLensSymbolsPromise) {
-			this._currentFindCodeLensSymbolsPromise.cancel();
-			this._currentFindCodeLensSymbolsPromise = undefined;
-			this._modelChangeCounter++;
-		}
-		if (this._currentResolveCodeLensSymbolsPromise) {
-			this._currentResolveCodeLensSymbolsPromise.cancel();
-			this._currentResolveCodeLensSymbolsPromise = undefined;
-		}
+		this._getCodeLensModelPromise?.cancel();
+		this._getCodeLensModelPromise = undefined;
+		this._resolveCodeLensesPromise?.cancel();
+		this._resolveCodeLensesPromise = undefined;
 		this._localToDispose.clear();
 		this._oldCodeLensModels.clear();
-		dispose(this._currentCodeLensModel);
+		this._currentCodeLensModel?.dispose();
 	}
 
 	private _onModelChange(): void {
@@ -122,7 +113,7 @@ export class CodeLensContribution implements IEditorContribution {
 			return;
 		}
 
-		if (!this._isEnabled) {
+		if (!this._editor.getOption(EditorOption.codeLens)) {
 			return;
 		}
 
@@ -153,34 +144,34 @@ export class CodeLensContribution implements IEditorContribution {
 			}
 		}
 
-		const detectVisibleLenses = this._detectVisibleLenses = new RunOnceScheduler(() => this._onViewportChanged(), 250);
-
 		const scheduler = new RunOnceScheduler(() => {
-			const counterValue = ++this._modelChangeCounter;
-			if (this._currentFindCodeLensSymbolsPromise) {
-				this._currentFindCodeLensSymbolsPromise.cancel();
-			}
+			const t1 = Date.now();
 
-			this._currentFindCodeLensSymbolsPromise = createCancelablePromise(token => getCodeLensData(model, token));
+			this._getCodeLensModelPromise?.cancel();
+			this._getCodeLensModelPromise = createCancelablePromise(token => getCodeLensModel(model, token));
 
-			this._currentFindCodeLensSymbolsPromise.then(result => {
-				if (counterValue === this._modelChangeCounter) { // only the last one wins
-					if (this._currentCodeLensModel) {
-						this._oldCodeLensModels.add(this._currentCodeLensModel);
-					}
-					this._currentCodeLensModel = result;
-
-					// cache model to reduce flicker
-					this._codeLensCache.put(model, result);
-
-					// render lenses
-					this._renderCodeLensSymbols(result);
-					detectVisibleLenses.schedule();
+			this._getCodeLensModelPromise.then(result => {
+				if (this._currentCodeLensModel) {
+					this._oldCodeLensModels.add(this._currentCodeLensModel);
 				}
+				this._currentCodeLensModel = result;
+
+				// cache model to reduce flicker
+				this._codeLensCache.put(model, result);
+
+				// update moving average
+				const newDelay = this._getCodeLensModelDelays.update(model, Date.now() - t1);
+				scheduler.delay = newDelay;
+
+				// render lenses
+				this._renderCodeLensSymbols(result);
+				this._resolveCodeLensesInViewportSoon();
 			}, onUnexpectedError);
-		}, 250);
+
+		}, this._getCodeLensModelDelays.get(model));
+
 		this._localToDispose.add(scheduler);
-		this._localToDispose.add(detectVisibleLenses);
+		this._localToDispose.add(toDisposable(() => this._resolveCodeLensesScheduler.cancel()));
 		this._localToDispose.add(this._editor.onDidChangeModelContent(() => {
 			this._editor.changeDecorations(decorationsAccessor => {
 				this._editor.changeViewZones(viewZonesAccessor => {
@@ -209,17 +200,17 @@ export class CodeLensContribution implements IEditorContribution {
 			});
 
 			// Compute new `visible` code lenses
-			detectVisibleLenses.schedule();
+			this._resolveCodeLensesInViewportSoon();
 			// Ask for all references again
 			scheduler.schedule();
 		}));
 		this._localToDispose.add(this._editor.onDidScrollChange(e => {
 			if (e.scrollTopChanged && this._lenses.length > 0) {
-				detectVisibleLenses.schedule();
+				this._resolveCodeLensesInViewportSoon();
 			}
 		}));
 		this._localToDispose.add(this._editor.onDidLayoutChange(() => {
-			detectVisibleLenses.schedule();
+			this._resolveCodeLensesInViewportSoon();
 		}));
 		this._localToDispose.add(toDisposable(() => {
 			if (this._editor.getModel()) {
@@ -264,7 +255,7 @@ export class CodeLensContribution implements IEditorContribution {
 		if (decChangeAccessor) {
 			helper.commit(decChangeAccessor);
 		}
-		this._lenses = [];
+		this._lenses.length = 0;
 	}
 
 	private _renderCodeLensSymbols(symbols: CodeLensModel): void {
@@ -313,7 +304,7 @@ export class CodeLensContribution implements IEditorContribution {
 						groupsIndex++;
 						codeLensIndex++;
 					} else {
-						this._lenses.splice(codeLensIndex, 0, new CodeLensWidget(groups[groupsIndex], <IActiveCodeEditor>this._editor, this._styleClassName, helper, viewZoneAccessor, () => this._detectVisibleLenses && this._detectVisibleLenses.schedule()));
+						this._lenses.splice(codeLensIndex, 0, new CodeLensWidget(groups[groupsIndex], <IActiveCodeEditor>this._editor, this._styleClassName, helper, viewZoneAccessor, () => this._resolveCodeLensesInViewportSoon()));
 						codeLensIndex++;
 						groupsIndex++;
 					}
@@ -327,7 +318,7 @@ export class CodeLensContribution implements IEditorContribution {
 
 				// Create extra symbols
 				while (groupsIndex < groups.length) {
-					this._lenses.push(new CodeLensWidget(groups[groupsIndex], <IActiveCodeEditor>this._editor, this._styleClassName, helper, viewZoneAccessor, () => this._detectVisibleLenses && this._detectVisibleLenses.schedule()));
+					this._lenses.push(new CodeLensWidget(groups[groupsIndex], <IActiveCodeEditor>this._editor, this._styleClassName, helper, viewZoneAccessor, () => this._resolveCodeLensesInViewportSoon()));
 					groupsIndex++;
 				}
 
@@ -338,11 +329,17 @@ export class CodeLensContribution implements IEditorContribution {
 		scrollState.restore(this._editor);
 	}
 
-	private _onViewportChanged(): void {
-		if (this._currentResolveCodeLensSymbolsPromise) {
-			this._currentResolveCodeLensSymbolsPromise.cancel();
-			this._currentResolveCodeLensSymbolsPromise = undefined;
+	private _resolveCodeLensesInViewportSoon(): void {
+		const model = this._editor.getModel();
+		if (model) {
+			this._resolveCodeLensesScheduler.schedule();
 		}
+	}
+
+	private _resolveCodeLensesInViewport(): void {
+
+		this._resolveCodeLensesPromise?.cancel();
+		this._resolveCodeLensesPromise = undefined;
 
 		const model = this._editor.getModel();
 		if (!model) {
@@ -363,6 +360,8 @@ export class CodeLensContribution implements IEditorContribution {
 			return;
 		}
 
+		const t1 = Date.now();
+
 		const resolvePromise = createCancelablePromise(token => {
 
 			const promises = toResolve.map((request, i) => {
@@ -388,20 +387,25 @@ export class CodeLensContribution implements IEditorContribution {
 
 			return Promise.all(promises);
 		});
-		this._currentResolveCodeLensSymbolsPromise = resolvePromise;
+		this._resolveCodeLensesPromise = resolvePromise;
+
+		this._resolveCodeLensesPromise.then(() => {
+
+			// update moving average
+			const newDelay = this._resolveCodeLensesDelays.update(model, Date.now() - t1);
+			this._resolveCodeLensesScheduler.delay = newDelay;
 
-		this._currentResolveCodeLensSymbolsPromise.then(() => {
 			if (this._currentCodeLensModel) { // update the cached state with new resolved items
 				this._codeLensCache.put(model, this._currentCodeLensModel);
 			}
 			this._oldCodeLensModels.clear(); // dispose old models once we have updated the UI with the current model
-			if (resolvePromise === this._currentResolveCodeLensSymbolsPromise) {
-				this._currentResolveCodeLensSymbolsPromise = undefined;
+			if (resolvePromise === this._resolveCodeLensesPromise) {
+				this._resolveCodeLensesPromise = undefined;
 			}
 		}, err => {
 			onUnexpectedError(err); // can also be cancellation!
-			if (resolvePromise === this._currentResolveCodeLensSymbolsPromise) {
-				this._currentResolveCodeLensSymbolsPromise = undefined;
+			if (resolvePromise === this._resolveCodeLensesPromise) {
+				this._resolveCodeLensesPromise = undefined;
 			}
 		});
 	}

src/vs/editor/contrib/codelens/codelensWidget.ts

@@ -4,8 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import 'vs/css!./codelensWidget';
-import { renderCodicons } from 'vs/base/common/codicons';
-import { escape } from 'vs/base/common/strings';
+import * as dom from 'vs/base/browser/dom';
 import { IViewZone, IContentWidget, IActiveCodeEditor, IContentWidgetPosition, ContentWidgetPositionPreference, IViewZoneChangeAccessor } from 'vs/editor/browser/editorBrowser';
 import { Range } from 'vs/editor/common/core/range';
 import { IModelDecorationsChangeAccessor, IModelDeltaDecoration, ITextModel } from 'vs/editor/common/model';
@@ -15,6 +14,7 @@ import { editorCodeLensForeground } from 'vs/editor/common/view/editorColorRegis
 import { CodeLensItem } from 'vs/editor/contrib/codelens/codelens';
 import { editorActiveLinkForeground } from 'vs/platform/theme/common/colorRegistry';
 import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
+import { renderCodicons } from 'vs/base/browser/codicons';
 
 class CodeLensViewZone implements IViewZone {
 
@@ -79,7 +79,7 @@ class CodeLensContentWidget implements IContentWidget {
 	withCommands(lenses: Array<CodeLens | undefined | null>, animate: boolean): void {
 		this._commands.clear();
 
-		let innerHtml = '';
+		let children: HTMLElement[] = [];
 		let hasSymbol = false;
 		for (let i = 0; i < lenses.length; i++) {
 			const lens = lenses[i];
@@ -88,29 +88,26 @@ class CodeLensContentWidget implements IContentWidget {
 			}
 			hasSymbol = true;
 			if (lens.command) {
-				const title = renderCodicons(escape(lens.command.title));
+				const title = renderCodicons(lens.command.title);
 				if (lens.command.id) {
-					innerHtml += `<a id=${i}>${title}</a>`;
+					children.push(dom.$('a', { id: String(i) }, ...title));
 					this._commands.set(String(i), lens.command);
 				} else {
-					innerHtml += `<span>${title}</span>`;
+					children.push(dom.$('span', undefined, ...title));
 				}
 				if (i + 1 < lenses.length) {
-					innerHtml += '<span>&#160;|&#160;</span>';
+					children.push(dom.$('span', undefined, '\u00a0|\u00a0'));
 				}
 			}
 		}
 
 		if (!hasSymbol) {
 			// symbols but no commands
-			this._domNode.innerHTML = '<span>no commands</span>';
+			dom.reset(this._domNode, dom.$('span', undefined, 'no commands'));
 
 		} else {
 			// symbols and commands
-			if (!innerHtml) {
-				innerHtml = '\u00a0';
-			}
-			this._domNode.innerHTML = innerHtml;
+			dom.reset(this._domNode, ...children);
 			if (this._isEmpty && animate) {
 				this._domNode.classList.add('fadein');
 			}

src/vs/editor/contrib/colorPicker/colorPickerWidget.ts

@@ -47,12 +47,12 @@ export class ColorPickerHeader extends Disposable {
 		this._register(model.onDidChangeColor(this.onDidChangeColor, this));
 		this._register(model.onDidChangePresentation(this.onDidChangePresentation, this));
 		this.pickedColorNode.style.backgroundColor = Color.Format.CSS.format(model.color) || '';
-		dom.toggleClass(this.pickedColorNode, 'light', model.color.rgba.a < 0.5 ? this.backgroundColor.isLighter() : model.color.isLighter());
+		this.pickedColorNode.classList.toggle('light', model.color.rgba.a < 0.5 ? this.backgroundColor.isLighter() : model.color.isLighter());
 	}
 
 	private onDidChangeColor(color: Color): void {
 		this.pickedColorNode.style.backgroundColor = Color.Format.CSS.format(color) || '';
-		dom.toggleClass(this.pickedColorNode, 'light', color.rgba.a < 0.5 ? this.backgroundColor.isLighter() : color.isLighter());
+		this.pickedColorNode.classList.toggle('light', color.rgba.a < 0.5 ? this.backgroundColor.isLighter() : color.isLighter());
 		this.onDidChangePresentation();
 	}
 
@@ -264,7 +264,7 @@ abstract class Strip extends Disposable {
 	private onMouseDown(e: MouseEvent): void {
 		const monitor = this._register(new GlobalMouseMoveMonitor<IStandardMouseMoveEventData>());
 		const origin = dom.getDomNodePagePosition(this.domNode);
-		dom.addClass(this.domNode, 'grabbing');
+		this.domNode.classList.add('grabbing');
 
 		if (e.target !== this.slider) {
 			this.onDidChangeTop(e.offsetY);
@@ -276,7 +276,7 @@ abstract class Strip extends Disposable {
 			this._onColorFlushed.fire();
 			mouseUpListener.dispose();
 			monitor.stopMonitoring(true);
-			dom.removeClass(this.domNode, 'grabbing');
+			this.domNode.classList.remove('grabbing');
 		}, true);
 	}
 
@@ -298,7 +298,7 @@ class OpacityStrip extends Strip {
 
 	constructor(container: HTMLElement, model: ColorPickerModel) {
 		super(container, model);
-		dom.addClass(this.domNode, 'opacity-strip');
+		this.domNode.classList.add('opacity-strip');
 
 		this._register(model.onDidChangeColor(this.onDidChangeColor, this));
 		this.onDidChangeColor(this.model.color);
@@ -321,7 +321,7 @@ class HueStrip extends Strip {
 
 	constructor(container: HTMLElement, model: ColorPickerModel) {
 		super(container, model);
-		dom.addClass(this.domNode, 'hue-strip');
+		this.domNode.classList.add('hue-strip');
 	}
 
 	protected getValue(color: Color): number {

src/vs/editor/contrib/documentSymbols/outlineModel.ts

@@ -14,8 +14,8 @@ import { ITextModel } from 'vs/editor/common/model';
 import { DocumentSymbol, DocumentSymbolProvider, DocumentSymbolProviderRegistry } from 'vs/editor/common/modes';
 import { MarkerSeverity } from 'vs/platform/markers/common/markers';
 import { Iterable } from 'vs/base/common/iterator';
-import { MovingAverage } from 'vs/base/common/numbers';
 import { URI } from 'vs/base/common/uri';
+import { LanguageFeatureRequestDelays } from 'vs/editor/common/modes/languageFeatureRegistry';
 
 export abstract class TreeElement {
 
@@ -208,7 +208,7 @@ export class OutlineGroup extends TreeElement {
 
 export class OutlineModel extends TreeElement {
 
-	private static readonly _requestDurations = new LRUCache<string, MovingAverage>(50, 0.7);
+	private static readonly _requestDurations = new LanguageFeatureRequestDelays(DocumentSymbolProviderRegistry, 350);
 	private static readonly _requests = new LRUCache<string, { promiseCnt: number, source: CancellationTokenSource, promise: Promise<any>, model: OutlineModel | undefined }>(9, 0.75);
 	private static readonly _keys = new class {
 
@@ -252,13 +252,7 @@ export class OutlineModel extends TreeElement {
 			// keep moving average of request durations
 			const now = Date.now();
 			data.promise.then(() => {
-				let key = this._keys.for(textModel, false);
-				let avg = this._requestDurations.get(key);
-				if (!avg) {
-					avg = new MovingAverage();
-					this._requestDurations.set(key, avg);
-				}
-				avg.update(Date.now() - now);
+				this._requestDurations.update(textModel, Date.now() - now);
 			});
 		}
 
@@ -290,14 +284,7 @@ export class OutlineModel extends TreeElement {
 	}
 
 	static getRequestDelay(textModel: ITextModel | null): number {
-		if (!textModel) {
-			return 350;
-		}
-		const avg = this._requestDurations.get(this._keys.for(textModel, false));
-		if (!avg) {
-			return 350;
-		}
-		return Math.max(350, Math.floor(1.3 * avg.value));
+		return textModel ? this._requestDurations.get(textModel) : this._requestDurations.min;
 	}
 
 	private static _create(textModel: ITextModel, token: CancellationToken): Promise<OutlineModel> {

src/vs/editor/contrib/format/format.ts

@@ -116,7 +116,7 @@ export abstract class FormattingConflicts {
 		if (selector) {
 			return await selector(formatter, document, mode);
 		}
-		return formatter[0];
+		return undefined;
 	}
 }
 

src/vs/editor/contrib/gotoError/gotoErrorWidget.ts

@@ -57,7 +57,7 @@ class MessageWidget {
 		domNode.className = 'descriptioncontainer';
 
 		this._messageBlock = document.createElement('div');
-		dom.addClass(this._messageBlock, 'message');
+		this._messageBlock.classList.add('message');
 		this._messageBlock.setAttribute('aria-live', 'assertive');
 		this._messageBlock.setAttribute('role', 'alert');
 		domNode.appendChild(this._messageBlock);
@@ -123,19 +123,19 @@ class MessageWidget {
 		}
 		if (source || code) {
 			const detailsElement = document.createElement('span');
-			dom.addClass(detailsElement, 'details');
+			detailsElement.classList.add('details');
 			lastLineElement.appendChild(detailsElement);
 			if (source) {
 				const sourceElement = document.createElement('span');
 				sourceElement.innerText = source;
-				dom.addClass(sourceElement, 'source');
+				sourceElement.classList.add('source');
 				detailsElement.appendChild(sourceElement);
 			}
 			if (code) {
 				if (typeof code === 'string') {
 					const codeElement = document.createElement('span');
 					codeElement.innerText = `(${code})`;
-					dom.addClass(codeElement, 'code');
+					codeElement.classList.add('code');
 					detailsElement.appendChild(codeElement);
 				} else {
 					this._codeLink = dom.$('a.code-link');
@@ -166,7 +166,7 @@ class MessageWidget {
 				let container = document.createElement('div');
 
 				let relatedResource = document.createElement('a');
-				dom.addClass(relatedResource, 'filename');
+				relatedResource.classList.add('filename');
 				relatedResource.innerText = `${getBaseLabel(related.resource)}(${related.startLineNumber}, ${related.startColumn}): `;
 				relatedResource.title = getPathLabel(related.resource, undefined);
 				this._relatedDiagnostics.set(relatedResource, related);
@@ -318,7 +318,7 @@ export class MarkerNavigationWidget extends PeekViewWidget {
 
 	protected _fillBody(container: HTMLElement): void {
 		this._parentContainer = container;
-		dom.addClass(container, 'marker-widget');
+		container.classList.add('marker-widget');
 		this._parentContainer.tabIndex = 0;
 		this._parentContainer.setAttribute('role', 'tooltip');
 

src/vs/editor/contrib/gotoSymbol/peek/referencesController.ts

@@ -5,7 +5,7 @@
 
 import * as nls from 'vs/nls';
 import { onUnexpectedError } from 'vs/base/common/errors';
-import { dispose, DisposableStore } from 'vs/base/common/lifecycle';
+import { DisposableStore } from 'vs/base/common/lifecycle';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IContextKey, IContextKeyService, RawContextKey, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
@@ -64,8 +64,8 @@ export abstract class ReferencesController implements IEditorContribution {
 	dispose(): void {
 		this._referenceSearchVisible.reset();
 		this._disposables.dispose();
-		dispose(this._widget);
-		dispose(this._model);
+		this._widget?.dispose();
+		this._model?.dispose();
 		this._widget = undefined;
 		this._model = undefined;
 	}
@@ -226,8 +226,8 @@ export abstract class ReferencesController implements IEditorContribution {
 	}
 
 	closeWidget(focusEditor = true): void {
-		dispose(this._widget);
-		dispose(this._model);
+		this._widget?.dispose();
+		this._model?.dispose();
 		this._referenceSearchVisible.reset();
 		this._disposables.clear();
 		this._widget = undefined;

src/vs/editor/contrib/gotoSymbol/symbolNavigation.ts

@@ -55,8 +55,8 @@ class SymbolNavigationService implements ISymbolNavigationService {
 
 	reset(): void {
 		this._ctxHasSymbols.reset();
-		dispose(this._currentState);
-		dispose(this._currentMessage);
+		this._currentState?.dispose();
+		this._currentMessage?.dispose();
 		this._currentModel = undefined;
 		this._currentIdx = -1;
 	}
@@ -138,7 +138,7 @@ class SymbolNavigationService implements ISymbolNavigationService {
 
 	private _showMessage(): void {
 
-		dispose(this._currentMessage);
+		this._currentMessage?.dispose();
 
 		const kb = this._keybindingService.lookupKeybinding('editor.gotoNextSymbolFromResult');
 		const message = kb
@@ -209,7 +209,7 @@ class EditorState {
 	}
 
 	private _onDidRemoveEditor(editor: ICodeEditor): void {
-		dispose(this._listener.get(editor));
+		this._listener.get(editor)?.dispose();
 		this._listener.delete(editor);
 	}
 }

src/vs/editor/contrib/hover/modesContentHover.ts

@@ -240,11 +240,11 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 
 		this._register(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.FOCUS, () => {
 			if (this._colorPicker) {
-				dom.addClass(this.getDomNode(), 'colorpicker-hover');
+				this.getDomNode().classList.add('colorpicker-hover');
 			}
 		}));
 		this._register(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.BLUR, () => {
-			dom.removeClass(this.getDomNode(), 'colorpicker-hover');
+			this.getDomNode().classList.remove('colorpicker-hover');
 		}));
 		this._register(editor.onDidChangeConfiguration((e) => {
 			this._hoverOperation.setHoverTime(this._editor.getOption(EditorOption.hover).delay);

src/vs/editor/contrib/links/getLinks.ts

@@ -13,6 +13,7 @@ import { IModelService } from 'vs/editor/common/services/modelService';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { isDisposable, Disposable } from 'vs/base/common/lifecycle';
 import { coalesce } from 'vs/base/common/arrays';
+import { assertType } from 'vs/base/common/types';
 
 export class Link implements ILink {
 
@@ -152,10 +153,13 @@ export function getLinks(model: ITextModel, token: CancellationToken): Promise<L
 
 
 CommandsRegistry.registerCommand('_executeLinkProvider', async (accessor, ...args): Promise<ILink[]> => {
-	const [uri] = args;
-	if (!(uri instanceof URI)) {
-		return [];
+	let [uri, resolveCount] = args;
+	assertType(uri instanceof URI);
+
+	if (typeof resolveCount !== 'number') {
+		resolveCount = 0;
 	}
+
 	const model = accessor.get(IModelService).getModel(uri);
 	if (!model) {
 		return [];
@@ -164,6 +168,12 @@ CommandsRegistry.registerCommand('_executeLinkProvider', async (accessor, ...arg
 	if (!list) {
 		return [];
 	}
+
+	// resolve links
+	for (let i = 0; i < Math.min(resolveCount, list.links.length); i++) {
+		await list.links[i].resolve(CancellationToken.None);
+	}
+
 	const result = list.links.slice(0);
 	list.dispose();
 	return result;

src/vs/editor/contrib/message/messageController.ts

@@ -15,9 +15,10 @@ import { registerEditorContribution, EditorCommand, registerEditorCommand } from
 import { ICodeEditor, IContentWidget, IContentWidgetPosition, ContentWidgetPositionPreference } from 'vs/editor/browser/editorBrowser';
 import { IContextKeyService, RawContextKey, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { IPosition } from 'vs/editor/common/core/position';
-import { registerThemingParticipant, HIGH_CONTRAST } from 'vs/platform/theme/common/themeService';
+import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
 import { inputValidationInfoBorder, inputValidationInfoBackground, inputValidationInfoForeground } from 'vs/platform/theme/common/colorRegistry';
 import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 
 export class MessageController extends Disposable implements IEditorContribution {
 
@@ -184,7 +185,7 @@ registerEditorContribution(MessageController.ID, MessageController);
 registerThemingParticipant((theme, collector) => {
 	const border = theme.getColor(inputValidationInfoBorder);
 	if (border) {
-		let borderWidth = theme.type === HIGH_CONTRAST ? 2 : 1;
+		let borderWidth = theme.type === ColorScheme.HIGH_CONTRAST ? 2 : 1;
 		collector.addRule(`.monaco-editor .monaco-editor-overlaymessage .anchor { border-top-color: ${border}; }`);
 		collector.addRule(`.monaco-editor .monaco-editor-overlaymessage .message { border: ${borderWidth}px solid ${border}; }`);
 	}

src/vs/editor/contrib/parameterHints/parameterHintsWidget.ts

@@ -20,11 +20,12 @@ import * as nls from 'vs/nls';
 import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { editorHoverBackground, editorHoverBorder, textCodeBlockBackground, textLinkForeground, editorHoverForeground } from 'vs/platform/theme/common/colorRegistry';
-import { HIGH_CONTRAST, registerThemingParticipant } from 'vs/platform/theme/common/themeService';
+import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
 import { ParameterHintsModel, TriggerContext } from 'vs/editor/contrib/parameterHints/parameterHintsModel';
 import { pad } from 'vs/base/common/strings';
 import { registerIcon, Codicon } from 'vs/base/common/codicons';
 import { assertIsDefined } from 'vs/base/common/types';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 
 const $ = dom.$;
 
@@ -364,7 +365,7 @@ export class ParameterHintsWidget extends Disposable implements IContentWidget {
 registerThemingParticipant((theme, collector) => {
 	const border = theme.getColor(editorHoverBorder);
 	if (border) {
-		const borderWidth = theme.type === HIGH_CONTRAST ? 2 : 1;
+		const borderWidth = theme.type === ColorScheme.HIGH_CONTRAST ? 2 : 1;
 		collector.addRule(`.monaco-editor .parameter-hints-widget { border: ${borderWidth}px solid ${border}; }`);
 		collector.addRule(`.monaco-editor .parameter-hints-widget.multiple .body { border-left: 1px solid ${border.transparent(0.5)}; }`);
 		collector.addRule(`.monaco-editor .parameter-hints-widget .signature.has-docs { border-bottom: 1px solid ${border.transparent(0.5)}; }`);

src/vs/editor/contrib/parameterHints/test/parameterHintsModel.test.ts

@@ -290,7 +290,7 @@ suite('ParameterHintsModel', () => {
 		hintsModel.trigger({ triggerKind: modes.SignatureHelpTriggerKind.Invoke }, 0);
 		assert.strictEqual(-1, didRequestCancellationOf);
 
-		return new Promise((resolve, reject) =>
+		return new Promise<void>((resolve, reject) =>
 			hintsModel.onChangedHints(newParamterHints => {
 				try {
 					assert.strictEqual(0, didRequestCancellationOf);

src/vs/editor/contrib/rename/test/onTypeRename.test.ts

@@ -104,7 +104,7 @@ suite('On type rename', () => {
 
 			await operations(testEditor);
 
-			return new Promise((resolve) => {
+			return new Promise<void>((resolve) => {
 				setTimeout(() => {
 					if (typeof expectedEndText === 'string') {
 						assert.equal(editor.getModel()!.getValue(), expectedEndText);

src/vs/editor/contrib/smartSelect/bracketSelections.ts

@@ -19,8 +19,8 @@ export class BracketSelectionRangeProvider implements SelectionRangeProvider {
 			result.push(bucket);
 
 			const ranges = new Map<string, LinkedList<Range>>();
-			await new Promise(resolve => BracketSelectionRangeProvider._bracketsRightYield(resolve, 0, model, position, ranges));
-			await new Promise(resolve => BracketSelectionRangeProvider._bracketsLeftYield(resolve, 0, model, position, ranges, bucket));
+			await new Promise<void>(resolve => BracketSelectionRangeProvider._bracketsRightYield(resolve, 0, model, position, ranges));
+			await new Promise<void>(resolve => BracketSelectionRangeProvider._bracketsLeftYield(resolve, 0, model, position, ranges, bucket));
 		}
 
 		return result;

src/vs/editor/contrib/smartSelect/smartSelect.ts

@@ -18,7 +18,7 @@ import * as modes from 'vs/editor/common/modes';
 import * as nls from 'vs/nls';
 import { MenuId } from 'vs/platform/actions/common/actions';
 import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
-import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { IDisposable } from 'vs/base/common/lifecycle';
 import { WordSelectionRangeProvider } from 'vs/editor/contrib/smartSelect/wordSelections';
 import { BracketSelectionRangeProvider } from 'vs/editor/contrib/smartSelect/bracketSelections';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
@@ -64,7 +64,7 @@ class SmartSelectController implements IEditorContribution {
 	}
 
 	dispose(): void {
-		dispose(this._selectionListener);
+		this._selectionListener?.dispose();
 	}
 
 	run(forward: boolean): Promise<void> | void {
@@ -106,10 +106,10 @@ class SmartSelectController implements IEditorContribution {
 				this._state = ranges.map(ranges => new SelectionRanges(0, ranges));
 
 				// listen to caret move and forget about state
-				dispose(this._selectionListener);
+				this._selectionListener?.dispose();
 				this._selectionListener = this._editor.onDidChangeCursorPosition(() => {
 					if (!this._ignoreSelection) {
-						dispose(this._selectionListener);
+						this._selectionListener?.dispose();
 						this._state = undefined;
 					}
 				});

src/vs/editor/contrib/snippet/snippetController2.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
-import { dispose, DisposableStore } from 'vs/base/common/lifecycle';
+import { DisposableStore } from 'vs/base/common/lifecycle';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { EditorCommand, registerEditorCommand, registerEditorContribution } from 'vs/editor/browser/editorExtensions';
 import { Range } from 'vs/editor/common/core/range';
@@ -75,7 +75,7 @@ export class SnippetController2 implements IEditorContribution {
 		this._inSnippet.reset();
 		this._hasPrevTabstop.reset();
 		this._hasNextTabstop.reset();
-		dispose(this._session);
+		this._session?.dispose();
 		this._snippetListener.dispose();
 	}
 
@@ -211,7 +211,7 @@ export class SnippetController2 implements IEditorContribution {
 		this._hasPrevTabstop.reset();
 		this._hasNextTabstop.reset();
 		this._snippetListener.clear();
-		dispose(this._session);
+		this._session?.dispose();
 		this._session = undefined;
 		this._modelVersionId = -1;
 		if (resetSelection) {

src/vs/editor/contrib/suggest/media/suggest.css

@@ -351,6 +351,7 @@
 	box-sizing: border-box;
 	height: 100%;
 	width: 100%;
+	padding-right: 22px;
 }
 
 .monaco-editor .suggest-widget .details > .monaco-scrollable-element > .body > .header > .type {

src/vs/editor/contrib/suggest/suggestAlternatives.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable } from 'vs/base/common/lifecycle';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { CompletionModel } from './completionModel';
@@ -34,7 +34,7 @@ export class SuggestAlternatives {
 
 	reset(): void {
 		this._ckOtherSuggestions.reset();
-		dispose(this._listener);
+		this._listener?.dispose();
 		this._model = undefined;
 		this._acceptNext = undefined;
 		this._ignore = false;

src/vs/editor/contrib/suggest/suggestController.ts

@@ -442,7 +442,7 @@ export class SuggestController implements IEditorContribution {
 	private _alertCompletionItem({ completion: suggestion }: CompletionItem): void {
 		const textLabel = typeof suggestion.label === 'string' ? suggestion.label : suggestion.label.name;
 		if (isNonEmptyArray(suggestion.additionalTextEdits)) {
-			let msg = nls.localize('arai.alert.snippet', "Accepting '{0}' made {1} additional edits", textLabel, suggestion.additionalTextEdits.length);
+			let msg = nls.localize('aria.alert.snippet', "Accepting '{0}' made {1} additional edits", textLabel, suggestion.additionalTextEdits.length);
 			alert(msg);
 		}
 	}
@@ -598,7 +598,8 @@ export class TriggerSuggestAction extends EditorAction {
 			kbOpts: {
 				kbExpr: EditorContextKeys.textInputFocus,
 				primary: KeyMod.CtrlCmd | KeyCode.Space,
-				mac: { primary: KeyMod.WinCtrl | KeyCode.Space, secondary: [KeyMod.Alt | KeyCode.Escape] },
+				secondary: [KeyMod.CtrlCmd | KeyCode.KEY_I],
+				mac: { primary: KeyMod.WinCtrl | KeyCode.Space, secondary: [KeyMod.Alt | KeyCode.Escape, KeyMod.CtrlCmd | KeyCode.KEY_I] },
 				weight: KeybindingWeight.EditorContrib
 			}
 		});

src/vs/editor/contrib/suggest/suggestModel.ts

@@ -436,7 +436,7 @@ export class SuggestModel implements IDisposable {
 
 		Promise.all([completions, wordDistance]).then(async ([completions, wordDistance]) => {
 
-			dispose(this._requestToken);
+			this._requestToken?.dispose();
 
 			if (this._state === State.Idle) {
 				return;

src/vs/editor/contrib/suggest/wordContextKey.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { RawContextKey, IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
-import { IDisposable, dispose, Disposable } from 'vs/base/common/lifecycle';
+import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { EditorOption } from 'vs/editor/common/config/editorOptions';
 
@@ -29,7 +29,7 @@ export class WordContextKey extends Disposable {
 
 	dispose(): void {
 		super.dispose();
-		dispose(this._selectionListener);
+		this._selectionListener?.dispose();
 		this._ckAtEnd.reset();
 	}
 

src/vs/editor/contrib/wordHighlighter/wordHighlighter.ts

@@ -239,7 +239,7 @@ class WordHighlighter {
 
 	public moveNext() {
 		let highlights = this._getSortedHighlights();
-		let index = arrays.firstIndex(highlights, (range) => range.containsPosition(this.editor.getPosition()));
+		let index = highlights.findIndex((range) => range.containsPosition(this.editor.getPosition()));
 		let newIndex = ((index + 1) % highlights.length);
 		let dest = highlights[newIndex];
 		try {
@@ -258,7 +258,7 @@ class WordHighlighter {
 
 	public moveBack() {
 		let highlights = this._getSortedHighlights();
-		let index = arrays.firstIndex(highlights, (range) => range.containsPosition(this.editor.getPosition()));
+		let index = highlights.findIndex((range) => range.containsPosition(this.editor.getPosition()));
 		let newIndex = ((index - 1 + highlights.length) % highlights.length);
 		let dest = highlights[newIndex];
 		try {

src/vs/editor/standalone/browser/inspectTokens/inspectTokens.ts

@@ -20,8 +20,9 @@ import { NULL_STATE, nullTokenize, nullTokenize2 } from 'vs/editor/common/modes/
 import { IModeService } from 'vs/editor/common/services/modeService';
 import { IStandaloneThemeService } from 'vs/editor/standalone/common/standaloneThemeService';
 import { editorHoverBackground, editorHoverBorder, editorHoverForeground } from 'vs/platform/theme/common/colorRegistry';
-import { HIGH_CONTRAST, registerThemingParticipant } from 'vs/platform/theme/common/themeService';
+import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
 import { InspectTokensNLS } from 'vs/editor/common/standaloneStrings';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 
 
 class InspectTokensController extends Disposable implements IEditorContribution {
@@ -332,7 +333,7 @@ registerEditorAction(InspectTokens);
 registerThemingParticipant((theme, collector) => {
 	const border = theme.getColor(editorHoverBorder);
 	if (border) {
-		let borderWidth = theme.type === HIGH_CONTRAST ? 2 : 1;
+		let borderWidth = theme.type === ColorScheme.HIGH_CONTRAST ? 2 : 1;
 		collector.addRule(`.monaco-editor .tokens-inspect-widget { border: ${borderWidth}px solid ${border}; }`);
 		collector.addRule(`.monaco-editor .tokens-inspect-widget .tokens-inspect-separator { background-color: ${border}; }`);
 	}

src/vs/editor/standalone/browser/standaloneThemeServiceImpl.ts

@@ -15,6 +15,7 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { ColorIdentifier, Extensions, IColorRegistry } from 'vs/platform/theme/common/colorRegistry';
 import { Extensions as ThemingExtensions, ICssStyleCollector, IFileIconTheme, IThemingRegistry, ITokenStyle } from 'vs/platform/theme/common/themeService';
 import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
 
 const VS_THEME_NAME = 'vs';
 const VS_DARK_THEME_NAME = 'vs-dark';
@@ -107,11 +108,11 @@ class StandaloneTheme implements IStandaloneTheme {
 		return Object.prototype.hasOwnProperty.call(this.getColors(), colorId);
 	}
 
-	public get type() {
+	public get type(): ColorScheme {
 		switch (this.base) {
-			case VS_THEME_NAME: return 'light';
-			case HC_BLACK_THEME_NAME: return 'hc';
-			default: return 'dark';
+			case VS_THEME_NAME: return ColorScheme.LIGHT;
+			case HC_BLACK_THEME_NAME: return ColorScheme.HIGH_CONTRAST;
+			default: return ColorScheme.DARK;
 		}
 	}
 

src/vs/editor/standalone/test/browser/standaloneLanguages.test.ts

@@ -12,7 +12,8 @@ import { TokenTheme } from 'vs/editor/common/modes/supports/tokenization';
 import { ILineTokens, IToken, TokenizationSupport2Adapter, TokensProvider } from 'vs/editor/standalone/browser/standaloneLanguages';
 import { IStandaloneTheme, IStandaloneThemeData, IStandaloneThemeService } from 'vs/editor/standalone/common/standaloneThemeService';
 import { ColorIdentifier } from 'vs/platform/theme/common/colorRegistry';
-import { IFileIconTheme, IColorTheme, LIGHT, ITokenStyle } from 'vs/platform/theme/common/themeService';
+import { ColorScheme } from 'vs/platform/theme/common/theme';
+import { IFileIconTheme, IColorTheme, ITokenStyle } from 'vs/platform/theme/common/themeService';
 
 suite('TokenizationSupport2Adapter', () => {
 
@@ -46,9 +47,9 @@ suite('TokenizationSupport2Adapter', () => {
 
 				tokenTheme: new MockTokenTheme(),
 
-				themeName: LIGHT,
+				themeName: ColorScheme.LIGHT,
 
-				type: LIGHT,
+				type: ColorScheme.LIGHT,
 
 				getColor: (color: ColorIdentifier, useDefault?: boolean): Color => {
 					throw new Error('Not implemented');

src/vs/editor/test/common/modes/supports/characterPair.test.ts

@@ -8,7 +8,6 @@ import { StandardTokenType } from 'vs/editor/common/modes';
 import { CharacterPairSupport } from 'vs/editor/common/modes/supports/characterPair';
 import { TokenText, createFakeScopedLineTokens } from 'vs/editor/test/common/modesTestUtils';
 import { StandardAutoClosingPairConditional } from 'vs/editor/common/modes/languageConfiguration';
-import { find } from 'vs/base/common/arrays';
 
 suite('CharacterPairSupport', () => {
 
@@ -55,7 +54,7 @@ suite('CharacterPairSupport', () => {
 	});
 
 	function findAutoClosingPair(characterPairSupport: CharacterPairSupport, character: string): StandardAutoClosingPairConditional | undefined {
-		return find(characterPairSupport.getAutoClosingPairs(), autoClosingPair => autoClosingPair.open === character);
+		return characterPairSupport.getAutoClosingPairs().find(autoClosingPair => autoClosingPair.open === character);
 	}
 
 	function testShouldAutoClose(characterPairSupport: CharacterPairSupport, line: TokenText[], character: string, column: number): boolean {