callh - Shift-Enter refocuses onto current item

Author: jrieken

src/vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution.ts

@@ -19,6 +19,9 @@ import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { PeekContext } from 'vs/editor/contrib/referenceSearch/peekViewWidget';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { Range } from 'vs/editor/common/core/range';
+import { IPosition } from 'vs/editor/common/core/position';
 
 const _ctxHasCompletionItemProvider = new RawContextKey<boolean>('editorHasCallHierarchyProvider', false);
 const _ctxCallHierarchyVisible = new RawContextKey<boolean>('callHierarchyVisible', false);
@@ -44,6 +47,7 @@ class CallHierarchyController implements IEditorContribution {
 		private readonly _editor: ICodeEditor,
 		@IContextKeyService private readonly _contextKeyService: IContextKeyService,
 		@IStorageService private readonly _storageService: IStorageService,
+		@ICodeEditorService private readonly _editorService: ICodeEditorService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 	) {
 		this._ctxIsVisible = _ctxCallHierarchyVisible.bindTo(this._contextKeyService);
@@ -60,7 +64,7 @@ class CallHierarchyController implements IEditorContribution {
 		this._dispoables.dispose();
 	}
 
-	async startCallHierarchy(): Promise<void> {
+	async startCallHierarchyFromEditor(): Promise<void> {
 		this._sessionDisposables.clear();
 
 		if (!this._editor.hasModel()) {
@@ -73,42 +77,65 @@ class CallHierarchyController implements IEditorContribution {
 			return;
 		}
 
+		const cts = new CancellationTokenSource();
+		const model = CallHierarchyModel.create(document, position, cts.token);
 		const direction = this._storageService.getNumber(CallHierarchyController._StorageDirection, StorageScope.GLOBAL, <number>CallHierarchyDirection.CallsFrom);
 
-		Event.any<any>(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endCallHierarchy, this, this._sessionDisposables);
-		this._widget = this._instantiationService.createInstance(
-			CallHierarchyTreePeekWidget,
-			this._editor,
-			position,
-			direction
+		this._showCallHierarchyWidget(position, direction, model, cts);
+	}
+
+	async startCallHierarchyFromCallHierarchy(): Promise<void> {
+		if (!this._widget) {
+			return;
+		}
+		const model = this._widget.getModel();
+		const call = this._widget.getFocused();
+		if (!call || !model) {
+			return;
+		}
+		const newEditor = await this._editorService.openCodeEditor({ resource: call.item.uri }, this._editor);
+		if (!newEditor) {
+			return;
+		}
+		const newModel = model.fork(call.item);
+		this._sessionDisposables.clear();
+
+		CallHierarchyController.get(newEditor)._showCallHierarchyWidget(
+			Range.lift(newModel.root.selectionRange).getStartPosition(),
+			this._widget.direction,
+			Promise.resolve(newModel),
+			new CancellationTokenSource()
 		);
+	}
 
+	private _showCallHierarchyWidget(position: IPosition, direction: number, model: Promise<CallHierarchyModel | undefined>, cts: CancellationTokenSource) {
+
+		Event.any<any>(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endCallHierarchy, this, this._sessionDisposables);
+		this._widget = this._instantiationService.createInstance(CallHierarchyTreePeekWidget, this._editor, position, direction);
 		this._widget.showLoading();
 		this._ctxIsVisible.set(true);
-
-		const cts = new CancellationTokenSource();
-
 		this._sessionDisposables.add(this._widget.onDidClose(() => {
 			this.endCallHierarchy();
 			this._storageService.store(CallHierarchyController._StorageDirection, this._widget!.direction, StorageScope.GLOBAL);
 		}));
 		this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
 		this._sessionDisposables.add(this._widget);
 
-		try {
-			const model = await CallHierarchyModel.create(document, position, cts.token);
+		model.then(model => {
 			if (cts.token.isCancellationRequested) {
 				return; // nothing
-			} else if (model) {
+			}
+			if (model) {
 				this._sessionDisposables.add(model);
-				this._widget.showModel(model);
-			} else {
-				this._widget.showMessage(localize('no.item', "No results"));
+				this._widget!.showModel(model);
 			}
-		} catch (e) {
-			this._widget.showMessage(localize('error', "Failed to show call hierarchy"));
+			else {
+				this._widget!.showMessage(localize('no.item', "No results"));
+			}
+		}).catch(e => {
+			this._widget!.showMessage(localize('error', "Failed to show call hierarchy"));
 			console.error(e);
-		}
+		});
 	}
 
 	toggleCallHierarchyDirection(): void {
@@ -151,7 +178,7 @@ registerEditorAction(class extends EditorAction {
 	}
 
 	async run(_accessor: ServicesAccessor, editor: ICodeEditor): Promise<void> {
-		return CallHierarchyController.get(editor).startCallHierarchy();
+		return CallHierarchyController.get(editor).startCallHierarchyFromEditor();
 	}
 });
 
@@ -175,6 +202,26 @@ registerEditorAction(class extends EditorAction {
 	}
 });
 
+registerEditorAction(class extends EditorAction {
+
+	constructor() {
+		super({
+			id: 'editor.refocusCallHierarchy',
+			label: localize('title.refocus', "Refocus Call Hierarchy"),
+			alias: 'Refocus Call Hierarchy',
+			kbOpts: {
+				weight: KeybindingWeight.WorkbenchContrib,
+				primary: KeyMod.Shift + KeyCode.Enter
+			},
+			precondition: _ctxCallHierarchyVisible
+		});
+	}
+
+	async run(_accessor: ServicesAccessor, editor: ICodeEditor): Promise<void> {
+		return CallHierarchyController.get(editor).startCallHierarchyFromCallHierarchy();
+	}
+});
+
 
 registerEditorCommand(new class extends EditorCommand {
 

src/vs/workbench/contrib/callHierarchy/browser/callHierarchy.ts

@@ -12,6 +12,7 @@ import { URI } from 'vs/base/common/uri';
 import { IPosition } from 'vs/editor/common/core/position';
 import { isNonEmptyArray } from 'vs/base/common/arrays';
 import { onUnexpectedExternalError } from 'vs/base/common/errors';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 export const enum CallHierarchyDirection {
 	CallsTo = 1,
@@ -55,6 +56,26 @@ export interface CallHierarchyProvider {
 export const CallHierarchyProviderRegistry = new LanguageFeatureRegistry<CallHierarchyProvider>();
 
 
+class RefCountedDisposabled {
+
+	constructor(
+		private readonly _disposable: IDisposable,
+		private _counter = 1
+	) { }
+
+	acquire() {
+		this._counter++;
+		return this;
+	}
+
+	release() {
+		if (--this._counter === 0) {
+			this._disposable.dispose();
+		}
+		return this;
+	}
+}
+
 export class CallHierarchyModel {
 
 	static async create(model: ITextModel, position: IPosition, token: CancellationToken): Promise<CallHierarchyModel | undefined> {
@@ -66,17 +87,26 @@ export class CallHierarchyModel {
 		if (!session) {
 			return undefined;
 		}
-		return new CallHierarchyModel(provider, session);
+		return new CallHierarchyModel(provider, session.root, new RefCountedDisposabled(session));
 	}
 
 	private constructor(
 		readonly provider: CallHierarchyProvider,
-		readonly session: CallHierarchySession,
-		readonly root = session.root
+		readonly root: CallHierarchyItem,
+		readonly ref: RefCountedDisposabled,
 	) { }
 
 	dispose(): void {
-		this.session.dispose();
+		this.ref.release();
+	}
+
+	fork(item: CallHierarchyItem): CallHierarchyModel {
+		const that = this;
+		return new class extends CallHierarchyModel {
+			constructor() {
+				super(that.provider, item, that.ref.acquire());
+			}
+		};
 	}
 
 	async resolveIncomingCalls(item: CallHierarchyItem, token: CancellationToken): Promise<IncomingCall[]> {

src/vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek.ts

@@ -390,6 +390,14 @@ export class CallHierarchyTreePeekWidget extends PeekViewWidget {
 		}
 	}
 
+	getModel(): CallHierarchyModel | undefined {
+		return this._tree.getInput();
+	}
+
+	getFocused(): callHTree.Call | undefined {
+		return this._tree.getFocus()[0];
+	}
+
 	async toggleDirection(): Promise<void> {
 		const model = this._tree.getInput();
 		if (model) {