Allowing to add more information to the hover

src/vs/editor/common/languages.ts

@@ -167,6 +167,23 @@ export interface Hover {
 	 * current position itself.
 	 */
 	range?: IRange;
+
+	/**
+	 * Meta-data concerning whether this hover can be extended/contracted or not
+	 */
+	extensionMetadata?: HoverExtensionMetadata;
+}
+
+export interface HoverExtensionMetadata {
+	/**
+	 * Can extend the hover
+	 */
+	canExtend?: boolean;
+
+	/**
+	 * Can contract the hover
+	 */
+	canContract?: boolean;
 }
 
 /**
@@ -175,11 +192,23 @@ export interface Hover {
  */
 export interface HoverProvider {
 	/**
-	 * Provide a hover for the given position and document. Multiple hovers at the same
+	 * Provide a hover for the given position, extension metadata and document. Multiple hovers at the same
 	 * position will be merged by the editor. A hover can have a range which defaults
 	 * to the word range at the position when omitted.
 	 */
-	provideHover(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Hover>;
+	provideHover(model: model.ITextModel, request: Position | HoverExtensionRequest, token: CancellationToken): ProviderResult<Hover>;
+}
+
+export interface HoverExtensionRequest {
+	/**
+	 * The position for which the hover is requested.
+	 */
+	position: Position;
+
+	/**
+	 * Wether the request is for an extension or a contraction of the given hover
+	 */
+	extend: boolean;
 }
 
 /**

src/vs/editor/contrib/colorPicker/browser/colorContributions.ts

@@ -62,7 +62,7 @@ export class ColorContribution extends Disposable implements IEditorContribution
 		}
 		if (!hoverController.isColorPickerVisible) {
 			const range = new Range(target.range.startLineNumber, target.range.startColumn + 1, target.range.endLineNumber, target.range.endColumn + 1);
-			hoverController.showContentHover(range, HoverStartMode.Immediate, HoverStartSource.Mouse, false, true);
+			hoverController.showContentHover(range, HoverStartSource.Mouse, true, { mode: HoverStartMode.Immediate, focus: false });
 		}
 	}
 }

src/vs/editor/contrib/colorPicker/browser/standaloneColorPickerWidget.ts

@@ -220,6 +220,7 @@ export class StandaloneColorPickerWidget extends Disposable implements IContentW
 		const context: IEditorHoverRenderContext = {
 			fragment,
 			statusBar,
+			disposables: undefined,
 			setColorPicker: (widget: ColorPickerWidget) => colorPickerWidget = widget,
 			onContentsChanged: () => { },
 			hide: () => this.hide()

src/vs/editor/contrib/hover/browser/contentHover.ts

@@ -26,16 +26,30 @@ import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/c
 import { ResizableContentWidget } from 'vs/editor/contrib/hover/browser/resizableContentWidget';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
+import { MarkdownHoverParticipant } from 'vs/editor/contrib/hover/browser/markdownHoverParticipant';
+import { InlayHintsHover } from 'vs/editor/contrib/inlayHints/browser/inlayHintsHover';
 
 const $ = dom.$;
 
+export interface IHoverOptions {
+	/**
+	 * Start mode of the hover
+	 */
+	mode: HoverStartMode;
+	/**
+	 * Whether the hover should be focused
+	 */
+	focus: boolean;
+}
+
 export class ContentHoverController extends Disposable {
 
 	private _currentResult: HoverResult | null = null;
 
 	private readonly _computer: ContentHoverComputer;
 	private readonly _widget: ContentHoverWidget;
 	private readonly _participants: IEditorHoverParticipant[];
+	private readonly _markdownHoverParticipant: MarkdownHoverParticipant | undefined;
 	private readonly _hoverOperation: HoverOperation<IHoverPart>;
 
 	constructor(
@@ -50,7 +64,11 @@ export class ContentHoverController extends Disposable {
 		// Instantiate participants and sort them by `hoverOrdinal` which is relevant for rendering order.
 		this._participants = [];
 		for (const participant of HoverParticipantRegistry.getAll()) {
-			this._participants.push(this._instantiationService.createInstance(participant, this._editor));
+			const participantInstance = this._instantiationService.createInstance(participant, this._editor);
+			if (participantInstance instanceof MarkdownHoverParticipant && !(participantInstance instanceof InlayHintsHover)) {
+				this._markdownHoverParticipant = participantInstance;
+			}
+			this._participants.push(participantInstance);
 		}
 		this._participants.sort((p1, p2) => p1.hoverOrdinal - p2.hoverOrdinal);
 
@@ -82,16 +100,15 @@ export class ContentHoverController extends Disposable {
 	 */
 	private _startShowingOrUpdateHover(
 		anchor: HoverAnchor | null,
-		mode: HoverStartMode,
 		source: HoverStartSource,
-		focus: boolean,
-		mouseEvent: IEditorMouseEvent | null
+		mouseEvent: IEditorMouseEvent | null,
+		opts: IHoverOptions
 	): boolean {
 
 		if (!this._widget.position || !this._currentResult) {
 			// The hover is not visible
 			if (anchor) {
-				this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+				this._startHoverOperationIfNecessary(anchor, source, false, opts);
 				return true;
 			}
 			return false;
@@ -109,7 +126,7 @@ export class ContentHoverController extends Disposable {
 			// The mouse is getting closer to the hover, so we will keep the hover untouched
 			// But we will kick off a hover update at the new anchor, insisting on keeping the hover visible.
 			if (anchor) {
-				this._startHoverOperationIfNecessary(anchor, mode, source, focus, true);
+				this._startHoverOperationIfNecessary(anchor, source, true, opts);
 			}
 			return true;
 		}
@@ -127,29 +144,29 @@ export class ContentHoverController extends Disposable {
 		if (!anchor.canAdoptVisibleHover(this._currentResult.anchor, this._widget.position)) {
 			// The new anchor is not compatible with the previous anchor
 			this._setCurrentResult(null);
-			this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+			this._startHoverOperationIfNecessary(anchor, source, false, opts);
 			return true;
 		}
 
 		// We aren't getting any closer to the hover, so we will filter existing results
 		// and keep those which also apply to the new anchor.
 		this._setCurrentResult(this._currentResult.filter(anchor));
-		this._startHoverOperationIfNecessary(anchor, mode, source, focus, false);
+		this._startHoverOperationIfNecessary(anchor, source, false, opts);
 		return true;
 	}
 
-	private _startHoverOperationIfNecessary(anchor: HoverAnchor, mode: HoverStartMode, source: HoverStartSource, focus: boolean, insistOnKeepingHoverVisible: boolean): void {
+	private _startHoverOperationIfNecessary(anchor: HoverAnchor, source: HoverStartSource, insistOnKeepingHoverVisible: boolean, opts: IHoverOptions): void {
 
 		if (this._computer.anchor && this._computer.anchor.equals(anchor)) {
 			// We have to start a hover operation at the exact same anchor as before, so no work is needed
 			return;
 		}
 		this._hoverOperation.cancel();
 		this._computer.anchor = anchor;
-		this._computer.shouldFocus = focus;
+		this._computer.shouldFocus = opts.focus;
 		this._computer.source = source;
 		this._computer.insistOnKeepingHoverVisible = insistOnKeepingHoverVisible;
-		this._hoverOperation.start(mode);
+		this._hoverOperation.start(opts.mode);
 	}
 
 	private _setCurrentResult(hoverResult: HoverResult | null): void {
@@ -212,6 +229,7 @@ export class ContentHoverController extends Disposable {
 		const context: IEditorHoverRenderContext = {
 			fragment,
 			statusBar,
+			disposables,
 			setColorPicker: (widget) => colorPicker = widget,
 			onContentsChanged: () => this._widget.onContentsChanged(),
 			setMinimumDimensions: (dimensions: dom.Dimension) => this._widget.setMinimumDimensions(dimensions),
@@ -341,16 +359,21 @@ export class ContentHoverController extends Disposable {
 			}
 		}
 
+		const options = { mode: HoverStartMode.Delayed, focus: false };
 		if (anchorCandidates.length === 0) {
-			return this._startShowingOrUpdateHover(null, HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
+			return this._startShowingOrUpdateHover(null, HoverStartSource.Mouse, mouseEvent, options);
 		}
 
 		anchorCandidates.sort((a, b) => b.priority - a.priority);
-		return this._startShowingOrUpdateHover(anchorCandidates[0], HoverStartMode.Delayed, HoverStartSource.Mouse, false, mouseEvent);
+		return this._startShowingOrUpdateHover(anchorCandidates[0], HoverStartSource.Mouse, mouseEvent, options);
+	}
+
+	public startShowingAtRange(range: Range, source: HoverStartSource, opts: IHoverOptions): void {
+		this._startShowingOrUpdateHover(new HoverRangeAnchor(0, range, undefined, undefined), source, null, opts);
 	}
 
-	public startShowingAtRange(range: Range, mode: HoverStartMode, source: HoverStartSource, focus: boolean): void {
-		this._startShowingOrUpdateHover(new HoverRangeAnchor(0, range, undefined, undefined), mode, source, focus, null);
+	public async extendOrContractFocusedMessage(extend: boolean): Promise<void> {
+		this._markdownHoverParticipant?.extendOrContractFocusedMessage(extend);
 	}
 
 	public getWidgetContent(): string | undefined {

src/vs/editor/contrib/hover/browser/hover.ts

@@ -15,7 +15,7 @@ import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { ILanguageService } from 'vs/editor/common/languages/language';
 import { GotoDefinitionAtPositionEditorContribution } from 'vs/editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition';
 import { HoverStartMode, HoverStartSource } from 'vs/editor/contrib/hover/browser/hoverOperation';
-import { ContentHoverWidget, ContentHoverController } from 'vs/editor/contrib/hover/browser/contentHover';
+import { ContentHoverWidget, ContentHoverController, IHoverOptions } from 'vs/editor/contrib/hover/browser/contentHover';
 import { MarginHoverWidget } from 'vs/editor/contrib/hover/browser/marginHover';
 import { AccessibilitySupport } from 'vs/platform/accessibility/common/accessibility';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -46,8 +46,9 @@ interface IHoverSettings {
 
 interface IHoverState {
 	mouseDown: boolean;
-	// TODO @aiday-mar maybe not needed, investigate this
+	// TODO@aiday-mar maybe not needed, investigate this
 	contentHoverFocused: boolean;
+	// TODO@aiday-mar do not place this here
 	activatedByDecoratorClick: boolean;
 }
 
@@ -325,7 +326,9 @@ export class HoverController extends Disposable implements IEditorContribution {
 		const mightTriggerFocus = (
 			resolvedKeyboardEvent.kind === ResultKind.MoreChordsNeeded ||
 			(resolvedKeyboardEvent.kind === ResultKind.KbFound
-				&& resolvedKeyboardEvent.commandId === 'editor.action.showHover'
+				&& (resolvedKeyboardEvent.commandId === 'editor.action.showHover'
+					|| resolvedKeyboardEvent.commandId === 'editor.action.showMoreHoverInformation'
+					|| resolvedKeyboardEvent.commandId === 'editor.action.showLessHoverInformation')
 				&& this._contentWidget?.isVisible
 			)
 		);
@@ -384,13 +387,16 @@ export class HoverController extends Disposable implements IEditorContribution {
 
 	public showContentHover(
 		range: Range,
-		mode: HoverStartMode,
 		source: HoverStartSource,
-		focus: boolean,
-		activatedByColorDecoratorClick: boolean = false
+		activatedByColorDecoratorClick: boolean = false,
+		hoverOptions: IHoverOptions
 	): void {
 		this._hoverState.activatedByDecoratorClick = activatedByColorDecoratorClick;
-		this._getOrCreateContentWidget().startShowingAtRange(range, mode, source, focus);
+		this._getOrCreateContentWidget().startShowingAtRange(range, source, hoverOptions);
+	}
+
+	public extendOrContractFocusedMessage(extend: boolean): void {
+		this._getOrCreateContentWidget().extendOrContractFocusedMessage(extend);
 	}
 
 	public focus(): void {
@@ -521,7 +527,7 @@ class ShowOrFocusHoverAction extends EditorAction {
 		const showContentHover = (focus: boolean) => {
 			const position = editor.getPosition();
 			const range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
-			controller.showContentHover(range, HoverStartMode.Immediate, HoverStartSource.Keyboard, focus);
+			controller.showContentHover(range, HoverStartSource.Keyboard, false, { mode: HoverStartMode.Immediate, focus });
 		};
 
 		const accessibilitySupportEnabled = editor.getOption(EditorOption.accessibilitySupport) === AccessibilitySupport.Enabled;
@@ -574,7 +580,7 @@ class ShowDefinitionPreviewHoverAction extends EditorAction {
 
 		const promise = goto.startFindDefinitionFromCursor(position);
 		promise.then(() => {
-			controller.showContentHover(range, HoverStartMode.Immediate, HoverStartSource.Keyboard, true);
+			controller.showContentHover(range, HoverStartSource.Keyboard, false, { mode: HoverStartMode.Immediate, focus: true });
 		});
 	}
 }
@@ -825,6 +831,62 @@ class GoToBottomHoverAction extends EditorAction {
 	}
 }
 
+class ShowMoreHoverInformationAction extends EditorAction {
+
+	constructor() {
+		super({
+			id: 'editor.action.showMoreHoverInformation',
+			label: nls.localize({
+				key: 'showMoreHoverInformation',
+				comment: ['Label for action that will trigger showing more hover information.']
+			}, "Show More Hover Information"),
+			alias: 'Show More Hover Information',
+			precondition: EditorContextKeys.hoverFocused,
+			kbOpts: {
+				kbExpr: EditorContextKeys.hoverFocused,
+				primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyP),
+				weight: KeybindingWeight.EditorContrib
+			}
+		});
+	}
+
+	public run(accessor: ServicesAccessor, editor: ICodeEditor): void {
+		extendOrContractFocusedMessage(editor, true);
+	}
+}
+
+class ShowLessHoverInformationAction extends EditorAction {
+
+	constructor() {
+		super({
+			id: 'editor.action.showLessHoverInformation',
+			label: nls.localize({
+				key: 'showLessHoverInformation',
+				comment: ['Label for action that will trigger showing less hover information.']
+			}, "Show Less Hover Information"),
+			alias: 'Show Less Hover Information',
+			precondition: EditorContextKeys.hoverFocused,
+			kbOpts: {
+				kbExpr: EditorContextKeys.hoverFocused,
+				primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyM),
+				weight: KeybindingWeight.EditorContrib
+			}
+		});
+	}
+
+	public run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void {
+		extendOrContractFocusedMessage(editor, false);
+	}
+}
+
+export function extendOrContractFocusedMessage(editor: ICodeEditor, extend: boolean) {
+	const controller = HoverController.get(editor);
+	if (!controller) {
+		return;
+	}
+	controller.extendOrContractFocusedMessage(extend);
+}
+
 registerEditorContribution(HoverController.ID, HoverController, EditorContributionInstantiation.BeforeFirstInteraction);
 registerEditorAction(ShowOrFocusHoverAction);
 registerEditorAction(ShowDefinitionPreviewHoverAction);
@@ -836,6 +898,8 @@ registerEditorAction(PageUpHoverAction);
 registerEditorAction(PageDownHoverAction);
 registerEditorAction(GoToTopHoverAction);
 registerEditorAction(GoToBottomHoverAction);
+registerEditorAction(ShowMoreHoverInformationAction);
+registerEditorAction(ShowLessHoverInformationAction);
 HoverParticipantRegistry.register(MarkdownHoverParticipant);
 HoverParticipantRegistry.register(MarkerHoverParticipant);
 

src/vs/editor/contrib/hover/browser/hoverTypes.ts

@@ -6,7 +6,7 @@
 import { Dimension } from 'vs/base/browser/dom';
 import { AsyncIterableObject } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { ICodeEditor, IEditorMouseEvent } from 'vs/editor/browser/editorBrowser';
 import { Position } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
@@ -103,6 +103,10 @@ export interface IEditorHoverRenderContext {
 	 * The status bar for actions for this hover.
 	 */
 	readonly statusBar: IEditorHoverStatusBar;
+	/**
+	 * The disposable store for the hover
+	 */
+	readonly disposables: DisposableStore | undefined;
 	/**
 	 * Set if the hover will render a color picker widget.
 	 */