Merge branch 'main' into extensionCodeblockLangFix

Author: mjbvz

src/vs/editor/common/config/editorOptions.ts

@@ -4195,7 +4195,7 @@ export interface IInlineSuggestOptions {
 	edits?: {
 		experimental?: {
 			enabled?: boolean;
-			useMixedLinesDiff?: 'never' | 'whenPossible' | 'afterJumpWhenPossible';
+			useMixedLinesDiff?: 'never' | 'whenPossible' | 'forStableInsertions' | 'afterJumpWhenPossible';
 			useInterleavedLinesDiff?: 'never' | 'always' | 'afterJump';
 			onlyShowWhenCloseToCursor?: boolean;
 		};
@@ -4227,7 +4227,7 @@ class InlineEditorSuggest extends BaseEditorOption<EditorOption.inlineSuggest, I
 			edits: {
 				experimental: {
 					enabled: true,
-					useMixedLinesDiff: 'never',
+					useMixedLinesDiff: 'forStableInsertions',
 					useInterleavedLinesDiff: 'never',
 					onlyShowWhenCloseToCursor: true,
 				},
@@ -4277,7 +4277,7 @@ class InlineEditorSuggest extends BaseEditorOption<EditorOption.inlineSuggest, I
 					type: 'string',
 					default: defaults.edits.experimental.useMixedLinesDiff,
 					description: nls.localize('inlineSuggest.edits.experimental.useMixedLinesDiff', "Controls whether to enable experimental edits in inline suggestions."),
-					enum: ['never', 'whenPossible'],
+					enum: ['never', 'whenPossible', 'forStableInsertions', 'afterJumpWhenPossible'],
 				},
 				'editor.inlineSuggest.edits.experimental.useInterleavedLinesDiff': {
 					type: 'string',
@@ -4310,7 +4310,7 @@ class InlineEditorSuggest extends BaseEditorOption<EditorOption.inlineSuggest, I
 			edits: {
 				experimental: {
 					enabled: boolean(input.edits?.experimental?.enabled, this.defaultValue.edits.experimental.enabled),
-					useMixedLinesDiff: stringSet(input.edits?.experimental?.useMixedLinesDiff, this.defaultValue.edits.experimental.useMixedLinesDiff, ['never', 'whenPossible', 'afterJumpWhenPossible']),
+					useMixedLinesDiff: stringSet(input.edits?.experimental?.useMixedLinesDiff, this.defaultValue.edits.experimental.useMixedLinesDiff, ['never', 'whenPossible', 'forStableInsertions', 'afterJumpWhenPossible']),
 					useInterleavedLinesDiff: stringSet(input.edits?.experimental?.useInterleavedLinesDiff, this.defaultValue.edits.experimental.useInterleavedLinesDiff, ['never', 'always', 'afterJump']),
 					onlyShowWhenCloseToCursor: boolean(input.edits?.experimental?.onlyShowWhenCloseToCursor, this.defaultValue.edits.experimental.onlyShowWhenCloseToCursor),
 				},

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

@@ -138,16 +138,15 @@ export class ContentHoverWidget extends ResizableContentWidget {
 
 	private _setHoverWidgetMaxDimensions(width: number | string, height: number | string): void {
 		ContentHoverWidget._applyMaxDimensions(this._hover.contentsDomNode, width, height);
+		ContentHoverWidget._applyMaxDimensions(this._hover.scrollbar.getDomNode(), width, height);
 		ContentHoverWidget._applyMaxDimensions(this._hover.containerDomNode, width, height);
 		this._hover.containerDomNode.style.setProperty('--vscode-hover-maxWidth', typeof width === 'number' ? `${width}px` : width);
 		this._layoutContentWidget();
 	}
 
 	private _setAdjustedHoverWidgetDimensions(size: dom.Dimension): void {
 		this._setHoverWidgetMaxDimensions('none', 'none');
-		const width = size.width;
-		const height = size.height;
-		this._setHoverWidgetDimensions(width, height);
+		this._setHoverWidgetDimensions(size.width, size.height);
 	}
 
 	private _updateResizableNodeMaxDimensions(): void {
@@ -297,14 +296,14 @@ export class ContentHoverWidget extends ResizableContentWidget {
 	private _updateMaxDimensions() {
 		const height = Math.max(this._editor.getLayoutInfo().height / 4, 250, ContentHoverWidget._lastDimensions.height);
 		const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 750, ContentHoverWidget._lastDimensions.width);
+		this._resizableNode.maxSize = new dom.Dimension(width, height);
 		this._setHoverWidgetMaxDimensions(width, height);
 	}
 
 	private _render(renderedHover: RenderedContentHover) {
 		this._setRenderedHover(renderedHover);
 		this._updateFont();
 		this._updateContent(renderedHover.domNode);
-		this._updateMaxDimensions();
 		this.onContentsChanged();
 		// Simply force a synchronous render on the editor
 		// such that the widget does not really render with left = '0px'
@@ -371,6 +370,7 @@ export class ContentHoverWidget extends ResizableContentWidget {
 		const layoutInfo = this._editor.getLayoutInfo();
 		this._resizableNode.layout(layoutInfo.height, layoutInfo.width);
 		this._setHoverWidgetDimensions('auto', 'auto');
+		this._updateMaxDimensions();
 	}
 
 	public setMinimumDimensions(dimensions: dom.Dimension): void {

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

@@ -13,7 +13,14 @@
 	box-sizing: content-box;
 }
 
+.monaco-editor .monaco-resizable-hover > .monaco-hover {
+	border: none;
+	border-radius: none;
+}
+
 .monaco-editor .monaco-hover {
+	border: 1px solid var(--vscode-editorHoverWidget-border);
+	border-radius: 3px;
 	color: var(--vscode-editorHoverWidget-foreground);
 	background-color: var(--vscode-editorHoverWidget-background);
 }
@@ -31,7 +38,7 @@
 }
 
 .monaco-editor .monaco-hover .hover-row .hover-row-contents {
-	min-width:0;
+	min-width: 0;
 	display: flex;
 	flex-direction: column;
 }
@@ -65,5 +72,3 @@
 .monaco-editor .monaco-hover code {
 	background-color: var(--vscode-textCodeBlock-background);
 }
-
-

src/vs/editor/contrib/inlineCompletions/browser/model/inlineCompletionsModel.ts

@@ -47,7 +47,7 @@ export class InlineCompletionsModel extends Disposable {
 
 	// We use a semantic id to keep the same inline completion selected even if the provider reorders the completions.
 	private readonly _selectedInlineCompletionId = observableValue<string | undefined>(this, undefined);
-	private readonly _primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? new Position(1, 1));
+	public readonly primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? new Position(1, 1));
 
 	private _isAcceptingPartially = false;
 	public get isAcceptingPartially() { return this._isAcceptingPartially; }
@@ -194,7 +194,7 @@ export class InlineCompletionsModel extends Disposable {
 			});
 		}
 
-		const cursorPosition = this._primaryPosition.get();
+		const cursorPosition = this.primaryPosition.get();
 		if (changeSummary.dontRefetch) {
 			return Promise.resolve(true);
 		}
@@ -257,7 +257,7 @@ export class InlineCompletionsModel extends Disposable {
 	private readonly _inlineCompletionItems = derivedOpts({ owner: this }, reader => {
 		const c = this._source.inlineCompletions.read(reader);
 		if (!c) { return undefined; }
-		const cursorPosition = this._primaryPosition.read(reader);
+		const cursorPosition = this.primaryPosition.read(reader);
 		let inlineEdit: InlineCompletionWithUpdatedRange | undefined = undefined;
 		const visibleCompletions: InlineCompletionWithUpdatedRange[] = [];
 		for (const completion of c.inlineCompletions) {
@@ -355,10 +355,10 @@ export class InlineCompletionsModel extends Disposable {
 			let edit = item.inlineEdit.toSingleTextEdit(reader);
 			edit = singleTextRemoveCommonPrefix(edit, model);
 
-			const cursorPos = this._primaryPosition.read(reader);
+			const cursorPos = this.primaryPosition.read(reader);
 			const cursorAtInlineEdit = LineRange.fromRangeInclusive(edit.range).addMargin(1, 1).contains(cursorPos.lineNumber);
 
-			const cursorDist = LineRange.fromRange(edit.range).distanceToLine(this._primaryPosition.read(reader).lineNumber);
+			const cursorDist = LineRange.fromRange(edit.range).distanceToLine(this.primaryPosition.read(reader).lineNumber);
 
 			if (this._onlyShowWhenCloseToCursor.read(reader) && cursorDist > 3 && !item.inlineEdit.request.isExplicitRequest && !this._inAcceptFlow.read(reader)) {
 				return undefined;

src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineDiffView.ts

@@ -23,7 +23,7 @@ import { classNames } from './utils.js';
 export interface IOriginalEditorInlineDiffViewState {
 	diff: DetailedLineRangeMapping[];
 	modifiedText: AbstractText;
-	mode: 'mixedLines' | 'interleavedLines' | 'sideBySide';
+	mode: 'mixedLines' | 'ghostText' | 'interleavedLines' | 'sideBySide';
 
 	modifiedCodeEditor: ICodeEditor;
 }
@@ -111,7 +111,7 @@ export class OriginalEditorInlineDiffView extends Disposable {
 		if (!diff) { return undefined; }
 
 		const modified = diff.modifiedText;
-		const showInline = diff.mode === 'mixedLines';
+		const showInline = diff.mode === 'mixedLines' || diff.mode === 'ghostText';
 
 		const showEmptyDecorations = true;
 
@@ -214,7 +214,7 @@ export class OriginalEditorInlineDiffView extends Disposable {
 								description: 'inserted-text',
 								before: {
 									content: insertedText,
-									inlineClassName: 'inlineCompletions-char-insert',
+									inlineClassName: diff.mode === 'ghostText' ? 'ghost-text-decoration' : 'inlineCompletions-char-insert',
 								},
 								zIndex: 2,
 								showIfCollapsed: true,

src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/view.ts

@@ -4,22 +4,23 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable } from '../../../../../../base/common/lifecycle.js';
-import { derived, IObservable } from '../../../../../../base/common/observable.js';
+import { derived, IObservable, IReader } from '../../../../../../base/common/observable.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { ICodeEditor } from '../../../../../browser/editorBrowser.js';
 import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
 import { EditorOption } from '../../../../../common/config/editorOptions.js';
 import { LineRange } from '../../../../../common/core/lineRange.js';
+import { Position } from '../../../../../common/core/position.js';
 import { StringText } from '../../../../../common/core/textEdit.js';
 import { DetailedLineRangeMapping, lineRangeMappingFromRangeMappings, RangeMapping } from '../../../../../common/diff/rangeMapping.js';
 import { TextModel } from '../../../../../common/model/textModel.js';
-import './view.css';
+import { InlineCompletionsModel } from '../../model/inlineCompletionsModel.js';
+import { IInlineEditsIndicatorState, InlineEditsIndicator } from './indicatorView.js';
 import { IOriginalEditorInlineDiffViewState, OriginalEditorInlineDiffView } from './inlineDiffView.js';
+import { InlineEditsSideBySideDiff } from './sideBySideDiff.js';
 import { applyEditToModifiedRangeMappings, createReindentEdit } from './utils.js';
-import { IInlineEditsIndicatorState, InlineEditsIndicator } from './indicatorView.js';
-import { InlineCompletionsModel } from '../../model/inlineCompletionsModel.js';
+import './view.css';
 import { InlineEditWithChanges } from './viewAndDiffProducer.js';
-import { InlineEditsSideBySideDiff } from './sideBySideDiff.js';
 
 export class InlineEditsView extends Disposable {
 	private readonly _editorObs = observableCodeEditor(this._editor);
@@ -37,7 +38,7 @@ export class InlineEditsView extends Disposable {
 	}
 
 	private readonly _uiState = derived<{
-		state: 'collapsed' | 'mixedLines' | 'interleavedLines' | 'sideBySide';
+		state: 'collapsed' | 'mixedLines' | 'ghostText' | 'interleavedLines' | 'sideBySide';
 		diff: DetailedLineRangeMapping[];
 		edit: InlineEditWithChanges;
 		newText: string;
@@ -55,17 +56,7 @@ export class InlineEditsView extends Disposable {
 		let newText = edit.edit.apply(edit.originalText);
 		let diff = lineRangeMappingFromRangeMappings(mappings, edit.originalText, new StringText(newText));
 
-		let state: 'collapsed' | 'mixedLines' | 'interleavedLines' | 'sideBySide';
-		if (edit.isCollapsed) {
-			state = 'collapsed';
-		} else if (diff.every(m => OriginalEditorInlineDiffView.supportsInlineDiffRendering(m)) &&
-			(this._useMixedLinesDiff.read(reader) === 'whenPossible' || (edit.userJumpedToIt && this._useMixedLinesDiff.read(reader) === 'afterJumpWhenPossible'))) {
-			state = 'mixedLines';
-		} else if ((this._useInterleavedLinesDiff.read(reader) === 'always' || (edit.userJumpedToIt && this._useInterleavedLinesDiff.read(reader) === 'afterJump'))) {
-			state = 'interleavedLines';
-		} else {
-			state = 'sideBySide';
-		}
+		const state = this.determinRenderState(edit, reader, diff);
 
 		if (state === 'sideBySide') {
 			const indentationAdjustmentEdit = createReindentEdit(newText, edit.modifiedLineRange);
@@ -140,4 +131,57 @@ export class InlineEditsView extends Disposable {
 		}),
 		this._model,
 	));
+
+	private determinRenderState(edit: InlineEditWithChanges, reader: IReader, diff: DetailedLineRangeMapping[]) {
+		if (edit.isCollapsed) {
+			return 'collapsed';
+		}
+
+		if (
+			(this._useMixedLinesDiff.read(reader) === 'whenPossible' || (edit.userJumpedToIt && this._useMixedLinesDiff.read(reader) === 'afterJumpWhenPossible'))
+			&& diff.every(m => OriginalEditorInlineDiffView.supportsInlineDiffRendering(m))
+		) {
+			return 'mixedLines';
+		}
+
+		if (
+			this._useMixedLinesDiff.read(reader) === 'forStableInsertions'
+			&& isInsertionAfterPosition(diff, edit.cursorPosition)
+		) {
+			return 'ghostText';
+		}
+
+		if (this._useInterleavedLinesDiff.read(reader) === 'always' || (edit.userJumpedToIt && this._useInterleavedLinesDiff.read(reader) === 'afterJump')) {
+			return 'interleavedLines';
+		}
+
+		return 'sideBySide';
+	}
+}
+
+function isInsertionAfterPosition(diff: DetailedLineRangeMapping[], position: Position | null) {
+	if (!position) {
+		return false;
+	}
+	const pos = position;
+
+	return diff.every(m => m.innerChanges!.every(r => isStableWordInsertion(r)));
+
+	function isStableWordInsertion(r: RangeMapping) {
+		if (!r.originalRange.isEmpty()) {
+			return false;
+		}
+		const isInsertionWithinLine = r.modifiedRange.startLineNumber === r.modifiedRange.endLineNumber;
+		if (!isInsertionWithinLine) {
+			return false;
+		}
+		const insertPosition = r.originalRange.getStartPosition();
+		if (pos.isBeforeOrEqual(insertPosition)) {
+			return true;
+		}
+		if (insertPosition.lineNumber < pos.lineNumber) {
+			return true;
+		}
+		return false;
+	}
 }

src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/viewAndDiffProducer.ts

@@ -53,6 +53,8 @@ export class InlineEditsViewAndDiffProducer extends Disposable {
 	});
 
 	private readonly _inlineEditPromise = derived<IObservable<InlineEditWithChanges | undefined> | undefined>(this, (reader) => {
+		const model = this._model.read(reader);
+		if (!model) { return undefined; }
 		const inlineEdit = this._edit.read(reader);
 		if (!inlineEdit) { return undefined; }
 
@@ -86,7 +88,7 @@ export class InlineEditsViewAndDiffProducer extends Disposable {
 			));
 			const diffEdits = new TextEdit(edits);
 
-			return new InlineEditWithChanges(text, diffEdits, inlineEdit.isCollapsed, inlineEdit.renderExplicitly, inlineEdit.commands, inlineEdit.inlineCompletion); //inlineEdit.showInlineIfPossible);
+			return new InlineEditWithChanges(text, diffEdits, inlineEdit.isCollapsed, model.primaryPosition.get(), inlineEdit.renderExplicitly, inlineEdit.commands, inlineEdit.inlineCompletion); //inlineEdit.showInlineIfPossible);
 		});
 	});
 
@@ -116,6 +118,7 @@ export class InlineEditWithChanges {
 		public readonly originalText: AbstractText,
 		public readonly edit: TextEdit,
 		public readonly isCollapsed: boolean,
+		public readonly cursorPosition: Position,
 		public readonly userJumpedToIt: boolean,
 		public readonly commands: readonly Command[],
 		public readonly inlineCompletion: InlineCompletionItem,
@@ -126,6 +129,7 @@ export class InlineEditWithChanges {
 		return this.originalText.getValue() === other.originalText.getValue() &&
 			this.edit.equals(other.edit) &&
 			this.isCollapsed === other.isCollapsed &&
+			this.cursorPosition.equals(other.cursorPosition) &&
 			this.userJumpedToIt === other.userJumpedToIt &&
 			this.commands === other.commands &&
 			this.inlineCompletion === other.inlineCompletion;

src/vs/editor/contrib/stickyScroll/browser/stickyScrollController.ts

@@ -468,7 +468,7 @@ export class StickyScrollController extends Disposable implements IEditorContrib
 			this._readConfiguration();
 		}
 
-		if (event.hasChanged(EditorOption.lineNumbers)) {
+		if (event.hasChanged(EditorOption.lineNumbers) || event.hasChanged(EditorOption.folding) || event.hasChanged(EditorOption.showFoldingControls)) {
 			this._renderStickyScroll(0);
 		}
 	}

src/vs/monaco.d.ts

@@ -4602,7 +4602,7 @@ declare namespace monaco.editor {
 		edits?: {
 			experimental?: {
 				enabled?: boolean;
-				useMixedLinesDiff?: 'never' | 'whenPossible' | 'afterJumpWhenPossible';
+				useMixedLinesDiff?: 'never' | 'whenPossible' | 'forStableInsertions' | 'afterJumpWhenPossible';
 				useInterleavedLinesDiff?: 'never' | 'always' | 'afterJump';
 				onlyShowWhenCloseToCursor?: boolean;
 			};

src/vs/platform/theme/common/iconRegistry.ts

@@ -145,6 +145,19 @@ export interface IIconRegistry {
 	getIconFont(id: string): IconFontDefinition | undefined;
 }
 
+// regexes for validation of font properties
+
+export const fontIdRegex = /^([\w_-]+)$/;
+export const fontStyleRegex = /^(normal|italic|(oblique[ \w\s-]+))$/;
+export const fontWeightRegex = /^(normal|bold|lighter|bolder|(\d{0-1000}))$/;
+export const fontSizeRegex = /^([\w_.%+-]+)$/;
+export const fontFormatRegex = /^woff|woff2|truetype|opentype|embedded-opentype|svg$/;
+export const fontCharacterRegex = /^([^\\]|\\[a-fA-F0-9]+)$/u;
+export const fontColorRegex = /^#[0-9a-fA-F]{0,6}$/;
+
+export const fontCharacterErrorMessage = localize('schema.fontCharacter.formatError', 'The fontCharacter must be a single letter or a backslash followed by unicode code points in hexadecimal.');
+export const fontIdErrorMessage = localize('schema.fontId.formatError', 'The font ID must only contain letters, numbers, underscores and dashes.');
+
 class IconRegistry implements IIconRegistry {
 
 	private readonly _onDidChange = new Emitter<void>();
@@ -156,8 +169,8 @@ class IconRegistry implements IIconRegistry {
 			icons: {
 				type: 'object',
 				properties: {
-					fontId: { type: 'string', description: localize('iconDefinition.fontId', 'The id of the font to use. If not set, the font that is defined first is used.') },
-					fontCharacter: { type: 'string', description: localize('iconDefinition.fontCharacter', 'The font character associated with the icon definition.') }
+					fontId: { type: 'string', description: localize('iconDefinition.fontId', 'The id of the font to use. If not set, the font that is defined first is used.'), pattern: fontIdRegex.source, patternErrorMessage: fontIdErrorMessage },
+					fontCharacter: { type: 'string', description: localize('iconDefinition.fontCharacter', 'The font character associated with the icon definition.'), pattern: fontCharacterRegex.source, patternErrorMessage: fontCharacterErrorMessage }
 				},
 				additionalProperties: false,
 				defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }]
@@ -318,7 +331,6 @@ iconRegistry.onDidChange(() => {
 	}
 });
 
-
 //setTimeout(_ => console.log(iconRegistry.toString()), 5000);
 
 

src/vs/workbench/api/browser/mainThreadDebugService.ts

@@ -397,7 +397,8 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 	}
 
 	public $acceptDAExit(handle: number, code: number, signal: string) {
-		this.getDebugAdapter(handle).fireExit(handle, code, signal);
+		// don't use getDebugAdapter since an error can be expected on a post-close
+		this._debugAdapters.get(handle)?.fireExit(handle, code, signal);
 	}
 
 	private getDebugAdapter(handle: number): ExtensionHostDebugAdapter {