Merge VS Code 1.26.1 (#2394)

* Squash merge commits for 1.26 (#1) (#2323)

* Polish tag search as per feedback (#55269)

* Polish tag search as per feedback

* Updated regex

* Allow users to opt-out of features that send online requests in the background (#55097)

* settings sweep #54690

* Minor css tweaks to enable eoverflow elipsis in more places (#55277)

* fix an issue with titlebarheight when not scaling with zoom

* Settings descriptions update #54690

* fixes #55209

* Settings editor - many padding fixes

* More space above level 2 label

* Fixing Cannot debug npm script using Yarn #55103

* Settings editor - show ellipsis when description overflows

* Settings editor - ... fix measuring around links, relayout

* Setting descriptions

* Settings editor - fix ... for some short lines, fix select container width

* Settings editor - overlay trees so scrollable shadow is full width

* Fix #54133 - missing extension settings after reload

* Settings color token description tweak

* Settings editor - disable overflow indicator temporarily, needs to be faster

* Added command to Run the selected npm script

* fixes #54452

* fixes #54929

* fixes #55248

* prefix command with extension name

* Contribute run selected to the context menu

* node-debug@1.26.6

* Allow terminal rendererType to be swapped out at runtime

Part of #53274
Fixes #55344

* Settings editor - fix not focusing search when restoring editor
setInput must be actually async. Will be fixed naturally when we aren't using winJS promises...

* Settings editor - TOC should only expand the section with a selected item

* Bump node-debug2

* Settings editor - Tree focus outlines

* Settings editor - don't blink the scrollbar when toc selection changes
And hide TOC correctly when the editor is narrow

* Settings editor - header rows should not be selectable

* fixes #54877

* change debug assignee to isi

* Settings sweep (#54690)

* workaround for #55051

* Settings sweep (#54690)

* settings sweep

#54690

* Don't try closing tags when you type > after another >

* Describe what implementation code lens does

Fixes #55370

* fix javadoc formatter setting description

* fixes #55325

* update to officical TS version

* Settings editor - Even more padding, use semibold instead of bold

* Fix #55357 - fix TOC twistie

* fixes #55288

* explorer: refresh on di change file system provider registration

fixes #53256

* Disable push to Linux repo to test standalone publisher

* New env var to notify log level to extensions #54001

* Disable snippets in extension search (when not in suggest dropdown) (#55281)

* Disable snippits in extension search (when not in suggest dropdown)

* Add monaco input contributions

* Fix bug preventing snippetSuggestions from taking effect in sub-editors

* Latest emmet helper to fix #52366

* Fix comment updates for threads within same file

* Allow extensions to log telemetry to log files #54001

* Pull latest css grammar

* files.exclude control - use same style for "add" vs "edit"

* files.exclude control - focus/keyboard behavior

* don't show menubar too early

* files.exclude - better styling

* Place cursor at end of extensions search box on autofill (#55254)

* Place cursor at end of extensions search box on autofill

* Use position instead of selection

* fix linux build issue (empty if block)

* Settings editor - fix extension category prefixes

* Settings editor - add simple ellipsis for first line that overflows, doesn't cover case when first line does not overflow but there is more text, TODO

* File/Text search provider docs

* Fixes #52655

* Include epoch (#55008)

* Fixes #53385

* Fixes #49480

*  VS Code Insiders (Users) not opening Fixes #55353

* Better handling of the case when the extension host fails to start

* Fixes #53966

*  Remove confusing Start from wordPartLeft commands ID

* vscode-xterm@3.6.0-beta12

Fixes #55488

* Initial size is set to infinity!! Fixes #55461

* Polish embeddedEditorBackground

* configuration service misses event

* Fix #55224 - fix duplicate results in multiroot workspace from splitting the diskseach query

* Select all not working in issue reporter on mac, fixes #55424

* Disable fuzzy matching for extensions autosuggest (#55498)

* Fix clipping of extensions search border in some third party themes (#55504)

* fixes #55538

* Fix bug causing an aria alert to not be shown the third time
 (and odd numbers thereafter)

* Settings editor - work around rendering glitch with webkit-line-clamp

* Settings editor - revert earlier '...' changes

* Settings editor - move enumDescription to its own div, because it disturbs -webkit-line-clamp for some reason

* Settings editor - better overflow indicator

* Don't show existing filters in autocomplete (#55495)

* Dont show existing filters in autocomplete

* Simplify

* Settings Editor: Add aria labels for input elements Fixes: #54836 (#55543)

* fixes #55223

* Update vscode-css-languageservice to 3.0.10-next.1

* Fix #55509 - settings navigation

* Fix #55519

* Fix #55520

* FIx #55524

* Fix #55556 - include wordSeparators in all search queries, so findTextInFiles can respect isWordMatch correctly

* oss updates for endgame

* Fix unit tests

* fixes #55522

* Avoid missing manifest error from bubbling up #54757

* Settings format crawl

* Search provider - Fix FileSearchProvider to return array, not progress

* Fix #55598

* Settings editor - fix NPE rendering settings with no description

* dont render inden guides in search box (#55600)

* fixes #55454

* More settings crawl

* Another change for #55598 - maxResults applies to FileSearch and TextSearch but not FileIndex

* Fix FileSearchProvider unit tests for progress change

* fixes #55561

* Settings description update for #54690

* Update setting descriptions for online services

* Minor edits

* fixes #55513

* fixes #55451

* Fix #55612 - fix findTextInFiles cancellation

* fixes #55539

* More setting description tweaks

* Setting to disable online experiments #54354

* fixes #55507

* fixes #55515

* Show online services action only in Insiders for now

* Settings editor - change toc behavior default to 'filter'

* Settings editor - nicer filter count style during search

* Fix #55617 - search viewlet icons

* Settings editor - better styling for element count indicator

* SearchProvider - fix NPE when searching extraFileResources

* Allow extends to work without json suffix

Fixes #16905

* Remove accessability options logic entirely

Follow up on #55451

* use latest version of DAP

* fixes #55490

* fixes #55122

* fixes #52332

* Avoid assumptions about git: URIs (fixes #36236)

* relative path for descriptions

* resourece: get rid of isFile context key

fixes #48275

* Register previous ids for compatibility (#53497)

* more tuning for #48275

* no need to always re-read "files explorer"

fixes #52003

* read out active composites properly

fixes #51967

* Update link colors for hc theme to meet color contrast ratio, fixes #55651

Also updated link color for `textLinkActiveForeground` to be the same as `textLinkForeground` as it wasn't properly updated

* detect 'winpty-agent.exe'; fixes #55672

* node-debug@1.26.7

* reset counter on new label

* Settings editor - fix multiple setting links in one description

* Settings editor - color code blocks in setting descriptions, fix #55532

* Settings editor - hover color in TOC

* Settings editor - fix navigation NPE

* Settings editor - fix text control width

* Settings editor - maybe fix #55684

* Fix bug causing cursor to not move on paste

* fixes #53582

* Use ctrlCmd instead of ctrl for go down from search box

* fixes #55264

* fixes #55456

* filter for spcaes before triggering search (#55611)

* Fix #55698 - don't lose filtered TOC counts when refreshing TOC

* fixes #55421

* fixes #28979

* fixes #55576

* only add check for updates to windows/linux help

* readonly files: append decoration to label

fixes #53022

* debug: do not show toolbar while initialising

fixes #55026

* Opening launch.json should not activate debug extensions

fixes #55029

* fixes #55435

* fixes #55434

* fixes #55439

* trigger menu only on altkey up

* Fix #50555 - fix settings editor memory leak

* Fix #55712 - no need to focus 'a' anymore when restoring control focus after tree render

* fixes #55335

* proper fix for readonly model

fixes #53022

* improve FoldingRangeKind spec (for #55686)

* Use class with static fields (fixes #55494)

* Fixes #53671

* fixes #54630

* [html] should disable ionic suggestions by default. Currently forces deprecated Ionic v1 suggestions in .html files while typing. Fixes #53324

* cleanup deps

* debug issues back to andre

* update electron for smoketest

* Fix #55757 - prevent settings tabs from overflowing

* Fix #53897 - revert setting menu defaults to old editor

* Add enum descriptions to `typescript.preferences.importModuleSpecifier`

* Fix #55767 - leaking style elements from settings editor

* Fix #55521 - prevent flashing when clicking in exclude control

* Update Git modified color for contrast ratio, fixes #53140

* Revert "Merge branch 'master' of github.com:Microsoft/vscode"

This reverts commit bf46b6bfbae0cab99c2863e1244a916181fa9fbc, reversing
changes made to e275a424483dfb4ed33b428c97d5e2c441d6b917.

* Revert "Revert "Merge branch 'master' of github.com:Microsoft/vscode""

This reverts commit 53949d963f39e40757557c6526332354a31d9154.

* don't ask to install an incomplete menu

* Fix NPE in terminal AccessibilityManager

Fixes #55744

* don't display fallback menu unless we've closed the last window

* fixes #55547

* Fix smoke tests for extension search box

* Update OSSREADME.json for Electron 2.0.5

* Update distro

Includes Chromium license changes

* fix #55455

* fix #55865

* fixes #55893

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation (#55805)

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation

* ONly show on @recommended or @recommended:workspace

* Make more consistant

* Fix #55911

* Understand json activity (#55926)

* Understand json file activity

* Refactoring

* adding composer.json

* Distro update for experiments

* use terminal.processId for auto-attach; fixes #55918

* Reject invalid URI with vscode.openFolder (for #55891)

* improve win32 setup system vs user detection

fixes #55840

fixes #55840

delay winreg import

related to #55840

show notification earlier

related to #55840

fix #55840

update inno setup message

related to #55840

* Fix #55593 - this code only operates on local paths, so use fsPath and Uri.file instead

* Bring back the old menu due to electron 2.0 issues (#55913)

* add the old menu back for native menus

* make menu labels match

* `vscode.openFolder`: treat missing URI schema gracefully (for #55891)

* delay EH reattach; fixes #55955

* Mark all json files under appSettingsHome as settings

* Use localized strings for telemetry opt-out

* Exception when saving file editor opened from remote file provider (fixes #55051)

* Remove terminal menu from stable

Fixes 56003

* VSCode Insiders crashes on open with TypeError: Cannot read property 'lastIndexOf' of undefined. Fixes #54933

* improve fix for #55891

* fix #55916

* Improve #55891

* increase EH debugging restart delay; fixes #55955

* Revert "Don't include non-resource entries in history quick pick"

This reverts commit 37209a838e9f7e9abe6dc53ed73cdf1e03b72060.

* Diff editor: horizontal scrollbar height is smaller (fixes #56062)

* improve openFolder uri fix (correctly treat backslashes)

* fixes #56116
repair ipc for native menubar keybindings

* Fix #56240 - Open the JSON settings editor instead of the UI editor

* Fix #55536

* uriDisplay: if no formatter is registered fall back to getPathlabel

fixes #56104

* VSCode hangs when opening python file. Fixes #56377

* VS Code Hangs When Opening Specific PowerShell File. Fixes #56430

* Fix #56433 - search extraFileResources even when no folders open

* Workaround #55649

* Fix in master #56371

* Fix tests #56371

* Fix in master #56317

* increase version to 1.26.1

* Fixes #56387: Handle SIGPIPE in extension host

* fixes #56185

* Fix merge issues (part 1)

* Fix build breaks (part 1)

* Build breaks (part 2)

* Build breaks (part 3)

* More build breaks (part 4)

* Fix build breaks (part 5)

* WIP

* Fix menus

* Render query result and message panels (#2363)

* Put back query editor hot exit changes

* Fix grid changes that broke profiler (#2365)

* Update APIs for saving query editor state

* Fix restore view state for profiler and edit data

* Updating custom default themes to support 4.5:1 contrast ratio

* Test updates

* Fix Extension Manager and Windows Setup

* Update license headers

* Add appveyor and travis files back

* Fix hidden modal dropdown issue

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

@@ -3,39 +3,34 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-'use strict';
-
 import { coalesce } from 'vs/base/common/arrays';
 import { onUnexpectedExternalError } from 'vs/base/common/errors';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ITextModel } from 'vs/editor/common/model';
 import { registerDefaultLanguageCommand } from 'vs/editor/browser/editorExtensions';
 import { Hover, HoverProviderRegistry } from 'vs/editor/common/modes';
-import { asWinJsPromise } from 'vs/base/common/async';
 import { Position } from 'vs/editor/common/core/position';
+import { CancellationToken } from 'vs/base/common/cancellation';
 
-export function getHover(model: ITextModel, position: Position): TPromise<Hover[]> {
+export function getHover(model: ITextModel, position: Position, token: CancellationToken): Promise<Hover[]> {
 
 	const supports = HoverProviderRegistry.ordered(model);
-	const values: Hover[] = [];
 
-	const promises = supports.map((support, idx) => {
-		return asWinJsPromise((token) => {
-			return support.provideHover(model, position, token);
-		}).then((result) => {
-			if (result) {
-				let hasRange = (typeof result.range !== 'undefined');
-				let hasHtmlContent = typeof result.contents !== 'undefined' && result.contents && result.contents.length > 0;
-				if (hasRange && hasHtmlContent) {
-					values[idx] = result;
-				}
-			}
+	const promises = supports.map(support => {
+		return Promise.resolve(support.provideHover(model, position, token)).then(hover => {
+			return hover && isValid(hover) ? hover : undefined;
 		}, err => {
 			onUnexpectedExternalError(err);
+			return undefined;
 		});
 	});
 
-	return TPromise.join(promises).then(() => coalesce(values));
+	return Promise.all(promises).then(values => coalesce(values));
 }
 
-registerDefaultLanguageCommand('_executeHoverProvider', getHover);
+registerDefaultLanguageCommand('_executeHoverProvider', (model, position) => getHover(model, position, CancellationToken.None));
+
+function isValid(result: Hover) {
+	const hasRange = (typeof result.range !== 'undefined');
+	const hasHtmlContent = typeof result.contents !== 'undefined' && result.contents && result.contents.length > 0;
+	return hasRange && hasHtmlContent;
+}

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

@@ -13,7 +13,8 @@ import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { IModeService } from 'vs/editor/common/services/modeService';
 import { Range } from 'vs/editor/common/core/range';
-import * as editorCommon from 'vs/editor/common/editorCommon';
+import { IEditorContribution, IScrollEvent } from 'vs/editor/common/editorCommon';
+import { IConfigurationChangedEvent } from 'vs/editor/common/config/editorOptions';
 import { registerEditorAction, registerEditorContribution, ServicesAccessor, EditorAction } from 'vs/editor/browser/editorExtensions';
 import { ICodeEditor, IEditorMouseEvent, MouseTargetType } from 'vs/editor/browser/editorBrowser';
 import { ModesContentHoverWidget } from './modesContentHover';
@@ -24,13 +25,15 @@ import { editorHoverHighlight, editorHoverBackground, editorHoverBorder, textLin
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { MarkdownRenderer } from 'vs/editor/contrib/markdown/markdownRenderer';
 import { IEmptyContentData } from 'vs/editor/browser/controller/mouseTarget';
+import { HoverStartMode } from 'vs/editor/contrib/hover/hoverOperation';
+import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
 
-export class ModesHoverController implements editorCommon.IEditorContribution {
+export class ModesHoverController implements IEditorContribution {
 
 	private static readonly ID = 'editor.contrib.hover';
 
-	private _editor: ICodeEditor;
 	private _toUnhook: IDisposable[];
+	private _didChangeConfigurationHandler: IDisposable;
 
 	private _contentWidget: ModesContentHoverWidget;
 	private _glyphWidget: ModesGlyphHoverWidget;
@@ -51,35 +54,57 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 
 	private _isMouseDown: boolean;
 	private _hoverClicked: boolean;
+	private _isHoverEnabled: boolean;
+	private _isHoverSticky: boolean;
 
 	static get(editor: ICodeEditor): ModesHoverController {
 		return editor.getContribution<ModesHoverController>(ModesHoverController.ID);
 	}
 
-	constructor(editor: ICodeEditor,
+	constructor(private readonly _editor: ICodeEditor,
 		@IOpenerService private readonly _openerService: IOpenerService,
 		@IModeService private readonly _modeService: IModeService,
 		@IThemeService private readonly _themeService: IThemeService
 	) {
-		this._editor = editor;
-
 		this._toUnhook = [];
-		this._isMouseDown = false;
 
-		if (editor.getConfiguration().contribInfo.hover) {
+		this._isMouseDown = false;
+		this._hoverClicked = false;
+
+		this._hookEvents();
+
+		this._didChangeConfigurationHandler = this._editor.onDidChangeConfiguration((e: IConfigurationChangedEvent) => {
+			if (e.contribInfo) {
+				this._hideWidgets();
+				this._unhookEvents();
+				this._hookEvents();
+			}
+		});
+	}
+
+	private _hookEvents(): void {
+		const hideWidgetsEventHandler = () => this._hideWidgets();
+
+		const hoverOpts = this._editor.getConfiguration().contribInfo.hover;
+		this._isHoverEnabled = hoverOpts.enabled;
+		this._isHoverSticky = hoverOpts.sticky;
+		if (this._isHoverEnabled) {
 			this._toUnhook.push(this._editor.onMouseDown((e: IEditorMouseEvent) => this._onEditorMouseDown(e)));
 			this._toUnhook.push(this._editor.onMouseUp((e: IEditorMouseEvent) => this._onEditorMouseUp(e)));
 			this._toUnhook.push(this._editor.onMouseMove((e: IEditorMouseEvent) => this._onEditorMouseMove(e)));
-			this._toUnhook.push(this._editor.onMouseLeave((e: IEditorMouseEvent) => this._hideWidgets()));
 			this._toUnhook.push(this._editor.onKeyDown((e: IKeyboardEvent) => this._onKeyDown(e)));
-			this._toUnhook.push(this._editor.onDidChangeModel(() => this._hideWidgets()));
 			this._toUnhook.push(this._editor.onDidChangeModelDecorations(() => this._onModelDecorationsChanged()));
-			this._toUnhook.push(this._editor.onDidScrollChange((e) => {
-				if (e.scrollTopChanged || e.scrollLeftChanged) {
-					this._hideWidgets();
-				}
-			}));
+		} else {
+			this._toUnhook.push(this._editor.onMouseMove(hideWidgetsEventHandler));
 		}
+
+		this._toUnhook.push(this._editor.onMouseLeave(hideWidgetsEventHandler));
+		this._toUnhook.push(this._editor.onDidChangeModel(hideWidgetsEventHandler));
+		this._toUnhook.push(this._editor.onDidScrollChange((e: IScrollEvent) => this._onEditorScrollChanged(e)));
+	}
+
+	private _unhookEvents(): void {
+		this._toUnhook = dispose(this._toUnhook);
 	}
 
 	private _onModelDecorationsChanged(): void {
@@ -87,10 +112,16 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 		this.glyphWidget.onModelDecorationsChanged();
 	}
 
+	private _onEditorScrollChanged(e: IScrollEvent): void {
+		if (e.scrollTopChanged || e.scrollLeftChanged) {
+			this._hideWidgets();
+		}
+	}
+
 	private _onEditorMouseDown(mouseEvent: IEditorMouseEvent): void {
 		this._isMouseDown = true;
 
-		var targetType = mouseEvent.target.type;
+		const targetType = mouseEvent.target.type;
 
 		if (targetType === MouseTargetType.CONTENT_WIDGET && mouseEvent.target.detail === ModesContentHoverWidget.ID) {
 			this._hoverClicked = true;
@@ -115,19 +146,20 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 	}
 
 	private _onEditorMouseMove(mouseEvent: IEditorMouseEvent): void {
+		// const this._editor.getConfiguration().contribInfo.hover.sticky;
 		let targetType = mouseEvent.target.type;
-		let stopKey = platform.isMacintosh ? 'metaKey' : 'ctrlKey';
+		const hasStopKey = (platform.isMacintosh ? mouseEvent.event.metaKey : mouseEvent.event.ctrlKey);
 
 		if (this._isMouseDown && this._hoverClicked && this.contentWidget.isColorPickerVisible()) {
 			return;
 		}
 
-		if (targetType === MouseTargetType.CONTENT_WIDGET && mouseEvent.target.detail === ModesContentHoverWidget.ID && !mouseEvent.event[stopKey]) {
+		if (this._isHoverSticky && targetType === MouseTargetType.CONTENT_WIDGET && mouseEvent.target.detail === ModesContentHoverWidget.ID && !hasStopKey) {
 			// mouse moved on top of content hover widget
 			return;
 		}
 
-		if (targetType === MouseTargetType.OVERLAY_WIDGET && mouseEvent.target.detail === ModesGlyphHoverWidget.ID && !mouseEvent.event[stopKey]) {
+		if (this._isHoverSticky && targetType === MouseTargetType.OVERLAY_WIDGET && mouseEvent.target.detail === ModesGlyphHoverWidget.ID && !hasStopKey) {
 			// mouse moved on top of overlay hover widget
 			return;
 		}
@@ -141,12 +173,18 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 			}
 		}
 
-		if (this._editor.getConfiguration().contribInfo.hover && targetType === MouseTargetType.CONTENT_TEXT) {
+		if (targetType === MouseTargetType.CONTENT_TEXT) {
 			this.glyphWidget.hide();
-			this.contentWidget.startShowingAt(mouseEvent.target.range, false);
+
+			if (this._isHoverEnabled) {
+				this.contentWidget.startShowingAt(mouseEvent.target.range, HoverStartMode.Delayed, false);
+			}
 		} else if (targetType === MouseTargetType.GUTTER_GLYPH_MARGIN) {
 			this.contentWidget.hide();
-			this.glyphWidget.startShowingAt(mouseEvent.target.position.lineNumber);
+
+			if (this._isHoverEnabled) {
+				this.glyphWidget.startShowingAt(mouseEvent.target.position.lineNumber);
+			}
 		} else {
 			this._hideWidgets();
 		}
@@ -174,8 +212,8 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 		this._glyphWidget = new ModesGlyphHoverWidget(this._editor, renderer);
 	}
 
-	public showContentHover(range: Range, focus: boolean): void {
-		this.contentWidget.startShowingAt(range, focus);
+	public showContentHover(range: Range, mode: HoverStartMode, focus: boolean): void {
+		this.contentWidget.startShowingAt(range, mode, focus);
 	}
 
 	public getId(): string {
@@ -183,7 +221,9 @@ export class ModesHoverController implements editorCommon.IEditorContribution {
 	}
 
 	public dispose(): void {
-		this._toUnhook = dispose(this._toUnhook);
+		this._unhookEvents();
+		this._didChangeConfigurationHandler.dispose();
+
 		if (this._glyphWidget) {
 			this._glyphWidget.dispose();
 			this._glyphWidget = null;
@@ -211,7 +251,8 @@ class ShowHoverAction extends EditorAction {
 			precondition: null,
 			kbOpts: {
 				kbExpr: EditorContextKeys.editorTextFocus,
-				primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_I)
+				primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_I),
+				weight: KeybindingWeight.EditorContrib
 			}
 		});
 	}
@@ -223,7 +264,7 @@ class ShowHoverAction extends EditorAction {
 		}
 		const position = editor.getPosition();
 		const range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
-		controller.showContentHover(range, true);
+		controller.showContentHover(range, HoverStartMode.Immediate, true);
 	}
 }
 

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

@@ -4,21 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { RunOnceScheduler } from 'vs/base/common/async';
+import { RunOnceScheduler, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
 import { onUnexpectedError } from 'vs/base/common/errors';
-import { TPromise } from 'vs/base/common/winjs.base';
+import { CancellationToken } from 'vs/base/common/cancellation';
 
 export interface IHoverComputer<Result> {
 
-	/**
-	 * Overwrite the default hover time
-	 */
-	getHoverTimeMillis?: () => number;
-
 	/**
 	 * This is called after half the hover time
 	 */
-	computeAsync?: () => TPromise<Result>;
+	computeAsync?: (token: CancellationToken) => Promise<Result>;
 
 	/**
 	 * This is called after all the hover time
@@ -46,17 +41,23 @@ const enum ComputeHoverOperationState {
 	WAITING_FOR_ASYNC_COMPUTATION = 3
 }
 
+export const enum HoverStartMode {
+	Delayed = 0,
+	Immediate = 1
+}
+
 export class HoverOperation<Result> {
 
 	static HOVER_TIME = 300;
 
 	private _computer: IHoverComputer<Result>;
 	private _state: ComputeHoverOperationState;
+	private _hoverTime: number;
 
 	private _firstWaitScheduler: RunOnceScheduler;
 	private _secondWaitScheduler: RunOnceScheduler;
 	private _loadingMessageScheduler: RunOnceScheduler;
-	private _asyncComputationPromise: TPromise<void>;
+	private _asyncComputationPromise: CancelablePromise<void>;
 	private _asyncComputationPromiseDone: boolean;
 
 	private _completeCallback: (r: Result) => void;
@@ -66,10 +67,11 @@ export class HoverOperation<Result> {
 	constructor(computer: IHoverComputer<Result>, success: (r: Result) => void, error: (err: any) => void, progress: (progress: any) => void) {
 		this._computer = computer;
 		this._state = ComputeHoverOperationState.IDLE;
+		this._hoverTime = HoverOperation.HOVER_TIME;
 
-		this._firstWaitScheduler = new RunOnceScheduler(() => this._triggerAsyncComputation(), this._getHoverTimeMillis() / 2);
-		this._secondWaitScheduler = new RunOnceScheduler(() => this._triggerSyncComputation(), this._getHoverTimeMillis() / 2);
-		this._loadingMessageScheduler = new RunOnceScheduler(() => this._showLoadingMessage(), 3 * this._getHoverTimeMillis());
+		this._firstWaitScheduler = new RunOnceScheduler(() => this._triggerAsyncComputation(), 0);
+		this._secondWaitScheduler = new RunOnceScheduler(() => this._triggerSyncComputation(), 0);
+		this._loadingMessageScheduler = new RunOnceScheduler(() => this._showLoadingMessage(), 0);
 
 		this._asyncComputationPromise = null;
 		this._asyncComputationPromiseDone = false;
@@ -79,23 +81,35 @@ export class HoverOperation<Result> {
 		this._progressCallback = progress;
 	}
 
-	private _getHoverTimeMillis(): number {
-		if (this._computer.getHoverTimeMillis) {
-			return this._computer.getHoverTimeMillis();
-		}
-		return HoverOperation.HOVER_TIME;
+	public setHoverTime(hoverTime: number): void {
+		this._hoverTime = hoverTime;
+	}
+
+	private _firstWaitTime(): number {
+		return this._hoverTime / 2;
+	}
+
+	private _secondWaitTime(): number {
+		return this._hoverTime / 2;
+	}
+
+	private _loadingMessageTime(): number {
+		return 3 * this._hoverTime;
 	}
 
 	private _triggerAsyncComputation(): void {
 		this._state = ComputeHoverOperationState.SECOND_WAIT;
-		this._secondWaitScheduler.schedule();
+		this._secondWaitScheduler.schedule(this._secondWaitTime());
 
 		if (this._computer.computeAsync) {
 			this._asyncComputationPromiseDone = false;
-			this._asyncComputationPromise = this._computer.computeAsync().then((asyncResult: Result) => {
-				this._asyncComputationPromiseDone = true;
-				this._withAsyncResult(asyncResult);
-			}, (e) => this._onError(e));
+			this._asyncComputationPromise = createCancelablePromise(token => {
+				return this._computer.computeAsync(token).then((asyncResult: Result) => {
+					this._asyncComputationPromiseDone = true;
+					this._withAsyncResult(asyncResult);
+				}, (e) => this._onError(e));
+			});
+
 		} else {
 			this._asyncComputationPromiseDone = true;
 		}
@@ -152,11 +166,25 @@ export class HoverOperation<Result> {
 		}
 	}
 
-	public start(): void {
-		if (this._state === ComputeHoverOperationState.IDLE) {
-			this._state = ComputeHoverOperationState.FIRST_WAIT;
-			this._firstWaitScheduler.schedule();
-			this._loadingMessageScheduler.schedule();
+	public start(mode: HoverStartMode): void {
+		if (mode === HoverStartMode.Delayed) {
+			if (this._state === ComputeHoverOperationState.IDLE) {
+				this._state = ComputeHoverOperationState.FIRST_WAIT;
+				this._firstWaitScheduler.schedule(this._firstWaitTime());
+				this._loadingMessageScheduler.schedule(this._loadingMessageTime());
+			}
+		} else {
+			switch (this._state) {
+				case ComputeHoverOperationState.IDLE:
+					this._triggerAsyncComputation();
+					this._secondWaitScheduler.cancel();
+					this._triggerSyncComputation();
+					break;
+				case ComputeHoverOperationState.SECOND_WAIT:
+					this._secondWaitScheduler.cancel();
+					this._triggerSyncComputation();
+					break;
+			}
 		}
 	}
 

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

@@ -6,13 +6,12 @@
 
 import * as nls from 'vs/nls';
 import * as dom from 'vs/base/browser/dom';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IRange, Range } from 'vs/editor/common/core/range';
 import { Position } from 'vs/editor/common/core/position';
 import { HoverProviderRegistry, Hover, IColor, DocumentColorProvider } from 'vs/editor/common/modes';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { getHover } from 'vs/editor/contrib/hover/getHover';
-import { HoverOperation, IHoverComputer } from './hoverOperation';
+import { HoverOperation, IHoverComputer, HoverStartMode } from './hoverOperation';
 import { ContentHoverWidget } from './hoverWidgets';
 import { IMarkdownString, MarkdownString, isEmptyMarkdownString, markedStringsEquals } from 'vs/base/common/htmlContent';
 import { MarkdownRenderer } from 'vs/editor/contrib/markdown/markdownRenderer';
@@ -21,9 +20,10 @@ import { ColorPickerModel } from 'vs/editor/contrib/colorPicker/colorPickerModel
 import { ColorPickerWidget } from 'vs/editor/contrib/colorPicker/colorPickerWidget';
 import { ColorDetector } from 'vs/editor/contrib/colorPicker/colorDetector';
 import { Color, RGBA } from 'vs/base/common/color';
-import { IDisposable, empty as EmptyDisposable, dispose, combinedDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, Disposable, combinedDisposable } from 'vs/base/common/lifecycle';
 import { getColorPresentations } from 'vs/editor/contrib/colorPicker/color';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
+import { CancellationToken } from 'vs/base/common/cancellation';
 const $ = dom.$;
 
 class ColorHover {
@@ -57,17 +57,17 @@ class ModesContentComputer implements IHoverComputer<HoverPart[]> {
 		this._result = [];
 	}
 
-	computeAsync(): TPromise<HoverPart[]> {
+	computeAsync(token: CancellationToken): Promise<HoverPart[]> {
 		const model = this._editor.getModel();
 
 		if (!HoverProviderRegistry.has(model)) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}
 
 		return getHover(model, new Position(
 			this._range.startLineNumber,
 			this._range.startColumn
-		));
+		), token);
 	}
 
 	computeSync(): HoverPart[] {
@@ -167,12 +167,11 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 	private _shouldFocus: boolean;
 	private _colorPicker: ColorPickerWidget;
 
-	private renderDisposable: IDisposable = EmptyDisposable;
-	private toDispose: IDisposable[] = [];
+	private renderDisposable: IDisposable = Disposable.None;
 
 	constructor(
 		editor: ICodeEditor,
-		markdownRenderner: MarkdownRenderer,
+		markdownRenderer: MarkdownRenderer,
 		private readonly _themeService: IThemeService
 	) {
 		super(ModesContentHoverWidget.ID, editor);
@@ -181,8 +180,8 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 		this._highlightDecorations = [];
 		this._isChangingDecorations = false;
 
-		this._markdownRenderer = markdownRenderner;
-		markdownRenderner.onDidRenderCodeBlock(this.onContentsChange, this, this.toDispose);
+		this._markdownRenderer = markdownRenderer;
+		this._register(markdownRenderer.onDidRenderCodeBlock(this.onContentsChange, this));
 
 		this._hoverOperation = new HoverOperation(
 			this._computer,
@@ -191,21 +190,23 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 			result => this._withResult(result, false)
 		);
 
-		this.toDispose.push(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.FOCUS, () => {
+		this._register(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.FOCUS, () => {
 			if (this._colorPicker) {
 				dom.addClass(this.getDomNode(), 'colorpicker-hover');
 			}
 		}));
-		this.toDispose.push(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.BLUR, () => {
+		this._register(dom.addStandardDisposableListener(this.getDomNode(), dom.EventType.BLUR, () => {
 			dom.removeClass(this.getDomNode(), 'colorpicker-hover');
 		}));
+		this._register(editor.onDidChangeConfiguration((e) => {
+			this._hoverOperation.setHoverTime(this._editor.getConfiguration().contribInfo.hover.delay);
+		}));
 	}
 
 	dispose(): void {
 		this.renderDisposable.dispose();
-		this.renderDisposable = EmptyDisposable;
+		this.renderDisposable = Disposable.None;
 		this._hoverOperation.cancel();
-		this.toDispose = dispose(this.toDispose);
 		super.dispose();
 	}
 
@@ -220,12 +221,12 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 			this._computer.clearResult();
 
 			if (!this._colorPicker) { // TODO@Michel ensure that displayed text for other decorations is computed even if color picker is in place
-				this._hoverOperation.start();
+				this._hoverOperation.start(HoverStartMode.Delayed);
 			}
 		}
 	}
 
-	startShowingAt(range: Range, focus: boolean): void {
+	startShowingAt(range: Range, mode: HoverStartMode, focus: boolean): void {
 		if (this._lastRange && this._lastRange.equalsRange(range)) {
 			// We have to show the widget at the exact same range as before, so no work is needed
 			return;
@@ -240,10 +241,10 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 			if (this._showAtPosition.lineNumber !== range.startLineNumber) {
 				this.hide();
 			} else {
-				var filteredMessages: HoverPart[] = [];
-				for (var i = 0, len = this._messages.length; i < len; i++) {
-					var msg = this._messages[i];
-					var rng = msg.range;
+				let filteredMessages: HoverPart[] = [];
+				for (let i = 0, len = this._messages.length; i < len; i++) {
+					const msg = this._messages[i];
+					const rng = msg.range;
 					if (rng.startColumn <= range.startColumn && rng.endColumn >= range.endColumn) {
 						filteredMessages.push(msg);
 					}
@@ -262,7 +263,7 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 		this._lastRange = range;
 		this._computer.setRange(range);
 		this._shouldFocus = focus;
-		this._hoverOperation.start();
+		this._hoverOperation.start(mode);
 	}
 
 	hide(): void {
@@ -273,7 +274,7 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 		this._highlightDecorations = this._editor.deltaDecorations(this._highlightDecorations, []);
 		this._isChangingDecorations = false;
 		this.renderDisposable.dispose();
-		this.renderDisposable = EmptyDisposable;
+		this.renderDisposable = Disposable.None;
 		this._colorPicker = null;
 	}
 
@@ -299,10 +300,10 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 		this._colorPicker = null;
 
 		// update column from which to show
-		var renderColumn = Number.MAX_VALUE,
-			highlightRange = messages[0].range,
-			fragment = document.createDocumentFragment(),
-			isEmptyHoverContent = true;
+		let renderColumn = Number.MAX_VALUE;
+		let highlightRange = messages[0].range;
+		let fragment = document.createDocumentFragment();
+		let isEmptyHoverContent = true;
 
 		let containColorPicker = false;
 		let markdownDisposeable: IDisposable;
@@ -338,7 +339,7 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 				const model = new ColorPickerModel(color, [], 0);
 				const widget = new ColorPickerWidget(fragment, model, this._editor.getConfiguration().pixelRatio, this._themeService);
 
-				getColorPresentations(editorModel, colorInfo, msg.provider).then(colorPresentations => {
+				getColorPresentations(editorModel, colorInfo, msg.provider, CancellationToken.None).then(colorPresentations => {
 					model.colorPresentations = colorPresentations;
 					const originalText = this._editor.getModel().getValueInRange(msg.range);
 					model.guessColorPresentation(color, originalText);
@@ -360,11 +361,11 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 							newRange = range.setEndPosition(range.endLineNumber, range.startColumn + model.presentation.label.length);
 						}
 
-						editorModel.pushEditOperations([], textEdits, () => []);
+						this._editor.executeEdits('colorpicker', textEdits);
 
 						if (model.presentation.additionalTextEdits) {
 							textEdits = [...model.presentation.additionalTextEdits];
-							editorModel.pushEditOperations([], textEdits, () => []);
+							this._editor.executeEdits('colorpicker', textEdits);
 							this.hide();
 						}
 						this._editor.pushUndoStop();
@@ -380,7 +381,7 @@ export class ModesContentHoverWidget extends ContentHoverWidget {
 								blue: color.rgba.b / 255,
 								alpha: color.rgba.a
 							}
-						}, msg.provider).then((colorPresentations) => {
+						}, msg.provider, CancellationToken.None).then((colorPresentations) => {
 							model.colorPresentations = colorPresentations;
 						});
 					};

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
-import { HoverOperation, IHoverComputer } from './hoverOperation';
+import { HoverOperation, IHoverComputer, HoverStartMode } from './hoverOperation';
 import { GlyphHoverWidget } from './hoverWidgets';
 import { $ } from 'vs/base/browser/dom';
 import { MarkdownRenderer } from 'vs/editor/contrib/markdown/markdownRenderer';
@@ -123,7 +123,7 @@ export class ModesGlyphHoverWidget extends GlyphHoverWidget {
 			// we need to recompute the displayed text
 			this._hoverOperation.cancel();
 			this._computer.clearResult();
-			this._hoverOperation.start();
+			this._hoverOperation.start(HoverStartMode.Delayed);
 		}
 	}
 
@@ -139,7 +139,7 @@ export class ModesGlyphHoverWidget extends GlyphHoverWidget {
 
 		this._lastLineNumber = lineNumber;
 		this._computer.setLineNumber(lineNumber);
-		this._hoverOperation.start();
+		this._hoverOperation.start(HoverStartMode.Delayed);
 	}
 
 	public hide(): void {