ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-03-21 12:20:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Merge from vscode 81d7885dc2e9dc617e1522697a2966bc4025a45d (#5949)" (#5983)

Browse Source 
This reverts commit d15a3fcc98.
This commit is contained in:
Karl Burtram
2019-06-11 12:35:58 -07:00
committed by GitHub
parent 95a50b7892
commit 5a7562a37b
926 changed files with 11394 additions and 19540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
src/vs/editor/contrib/codeAction/codeActionModel.ts
View File

@@ -4,8 +4,8 @@
*--------------------------------------------------------------------------------------------*/
import { CancelablePromise, createCancelablePromise, TimeoutTimer } from 'vs/base/common/async';
import { Emitter } from 'vs/base/common/event';
import { dispose, Disposable } from 'vs/base/common/lifecycle';
import { Emitter, Event } from 'vs/base/common/event';
import { dispose, IDisposable } from 'vs/base/common/lifecycle';
import { URI } from 'vs/base/common/uri';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { Position } from 'vs/editor/common/core/position';
@@ -14,34 +14,36 @@ import { Selection } from 'vs/editor/common/core/selection';
import { CodeActionProviderRegistry } from 'vs/editor/common/modes';
import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
import { IMarkerService } from 'vs/platform/markers/common/markers';
import { ILocalProgressService } from 'vs/platform/progress/common/progress';
import { IProgressService } from 'vs/platform/progress/common/progress';
import { getCodeActions, CodeActionSet } from './codeAction';
import { CodeActionTrigger } from './codeActionTrigger';
export const SUPPORTED_CODE_ACTIONS = new RawContextKey<string>('supportedCodeAction', '');
export type TriggeredCodeAction = undefined | {
readonly selection: Selection;
readonly trigger: CodeActionTrigger;
readonly position: Position;
};
export class CodeActionOracle {
class CodeActionOracle extends Disposable {
private readonly _autoTriggerTimer = this._register(new TimeoutTimer());
private _disposables: IDisposable[] = [];
private readonly _autoTriggerTimer = new TimeoutTimer();
constructor(
private readonly _editor: ICodeEditor,
private readonly _markerService: IMarkerService,
private readonly _signalChange: (triggered: TriggeredCodeAction) => void,
private readonly _signalChange: (newState: CodeActionsState.State) => void,
private readonly _delay: number = 250,
private readonly _progressService?: IProgressService,
) {
super();
this._register(this._markerService.onMarkerChanged(e => this._onMarkerChanges(e)));
this._register(this._editor.onDidChangeCursorPosition(() => this._onCursorChange()));
this._disposables.push(
this._markerService.onMarkerChanged(e => this._onMarkerChanges(e)),
this._editor.onDidChangeCursorPosition(() => this._onCursorChange()),
);
}
public trigger(trigger: CodeActionTrigger): TriggeredCodeAction {
dispose(): void {
this._disposables = dispose(this._disposables);
this._autoTriggerTimer.cancel();
}
trigger(trigger: CodeActionTrigger) {
const selection = this._getRangeOfSelectionUnlessWhitespaceEnclosed(trigger);
return this._createEventAndSignalChange(trigger, selection);
}
@@ -110,24 +112,35 @@ class CodeActionOracle extends Disposable {
return selection ? selection : undefined;
}
private _createEventAndSignalChange(trigger: CodeActionTrigger, selection: Selection | undefined): TriggeredCodeAction {
const model = this._editor.getModel();
if (!selection || !model) {
private _createEventAndSignalChange(trigger: CodeActionTrigger, selection: Selection | undefined): Promise<CodeActionSet | undefined> {
if (!selection) {
// cancel
this._signalChange(undefined);
return undefined;
this._signalChange(CodeActionsState.Empty);
return Promise.resolve(undefined);
} else {
const model = this._editor.getModel();
if (!model) {
// cancel
this._signalChange(CodeActionsState.Empty);
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(actions, 250);
}
this._signalChange(new CodeActionsState.Triggered(
trigger,
selection,
position,
actions
));
return actions;
}
const markerRange = this._getRangeOfMarker(selection);
const position = markerRange ? markerRange.getStartPosition() : selection.getStartPosition();
const e: TriggeredCodeAction = {
trigger,
selection,
position
};
this._signalChange(e);
return e;
}
}
@@ -154,35 +167,36 @@ export namespace CodeActionsState {
export type State = typeof Empty | Triggered;
}
export class CodeActionModel extends Disposable {
export class CodeActionModel {
private _codeActionOracle?: CodeActionOracle;
private _state: CodeActionsState.State = CodeActionsState.Empty;
private _onDidChangeState = new Emitter<CodeActionsState.State>();
private _disposables: IDisposable[] = [];
private readonly _supportedCodeActions: IContextKey<string>;
private readonly _onDidChangeState = this._register(new Emitter<CodeActionsState.State>());
public readonly onDidChangeState = this._onDidChangeState.event;
constructor(
private readonly _editor: ICodeEditor,
private readonly _markerService: IMarkerService,
contextKeyService: IContextKeyService,
private readonly _progressService?: ILocalProgressService
private readonly _progressService: IProgressService
) {
super();
this._supportedCodeActions = SUPPORTED_CODE_ACTIONS.bindTo(contextKeyService);
this._register(this._editor.onDidChangeModel(() => this._update()));
this._register(this._editor.onDidChangeModelLanguage(() => this._update()));
this._register(CodeActionProviderRegistry.onDidChange(() => this._update()));
this._disposables.push(this._editor.onDidChangeModel(() => this._update()));
this._disposables.push(this._editor.onDidChangeModelLanguage(() => this._update()));
this._disposables.push(CodeActionProviderRegistry.onDidChange(() => this._update()));
this._update();
}
dispose(): void {
super.dispose();
this._disposables = dispose(this._disposables);
dispose(this._codeActionOracle);
this.setState(CodeActionsState.Empty, true);
}
get onDidChangeState(): Event<CodeActionsState.State> {
return this._onDidChangeState.event;
}
private _update(): void {
@@ -191,6 +205,9 @@ export class CodeActionModel extends Disposable {
this._codeActionOracle = undefined;
}
if (this._state.type === CodeActionsState.Type.Triggered) {
this._state.actions.cancel();
}
this.setState(CodeActionsState.Empty);
const model = this._editor.getModel();
@@ -207,46 +224,25 @@ export class CodeActionModel extends Disposable {
this._supportedCodeActions.set(supportedActions.join(' '));
this._codeActionOracle = new CodeActionOracle(this._editor, this._markerService, trigger => {
if (!trigger) {
this.setState(CodeActionsState.Empty);
return;
}
const actions = createCancelablePromise(token => getCodeActions(model, trigger.selection, trigger.trigger, token));
if (this._progressService && trigger.trigger.type === 'manual') {
this._progressService.showWhile(actions, 250);
}
this.setState(new CodeActionsState.Triggered(trigger.trigger, trigger.selection, trigger.position, actions));
}, undefined);
this._codeActionOracle = new CodeActionOracle(this._editor, this._markerService, newState => this.setState(newState), undefined, this._progressService);
this._codeActionOracle.trigger({ type: 'auto' });
} else {
this._supportedCodeActions.reset();
}
}
public trigger(trigger: CodeActionTrigger) {
public trigger(trigger: CodeActionTrigger): Promise<CodeActionSet | undefined> {
if (this._codeActionOracle) {
this._codeActionOracle.trigger(trigger);
return this._codeActionOracle.trigger(trigger);
}
return Promise.resolve(undefined);
}
private setState(newState: CodeActionsState.State, skipNotify?: boolean) {
private setState(newState: CodeActionsState.State) {
if (newState === this._state) {
return;
}
// Cancel old request
if (this._state.type === CodeActionsState.Type.Triggered) {
this._state.actions.cancel();
}
this._state = newState;
if (!skipNotify) {
this._onDidChangeState.fire(newState);
}
this._onDidChangeState.fire(newState);
}
}