add internal interfaces and actions for go to declaration, #62483

src/vs/editor/browser/widget/codeEditorWidget.ts

@@ -1639,6 +1639,7 @@ export class EditorModeContext extends Disposable {
 	private _hasCodeActionsProvider: IContextKey<boolean>;
 	private _hasCodeLensProvider: IContextKey<boolean>;
 	private _hasDefinitionProvider: IContextKey<boolean>;
+	private _hasDeclarationProvider: IContextKey<boolean>;
 	private _hasImplementationProvider: IContextKey<boolean>;
 	private _hasTypeDefinitionProvider: IContextKey<boolean>;
 	private _hasHoverProvider: IContextKey<boolean>;
@@ -1663,6 +1664,7 @@ export class EditorModeContext extends Disposable {
 		this._hasCodeActionsProvider = EditorContextKeys.hasCodeActionsProvider.bindTo(contextKeyService);
 		this._hasCodeLensProvider = EditorContextKeys.hasCodeLensProvider.bindTo(contextKeyService);
 		this._hasDefinitionProvider = EditorContextKeys.hasDefinitionProvider.bindTo(contextKeyService);
+		this._hasDeclarationProvider = EditorContextKeys.hasDeclarationProvider.bindTo(contextKeyService);
 		this._hasImplementationProvider = EditorContextKeys.hasImplementationProvider.bindTo(contextKeyService);
 		this._hasTypeDefinitionProvider = EditorContextKeys.hasTypeDefinitionProvider.bindTo(contextKeyService);
 		this._hasHoverProvider = EditorContextKeys.hasHoverProvider.bindTo(contextKeyService);
@@ -1686,6 +1688,7 @@ export class EditorModeContext extends Disposable {
 		this._register(modes.CodeActionProviderRegistry.onDidChange(update));
 		this._register(modes.CodeLensProviderRegistry.onDidChange(update));
 		this._register(modes.DefinitionProviderRegistry.onDidChange(update));
+		this._register(modes.DeclarationProviderRegistry.onDidChange(update));
 		this._register(modes.ImplementationProviderRegistry.onDidChange(update));
 		this._register(modes.TypeDefinitionProviderRegistry.onDidChange(update));
 		this._register(modes.HoverProviderRegistry.onDidChange(update));
@@ -1710,6 +1713,7 @@ export class EditorModeContext extends Disposable {
 		this._hasCodeActionsProvider.reset();
 		this._hasCodeLensProvider.reset();
 		this._hasDefinitionProvider.reset();
+		this._hasDeclarationProvider.reset();
 		this._hasImplementationProvider.reset();
 		this._hasTypeDefinitionProvider.reset();
 		this._hasHoverProvider.reset();
@@ -1734,6 +1738,7 @@ export class EditorModeContext extends Disposable {
 		this._hasCodeActionsProvider.set(modes.CodeActionProviderRegistry.has(model));
 		this._hasCodeLensProvider.set(modes.CodeLensProviderRegistry.has(model));
 		this._hasDefinitionProvider.set(modes.DefinitionProviderRegistry.has(model));
+		this._hasDeclarationProvider.set(modes.DeclarationProviderRegistry.has(model));
 		this._hasImplementationProvider.set(modes.ImplementationProviderRegistry.has(model));
 		this._hasTypeDefinitionProvider.set(modes.TypeDefinitionProviderRegistry.has(model));
 		this._hasHoverProvider.set(modes.HoverProviderRegistry.has(model));

src/vs/editor/common/editorContextKeys.ts

@@ -38,6 +38,7 @@ export namespace EditorContextKeys {
 	export const hasCodeActionsProvider = new RawContextKey<boolean>('editorHasCodeActionsProvider', false);
 	export const hasCodeLensProvider = new RawContextKey<boolean>('editorHasCodeLensProvider', false);
 	export const hasDefinitionProvider = new RawContextKey<boolean>('editorHasDefinitionProvider', false);
+	export const hasDeclarationProvider = new RawContextKey<boolean>('editorHasDeclarationProvider', false);
 	export const hasImplementationProvider = new RawContextKey<boolean>('editorHasImplementationProvider', false);
 	export const hasTypeDefinitionProvider = new RawContextKey<boolean>('editorHasTypeDefinitionProvider', false);
 	export const hasHoverProvider = new RawContextKey<boolean>('editorHasHoverProvider', false);

src/vs/editor/common/modes.ts

@@ -747,6 +747,18 @@ export interface DefinitionProvider {
 	provideDefinition(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>;
 }
 
+/**
+ * The definition provider interface defines the contract between extensions and
+ * the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
+ * and peek definition features.
+ */
+export interface DeclarationProvider {
+	/**
+	 * Provide the declaration of the symbol at the given position and document.
+	 */
+	provideDeclaration(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>;
+}
+
 /**
  * The implementation provider interface defines the contract between extensions and
  * the go to implementation feature.
@@ -1275,6 +1287,11 @@ export const DocumentHighlightProviderRegistry = new LanguageFeatureRegistry<Doc
  */
 export const DefinitionProviderRegistry = new LanguageFeatureRegistry<DefinitionProvider>();
 
+/**
+ * @internal
+ */
+export const DeclarationProviderRegistry = new LanguageFeatureRegistry<DeclarationProvider>();
+
 /**
  * @internal
  */

src/vs/editor/contrib/goToDefinition/goToDefinition.ts

@@ -9,7 +9,7 @@ import { onUnexpectedExternalError } from 'vs/base/common/errors';
 import { registerDefaultLanguageCommand } from 'vs/editor/browser/editorExtensions';
 import { Position } from 'vs/editor/common/core/position';
 import { ITextModel } from 'vs/editor/common/model';
-import { DefinitionLink, DefinitionProviderRegistry, ImplementationProviderRegistry, TypeDefinitionProviderRegistry } from 'vs/editor/common/modes';
+import { DefinitionLink, DefinitionProviderRegistry, ImplementationProviderRegistry, TypeDefinitionProviderRegistry, DeclarationProviderRegistry } from 'vs/editor/common/modes';
 import { LanguageFeatureRegistry } from 'vs/editor/common/modes/languageFeatureRegistry';
 
 
@@ -40,6 +40,12 @@ export function getDefinitionsAtPosition(model: ITextModel, position: Position,
 	});
 }
 
+export function getDeclarationsAtPosition(model: ITextModel, position: Position, token: CancellationToken): Thenable<DefinitionLink[]> {
+	return getDefinitions(model, position, DeclarationProviderRegistry, (provider, model, position) => {
+		return provider.provideDeclaration(model, position, token);
+	});
+}
+
 export function getImplementationsAtPosition(model: ITextModel, position: Position, token: CancellationToken): Thenable<DefinitionLink[]> {
 	return getDefinitions(model, position, ImplementationProviderRegistry, (provider, model, position) => {
 		return provider.provideImplementation(model, position, token);
@@ -53,5 +59,6 @@ export function getTypeDefinitionsAtPosition(model: ITextModel, position: Positi
 }
 
 registerDefaultLanguageCommand('_executeDefinitionProvider', (model, position) => getDefinitionsAtPosition(model, position, CancellationToken.None));
+registerDefaultLanguageCommand('_executeDeclarationProvider', (model, position) => getDeclarationsAtPosition(model, position, CancellationToken.None));
 registerDefaultLanguageCommand('_executeImplementationProvider', (model, position) => getImplementationsAtPosition(model, position, CancellationToken.None));
 registerDefaultLanguageCommand('_executeTypeDefinitionProvider', (model, position) => getTypeDefinitionsAtPosition(model, position, CancellationToken.None));

src/vs/editor/contrib/goToDefinition/goToDefinitionCommands.ts

@@ -249,6 +249,41 @@ export class PeekDefinitionAction extends DefinitionAction {
 	}
 }
 
+export class GoToDeclarationAction extends DefinitionAction {
+
+	public static readonly ID = 'editor.action.goToDeclaration';
+
+	constructor() {
+		super(new DefinitionActionConfig(), {
+			id: GoToDeclarationAction.ID,
+			label: nls.localize('actions.goToDeclaration.label', "Go to Declaration"),
+			alias: 'Go to Declaration',
+			precondition: ContextKeyExpr.and(
+				EditorContextKeys.hasDeclarationProvider,
+				EditorContextKeys.isInEmbeddedEditor.toNegated()),
+			kbOpts: {
+				kbExpr: EditorContextKeys.editorTextFocus,
+				primary: KeyMod.CtrlCmd | KeyCode.F12,
+				weight: KeybindingWeight.EditorContrib
+			},
+			menuOpts: {
+				group: 'navigation',
+				order: 1.3
+			}
+		});
+	}
+
+	protected _getNoResultFoundMessage(info?: IWordAtPosition): string {
+		return info && info.word
+			? nls.localize('decl.noResultWord', "No declaration found for '{0}'", info.word)
+			: nls.localize('decl.generic.noResults', "No declaration found");
+	}
+
+	protected _getMetaTitle(model: ReferencesModel): string {
+		return model.references.length > 1 && nls.localize('decl.meta.title', " – {0} declarations", model.references.length);
+	}
+}
+
 export class ImplementationAction extends DefinitionAction {
 	protected _getDeclarationsAtPosition(model: ITextModel, position: corePosition.Position, token: CancellationToken): Thenable<DefinitionLink[]> {
 		return getImplementationsAtPosition(model, position, token);

src/vs/monaco.d.ts

@@ -5058,6 +5058,18 @@ declare namespace monaco.languages {
 		provideDefinition(model: editor.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>;
 	}
 
+	/**
+	 * The definition provider interface defines the contract between extensions and
+	 * the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
+	 * and peek definition features.
+	 */
+	export interface DeclarationProvider {
+		/**
+		 * Provide the declaration of the symbol at the given position and document.
+		 */
+		provideDeclaration(model: editor.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>;
+	}
+
 	/**
 	 * The implementation provider interface defines the contract between extensions and
 	 * the go to implementation feature.