add generic go to locations command that allows to implement go-to-something...

add generic go to locations command that allows to implement go-to-something before us API-ifying things, #83752

src/vs/base/common/types.ts

@@ -93,6 +93,13 @@ export function isUndefinedOrNull(obj: any): obj is undefined | null {
 	return isUndefined(obj) || obj === null;
 }
 
+
+export function assertType(condition: any, type?: string): asserts condition {
+	if (!condition) {
+		throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');
+	}
+}
+
 /**
  * Asserts that the argument passed in is neither undefined nor null.
  */

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

@@ -33,6 +33,9 @@ import { ISymbolNavigationService } from 'vs/editor/contrib/gotoSymbol/symbolNav
 import { EditorOption, GoToLocationValues } from 'vs/editor/common/config/editorOptions';
 import { isStandalone } from 'vs/base/browser/browser';
 import { URI } from 'vs/base/common/uri';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ScrollType } from 'vs/editor/common/editorCommon';
+import { assertType } from 'vs/base/common/types';
 
 export interface SymbolNavigationActionConfig {
 	openToSide: boolean;
@@ -100,7 +103,7 @@ abstract class SymbolNavigationAction extends EditorAction {
 		return promise;
 	}
 
-	protected abstract _getLocationModel(model: ITextModel, position: corePosition.Position, token: CancellationToken): Promise<ReferencesModel>;
+	protected abstract _getLocationModel(model: ITextModel, position: corePosition.Position, token: CancellationToken): Promise<ReferencesModel | undefined>;
 
 	protected abstract _getNoResultFoundMessage(info: IWordAtPosition | null): string;
 
@@ -639,59 +642,89 @@ registerEditorAction(class PeekReferencesAction extends ReferencesAction {
 
 //#endregion
 
-//#region --- REFERENCE search special commands
 
-CommandsRegistry.registerCommand({
-	id: 'editor.action.findReferences',
-	handler: (accessor: ServicesAccessor, resource: URI, position: corePosition.IPosition) => {
-		if (!(resource instanceof URI)) {
-			throw new Error('illegal argument, uri');
-		}
-		if (!position) {
-			throw new Error('illegal argument, position');
-		}
+//#region --- GENERIC goto symbols command
 
-		const codeEditorService = accessor.get(ICodeEditorService);
-		return codeEditorService.openCodeEditor({ resource }, codeEditorService.getFocusedCodeEditor()).then(control => {
-			if (!isCodeEditor(control) || !control.hasModel()) {
-				return undefined;
-			}
-
-			const controller = ReferencesController.get(control);
-			if (!controller) {
-				return undefined;
-			}
+class GenericGoToLocationAction extends SymbolNavigationAction {
 
-			const references = createCancelablePromise(token => getReferencesAtPosition(control.getModel(), corePosition.Position.lift(position), token).then(references => new ReferencesModel(references)));
-			const range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
-			return Promise.resolve(controller.toggleWidget(range, references, false));
+	constructor(
+		private readonly _references: Location[]
+	) {
+		super({
+			muteMessage: true,
+			openInPeek: false,
+			openToSide: false
+		}, {
+			id: 'editor.action.goToLocation',
+			label: nls.localize('label.generic', "Go To Any Symbol"),
+			alias: 'Go To Any Symbol',
+			precondition: ContextKeyExpr.and(
+				PeekContext.notInPeekEditor,
+				EditorContextKeys.isInEmbeddedEditor.toNegated()
+			),
 		});
 	}
-});
+
+	protected async _getLocationModel(_model: ITextModel, _position: corePosition.Position, _token: CancellationToken): Promise<ReferencesModel | undefined> {
+		return new ReferencesModel(this._references);
+	}
+
+	protected _getNoResultFoundMessage(info: IWordAtPosition | null): string {
+		return info && nls.localize('generic.noResult', "No results for '{0}'", info.word) || '';
+	}
+
+	protected _getGoToPreference(editor: IActiveCodeEditor): GoToLocationValues {
+		return editor.getOption(EditorOption.gotoLocation).multipleReferences;
+	}
+
+	protected _getMetaTitle() { return ''; }
+	protected _getAlternativeCommand() { return ''; }
+}
 
 CommandsRegistry.registerCommand({
-	id: 'editor.action.showReferences',
+	id: 'editor.action.goToLocations',
 	description: {
-		description: 'Show references at a position in a file',
+		description: 'Go to locations from a position in a file',
 		args: [
-			{ name: 'uri', description: 'The text document in which to show references', constraint: URI },
-			{ name: 'position', description: 'The position at which to show', constraint: corePosition.Position.isIPosition },
+			{ name: 'uri', description: 'The text document in which to start', constraint: URI },
+			{ name: 'position', description: 'The position at which to start', constraint: corePosition.Position.isIPosition },
 			{ name: 'locations', description: 'An array of locations.', constraint: Array },
 		]
 	},
-	handler: (accessor: ServicesAccessor, resource: URI, position: corePosition.IPosition, references: Location[]) => {
-		if (!(resource instanceof URI)) {
-			throw new Error('illegal argument, uri expected');
-		}
+	handler: async (accessor: ServicesAccessor, resource: any, position: any, references: any) => {
+		assertType(URI.isUri(resource));
+		assertType(corePosition.Position.isIPosition(position));
+		assertType(Array.isArray(references));
 
-		if (!references) {
-			throw new Error('missing references');
+		const editorService = accessor.get(ICodeEditorService);
+		const editor = await editorService.openCodeEditor({ resource }, editorService.getFocusedCodeEditor());
+
+		if (isCodeEditor(editor)) {
+			editor.setPosition(position);
+			editor.revealPositionInCenterIfOutsideViewport(position, ScrollType.Smooth);
+
+			return editor.invokeWithinContext(accessor => {
+				const command = new GenericGoToLocationAction(references);
+				accessor.get(IInstantiationService).invokeFunction(command.run.bind(command), editor);
+			});
 		}
+	}
+});
 
-		const codeEditorService = accessor.get(ICodeEditorService);
+//#endregion
 
+
+//#region --- REFERENCE search special commands
+
+CommandsRegistry.registerCommand({
+	id: 'editor.action.findReferences',
+	handler: (accessor: ServicesAccessor, resource: any, position: any) => {
+		assertType(URI.isUri(resource));
+		assertType(corePosition.Position.isIPosition(position));
+
+		const codeEditorService = accessor.get(ICodeEditorService);
 		return codeEditorService.openCodeEditor({ resource }, codeEditorService.getFocusedCodeEditor()).then(control => {
-			if (!isCodeEditor(control)) {
+			if (!isCodeEditor(control) || !control.hasModel()) {
 				return undefined;
 			}
 
@@ -700,13 +733,14 @@ CommandsRegistry.registerCommand({
 				return undefined;
 			}
 
-			return controller.toggleWidget(
-				new Range(position.lineNumber, position.column, position.lineNumber, position.column),
-				createCancelablePromise(_ => Promise.resolve(new ReferencesModel(references))),
-				false
-			);
+			const references = createCancelablePromise(token => getReferencesAtPosition(control.getModel(), corePosition.Position.lift(position), token).then(references => new ReferencesModel(references)));
+			const range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
+			return Promise.resolve(controller.toggleWidget(range, references, false));
 		});
-	},
+	}
 });
 
+// use NEW command
+CommandsRegistry.registerCommandAlias('editor.action.showReferences', 'editor.action.goToLocations');
+
 //#endregion