Merge from master

src/vs/editor/contrib/codeAction/codeActionModel.ts

@@ -3,11 +3,10 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
-import { debounceEvent, Emitter, Event } from 'vs/base/common/event';
+import { CancelablePromise, createCancelablePromise, TimeoutTimer } from 'vs/base/common/async';
+import { Emitter, Event } from 'vs/base/common/event';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
-import URI from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
+import { URI } from 'vs/base/common/uri';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { Position } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
@@ -24,22 +23,24 @@ export const SUPPORTED_CODE_ACTIONS = new RawContextKey<string>('supportedCodeAc
 export class CodeActionOracle {
 
 	private _disposables: IDisposable[] = [];
+	private readonly _autoTriggerTimer = new TimeoutTimer();
 
 	constructor(
 		private _editor: ICodeEditor,
 		private readonly _markerService: IMarkerService,
 		private _signalChange: (e: CodeActionsComputeEvent) => any,
-		delay: number = 250,
+		private readonly _delay: number = 250,
 		private readonly _progressService?: IProgressService,
 	) {
 		this._disposables.push(
-			debounceEvent(this._markerService.onMarkerChanged, (last, cur) => last ? last.concat(cur) : cur, delay / 2)(e => this._onMarkerChanges(e)),
-			debounceEvent(this._editor.onDidChangeCursorPosition, (last, cur) => cur, delay)(e => this._onCursorChange())
+			this._markerService.onMarkerChanged(e => this._onMarkerChanges(e)),
+			this._editor.onDidChangeCursorPosition(() => this._onCursorChange()),
 		);
 	}
 
 	dispose(): void {
 		this._disposables = dispose(this._disposables);
+		this._autoTriggerTimer.cancel();
 	}
 
 	trigger(trigger: CodeActionTrigger) {
@@ -48,21 +49,29 @@ export class CodeActionOracle {
 	}
 
 	private _onMarkerChanges(resources: URI[]): void {
-		const { uri } = this._editor.getModel();
-		for (const resource of resources) {
-			if (resource.toString() === uri.toString()) {
+		const model = this._editor.getModel();
+		if (!model) {
+			return;
+		}
+
+		if (resources.some(resource => resource.toString() === model.uri.toString())) {
+			this._autoTriggerTimer.cancelAndSet(() => {
 				this.trigger({ type: 'auto' });
-				return;
-			}
+			}, this._delay);
 		}
 	}
 
 	private _onCursorChange(): void {
-		this.trigger({ type: 'auto' });
+		this._autoTriggerTimer.cancelAndSet(() => {
+			this.trigger({ type: 'auto' });
+		}, this._delay);
 	}
 
-	private _getRangeOfMarker(selection: Selection): Range {
+	private _getRangeOfMarker(selection: Selection): Range | undefined {
 		const model = this._editor.getModel();
+		if (!model) {
+			return undefined;
+		}
 		for (const marker of this._markerService.read({ resource: model.uri })) {
 			if (Range.intersectRanges(marker, selection)) {
 				return Range.lift(marker);
@@ -72,9 +81,12 @@ export class CodeActionOracle {
 	}
 
 	private _getRangeOfSelectionUnlessWhitespaceEnclosed(trigger: CodeActionTrigger): Selection | undefined {
+		if (!this._editor.hasModel()) {
+			return undefined;
+		}
 		const model = this._editor.getModel();
 		const selection = this._editor.getSelection();
-		if (selection.isEmpty() && !(trigger.filter && trigger.filter.includeSourceActions)) {
+		if (selection.isEmpty() && trigger.type === 'auto') {
 			const { lineNumber, column } = selection.getPosition();
 			const line = model.getLineContent(lineNumber);
 			if (line.length === 0) {
@@ -97,7 +109,7 @@ export class CodeActionOracle {
 				}
 			}
 		}
-		return selection;
+		return selection ? selection : undefined;
 	}
 
 	private _createEventAndSignalChange(trigger: CodeActionTrigger, selection: Selection | undefined): Thenable<CodeAction[] | undefined> {
@@ -109,15 +121,26 @@ export class CodeActionOracle {
 				position: undefined,
 				actions: undefined,
 			});
-			return TPromise.as(undefined);
+			return Promise.resolve(undefined);
 		} else {
 			const model = this._editor.getModel();
+			if (!model) {
+				// cancel
+				this._signalChange({
+					trigger,
+					rangeOrSelection: undefined,
+					position: undefined,
+					actions: undefined,
+				});
+				return Promise.resolve(undefined);
+			}
+
 			const markerRange = this._getRangeOfMarker(selection);
 			const position = markerRange ? markerRange.getStartPosition() : selection.getStartPosition();
 			const actions = createCancelablePromise(token => getCodeActions(model, selection, trigger, token));
 
 			if (this._progressService && trigger.type === 'manual') {
-				this._progressService.showWhile(TPromise.wrap(actions), 250);
+				this._progressService.showWhile(actions, 250);
 			}
 
 			this._signalChange({
@@ -133,16 +156,16 @@ export class CodeActionOracle {
 
 export interface CodeActionsComputeEvent {
 	trigger: CodeActionTrigger;
-	rangeOrSelection: Range | Selection;
-	position: Position;
-	actions: CancelablePromise<CodeAction[]>;
+	rangeOrSelection: Range | Selection | undefined;
+	position: Position | undefined;
+	actions: CancelablePromise<CodeAction[]> | undefined;
 }
 
 export class CodeActionModel {
 
 	private _editor: ICodeEditor;
 	private _markerService: IMarkerService;
-	private _codeActionOracle: CodeActionOracle;
+	private _codeActionOracle?: CodeActionOracle;
 	private _onDidChangeFixes = new Emitter<CodeActionsComputeEvent>();
 	private _disposables: IDisposable[] = [];
 	private readonly _supportedCodeActions: IContextKey<string>;
@@ -177,12 +200,13 @@ export class CodeActionModel {
 			this._onDidChangeFixes.fire(undefined);
 		}
 
-		if (this._editor.getModel()
-			&& CodeActionProviderRegistry.has(this._editor.getModel())
+		const model = this._editor.getModel();
+		if (model
+			&& CodeActionProviderRegistry.has(model)
 			&& !this._editor.getConfiguration().readOnly) {
 
 			const supportedActions: string[] = [];
-			for (const provider of CodeActionProviderRegistry.all(this._editor.getModel())) {
+			for (const provider of CodeActionProviderRegistry.all(model)) {
 				if (Array.isArray(provider.providedCodeActionKinds)) {
 					supportedActions.push(...provider.providedCodeActionKinds);
 				}
@@ -201,6 +225,6 @@ export class CodeActionModel {
 		if (this._codeActionOracle) {
 			return this._codeActionOracle.trigger(trigger);
 		}
-		return TPromise.as(undefined);
+		return Promise.resolve(undefined);
 	}
 }