@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.d.ts

@@ -1,56 +1,58 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
+import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
 import { ISingleEditOperation } from "../../../../common/core/editOperation.js";
 import { Position } from "../../../../common/core/position.js";
 import { Range } from "../../../../common/core/range.js";
 import { SingleTextEdit } from "../../../../common/core/textEdit.js";
-import { LanguageFeatureRegistry } from "../../../../common/languageFeatureRegistry.js";
-import { Command, InlineCompletion, InlineCompletionContext, InlineCompletions, InlineCompletionsProvider } from "../../../../common/languages.js";
+import { InlineCompletionEndOfLifeReason, InlineCompletion, InlineCompletionContext, InlineCompletions, InlineCompletionsProvider, PartialAcceptInfo } from "../../../../common/languages.js";
 import { ILanguageConfigurationService } from "../../../../common/languages/languageConfigurationRegistry.service.js";
 import { ITextModel } from "../../../../common/model.js";
-export declare function provideInlineCompletions(registry: LanguageFeatureRegistry<InlineCompletionsProvider>, positionOrRange: Position | Range, model: ITextModel, context: InlineCompletionContext, baseToken?: CancellationToken, languageConfigurationService?: ILanguageConfigurationService): Promise<InlineCompletionProviderResult>;
+export declare function provideInlineCompletions(providers: InlineCompletionsProvider[], positionOrRange: Position | Range, model: ITextModel, context: InlineCompletionContext, baseToken?: CancellationToken, languageConfigurationService?: ILanguageConfigurationService): Promise<InlineCompletionProviderResult>;
 export declare class InlineCompletionProviderResult implements IDisposable {
-    readonly completions: readonly InlineCompletionItem[];
+    readonly completions: readonly InlineSuggestData[];
     private readonly hashs;
     private readonly providerResults;
-    constructor(completions: readonly InlineCompletionItem[], hashs: Set<string>, providerResults: readonly InlineCompletionList[]);
-    has(item: InlineCompletionItem): boolean;
+    constructor(completions: readonly InlineSuggestData[], hashs: Set<string>, providerResults: readonly InlineSuggestionList[]);
+    has(edit: SingleTextEdit): boolean;
     isEmpty(): boolean;
     dispose(): void;
 }
-export declare class InlineCompletionList {
-    readonly inlineCompletions: InlineCompletions;
-    readonly provider: InlineCompletionsProvider;
-    private refCount;
-    constructor(inlineCompletions: InlineCompletions, provider: InlineCompletionsProvider);
-    addRef(): void;
-    removeRef(): void;
-}
-export declare class InlineCompletionItem {
-    readonly filterText: string;
-    readonly command: Command | undefined;
-    readonly shownCommand: Command | undefined;
-    readonly action: Command | undefined;
+export declare class InlineSuggestData {
     readonly range: Range;
     readonly insertText: string;
     readonly snippetInfo: SnippetInfo | undefined;
-    readonly cursorShowRange: Range | undefined;
+    readonly displayLocation: IDisplayLocation | undefined;
     readonly additionalTextEdits: readonly ISingleEditOperation[];
     readonly sourceInlineCompletion: InlineCompletion;
-    readonly source: InlineCompletionList;
-    readonly id: string;
-    static from(inlineCompletion: InlineCompletion, source: InlineCompletionList, defaultReplaceRange: Range, textModel: ITextModel, languageConfigurationService: ILanguageConfigurationService | undefined): InlineCompletionItem;
-    static ID: number;
-    private _didCallShow;
-    constructor(filterText: string, command: Command | undefined, shownCommand: Command | undefined, action: Command | undefined, range: Range, insertText: string, snippetInfo: SnippetInfo | undefined, cursorShowRange: Range | undefined, additionalTextEdits: readonly ISingleEditOperation[], sourceInlineCompletion: InlineCompletion, source: InlineCompletionList, id?: string);
-    get isInlineEdit(): boolean;
-    get didShow(): boolean;
-    markAsShown(): void;
-    withRangeInsertTextAndFilterText(updatedRange: Range, updatedInsertText: string, updatedFilterText: string): InlineCompletionItem;
-    hash(): string;
-    toSingleTextEdit(): SingleTextEdit;
+    readonly source: InlineSuggestionList;
+    readonly context: InlineCompletionContext;
+    readonly isInlineEdit: boolean;
+    private _didShow;
+    private _didReportEndOfLife;
+    private _lastSetEndOfLifeReason;
+    constructor(range: Range, insertText: string, snippetInfo: SnippetInfo | undefined, displayLocation: IDisplayLocation | undefined, additionalTextEdits: readonly ISingleEditOperation[], sourceInlineCompletion: InlineCompletion, source: InlineSuggestionList, context: InlineCompletionContext, isInlineEdit: boolean);
+    get showInlineEditMenu(): boolean;
+    getSingleTextEdit(): SingleTextEdit;
+    reportInlineEditShown(commandService: ICommandService, updatedInsertText: string): Promise<void>;
+    reportPartialAccept(acceptedCharacters: number, info: PartialAcceptInfo): void;
+    reportEndOfLife(reason?: InlineCompletionEndOfLifeReason): void;
+    setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
 }
 export interface SnippetInfo {
     snippet: string;
     range: Range;
 }
+export interface IDisplayLocation {
+    range: Range;
+    label: string;
+}
+export declare class InlineSuggestionList {
+    readonly inlineSuggestions: InlineCompletions;
+    readonly inlineSuggestionsData: readonly InlineSuggestData[];
+    readonly provider: InlineCompletionsProvider;
+    private refCount;
+    constructor(inlineSuggestions: InlineCompletions, inlineSuggestionsData: readonly InlineSuggestData[], provider: InlineCompletionsProvider);
+    addRef(): void;
+    removeRef(): void;
+}

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.js

@@ -11,19 +11,18 @@ import { OffsetRange } from '../../../../common/core/offsetRange.js';
 import { Position } from '../../../../common/core/position.js';
 import { Range } from '../../../../common/core/range.js';
 import { SingleTextEdit } from '../../../../common/core/textEdit.js';
-import { InlineCompletionTriggerKind } from '../../../../common/languages.js';
+import { InlineCompletionTriggerKind, InlineCompletionEndOfLifeReasonKind } from '../../../../common/languages.js';
 import { fixBracketsInLine } from '../../../../common/model/bracketPairsTextModelPart/fixBrackets.js';
 import { TextModelText } from '../../../../common/model/textModelText.js';
 import { SnippetParser, Text } from '../../../snippet/browser/snippetParser.js';
 import { getReadonlyEmptyArray } from '../utils.js';
 
-async function provideInlineCompletions(registry, positionOrRange, model, context, baseToken = CancellationToken.None, languageConfigurationService) {
+async function provideInlineCompletions(providers, positionOrRange, model, context, baseToken = CancellationToken.None, languageConfigurationService) {
     const requestUuid = generateUuid();
     const tokenSource = ( new CancellationTokenSource(baseToken));
     const token = tokenSource.token;
     const contextWithUuid = { ...context, requestUuid: requestUuid };
     const defaultReplaceRange = positionOrRange instanceof Position ? getDefaultRange(positionOrRange, model) : positionOrRange;
-    const providers = registry.all(model);
     const multiMap = ( new SetMap());
     for (const provider of providers) {
         if (provider.groupId) {
@@ -43,9 +42,7 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
         }
         return result;
     }
-    const states = ( new Map());
-    const seen = ( new Set());
-    function findPreferredProviderCircle(provider, stack) {
+    function findPreferredProviderCircle(provider, stack, seen) {
         stack = [...stack, provider];
         if (( seen.has(provider))) {
             return stack;
@@ -54,7 +51,7 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
         try {
             const preferred = getPreferredProviders(provider);
             for (const p of preferred) {
-                const c = findPreferredProviderCircle(p, stack);
+                const c = findPreferredProviderCircle(p, stack, seen);
                 if (c) {
                     return c;
                 }
@@ -65,12 +62,12 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
         }
         return undefined;
     }
-    function queryProviderOrPreferredProvider(provider) {
+    function queryProviderOrPreferredProvider(provider, states) {
         const state = states.get(provider);
         if (state) {
             return state;
         }
-        const circle = findPreferredProviderCircle(provider, []);
+        const circle = findPreferredProviderCircle(provider, [], ( new Set()));
         if (circle) {
             onUnexpectedExternalError(( new Error(`Inline completions: cyclic yield-to dependency detected.`
                 + ` Path: ${( circle.map(s => s.toString ? ( s.toString()) : ('' + s))).join(' -> ')}`)));
@@ -81,8 +78,8 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
             if (!circle) {
                 const preferred = getPreferredProviders(provider);
                 for (const p of preferred) {
-                    const result = await queryProviderOrPreferredProvider(p);
-                    if (result && result.inlineCompletions.items.length > 0) {
+                    const result = await queryProviderOrPreferredProvider(p, states);
+                    if (result && result.inlineSuggestions.items.length > 0) {
                         return undefined;
                     }
                 }
@@ -108,16 +105,21 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
         if (!result) {
             return undefined;
         }
-        const list = ( new InlineCompletionList(result, provider));
+        const data = [];
+        const list = ( new InlineSuggestionList(result, data, provider));
+        for (const item of result.items) {
+            data.push(createInlineCompletionItem(item, list, defaultReplaceRange, model, languageConfigurationService, contextWithUuid));
+        }
         runWhenCancelled(token, () => list.removeRef());
         return list;
     }
-    const inlineCompletionLists = AsyncIterableObject.fromPromisesResolveOrder(( providers.map(queryProviderOrPreferredProvider)));
+    const states = ( new Map());
+    const inlineCompletionLists = AsyncIterableObject.fromPromisesResolveOrder(( providers.map(p => queryProviderOrPreferredProvider(p, states))));
     if (token.isCancellationRequested) {
         tokenSource.dispose(true);
         return ( new InlineCompletionProviderResult([], ( new Set()), []));
     }
-    const result = await addRefAndCreateResult(contextWithUuid, inlineCompletionLists, defaultReplaceRange, model, languageConfigurationService);
+    const result = await addRefAndCreateResult(contextWithUuid, inlineCompletionLists, model);
     tokenSource.dispose(true);
     return result;
 }
@@ -134,7 +136,7 @@ function runWhenCancelled(token, callback) {
         return { dispose: () => listener.dispose() };
     }
 }
-async function addRefAndCreateResult(context, inlineCompletionLists, defaultReplaceRange, model, languageConfigurationService) {
+async function addRefAndCreateResult(context, inlineCompletionLists, model) {
     const itemsByHash = ( new Map());
     let shouldStop = false;
     const lists = [];
@@ -144,17 +146,16 @@ async function addRefAndCreateResult(context, inlineCompletionLists, defaultRepl
         }
         completions.addRef();
         lists.push(completions);
-        for (const item of completions.inlineCompletions.items) {
+        for (const item of completions.inlineSuggestionsData) {
             if (!context.includeInlineEdits && (item.isInlineEdit || item.showInlineEditMenu)) {
                 continue;
             }
             if (!context.includeInlineCompletions && !(item.isInlineEdit || item.showInlineEditMenu)) {
                 continue;
             }
-            const inlineCompletionItem = InlineCompletionItem.from(item, completions, defaultReplaceRange, model, languageConfigurationService);
-            itemsByHash.set(inlineCompletionItem.hash(), inlineCompletionItem);
+            itemsByHash.set(createHashFromSingleTextEdit(item.getSingleTextEdit()), item);
             if (!(item.isInlineEdit || item.showInlineEditMenu) && context.triggerKind === InlineCompletionTriggerKind.Automatic) {
-                const minifiedEdit = inlineCompletionItem.toSingleTextEdit().removeCommonPrefix(( new TextModelText(model)));
+                const minifiedEdit = item.getSingleTextEdit().removeCommonPrefix(( new TextModelText(model)));
                 if (!minifiedEdit.isEmpty) {
                     shouldStop = true;
                 }
@@ -173,8 +174,8 @@ class InlineCompletionProviderResult {
         this.hashs = hashs;
         this.providerResults = providerResults;
     }
-    has(item) {
-        return ( this.hashs.has(item.hash()));
+    has(edit) {
+        return ( this.hashs.has(createHashFromSingleTextEdit(edit)));
     }
     isEmpty() {
         return this.completions.length === 0
@@ -186,136 +187,144 @@ class InlineCompletionProviderResult {
         }
     }
 }
-class InlineCompletionList {
-    constructor(inlineCompletions, provider) {
-        this.inlineCompletions = inlineCompletions;
-        this.provider = provider;
-        this.refCount = 1;
-    }
-    addRef() {
-        this.refCount++;
-    }
-    removeRef() {
-        this.refCount--;
-        if (this.refCount === 0) {
-            this.provider.freeInlineCompletions(this.inlineCompletions);
-        }
-    }
+function createHashFromSingleTextEdit(edit) {
+    return JSON.stringify([edit.text, ( edit.range.getStartPosition().toString())]);
 }
-class InlineCompletionItem {
-    static from(inlineCompletion, source, defaultReplaceRange, textModel, languageConfigurationService) {
-        let insertText;
-        let snippetInfo;
-        let range = inlineCompletion.range ? Range.lift(inlineCompletion.range) : defaultReplaceRange;
-        if (typeof inlineCompletion.insertText === 'string') {
-            insertText = inlineCompletion.insertText;
-            if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
-                insertText = closeBrackets(insertText, range.getStartPosition(), textModel, languageConfigurationService);
-                const diff = insertText.length - inlineCompletion.insertText.length;
-                if (diff !== 0) {
-                    range = ( new Range(
-                        range.startLineNumber,
-                        range.startColumn,
-                        range.endLineNumber,
-                        range.endColumn + diff
-                    ));
-                }
+function createInlineCompletionItem(inlineCompletion, source, defaultReplaceRange, textModel, languageConfigurationService, context) {
+    let insertText;
+    let snippetInfo;
+    let range = inlineCompletion.range ? Range.lift(inlineCompletion.range) : defaultReplaceRange;
+    if (typeof inlineCompletion.insertText === 'string') {
+        insertText = inlineCompletion.insertText;
+        if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
+            insertText = closeBrackets(insertText, range.getStartPosition(), textModel, languageConfigurationService);
+            const diff = insertText.length - inlineCompletion.insertText.length;
+            if (diff !== 0) {
+                range = ( new Range(
+                    range.startLineNumber,
+                    range.startColumn,
+                    range.endLineNumber,
+                    range.endColumn + diff
+                ));
             }
-            snippetInfo = undefined;
         }
-        else if ('snippet' in inlineCompletion.insertText) {
-            const preBracketCompletionLength = inlineCompletion.insertText.snippet.length;
-            if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
-                inlineCompletion.insertText.snippet = closeBrackets(inlineCompletion.insertText.snippet, range.getStartPosition(), textModel, languageConfigurationService);
-                const diff = inlineCompletion.insertText.snippet.length - preBracketCompletionLength;
-                if (diff !== 0) {
-                    range = ( new Range(
-                        range.startLineNumber,
-                        range.startColumn,
-                        range.endLineNumber,
-                        range.endColumn + diff
-                    ));
-                }
-            }
-            const snippet = ( new SnippetParser()).parse(inlineCompletion.insertText.snippet);
-            if (snippet.children.length === 1 && snippet.children[0] instanceof Text) {
-                insertText = snippet.children[0].value;
-                snippetInfo = undefined;
-            }
-            else {
-                insertText = ( snippet.toString());
-                snippetInfo = {
-                    snippet: inlineCompletion.insertText.snippet,
-                    range: range
-                };
+        snippetInfo = undefined;
+    }
+    else if ('snippet' in inlineCompletion.insertText) {
+        const preBracketCompletionLength = inlineCompletion.insertText.snippet.length;
+        if (languageConfigurationService && inlineCompletion.completeBracketPairs) {
+            inlineCompletion.insertText.snippet = closeBrackets(inlineCompletion.insertText.snippet, range.getStartPosition(), textModel, languageConfigurationService);
+            const diff = inlineCompletion.insertText.snippet.length - preBracketCompletionLength;
+            if (diff !== 0) {
+                range = ( new Range(
+                    range.startLineNumber,
+                    range.startColumn,
+                    range.endLineNumber,
+                    range.endColumn + diff
+                ));
             }
         }
+        const snippet = ( new SnippetParser()).parse(inlineCompletion.insertText.snippet);
+        if (snippet.children.length === 1 && snippet.children[0] instanceof Text) {
+            insertText = snippet.children[0].value;
+            snippetInfo = undefined;
+        }
         else {
-            assertNever();
+            insertText = ( snippet.toString());
+            snippetInfo = {
+                snippet: inlineCompletion.insertText.snippet,
+                range: range
+            };
         }
-        return ( new InlineCompletionItem(
-            insertText,
-            inlineCompletion.command,
-            inlineCompletion.shownCommand,
-            inlineCompletion.action,
-            range,
-            insertText,
-            snippetInfo,
-            Range.lift(inlineCompletion.showRange) ?? undefined,
-            inlineCompletion.additionalTextEdits || getReadonlyEmptyArray(),
-            inlineCompletion,
-            source
-        ));
     }
-    static { this.ID = 1; }
-    constructor(filterText, command,
-    shownCommand, action, range, insertText, snippetInfo, cursorShowRange, additionalTextEdits,
-    sourceInlineCompletion,
-    source, id = `InlineCompletion:${InlineCompletionItem.ID++}`) {
-        this.filterText = filterText;
-        this.command = command;
-        this.shownCommand = shownCommand;
-        this.action = action;
+    else {
+        assertNever();
+    }
+    const displayLocation = inlineCompletion.displayLocation ? {
+        range: Range.lift(inlineCompletion.displayLocation.range),
+        label: inlineCompletion.displayLocation.label
+    } : undefined;
+    return ( new InlineSuggestData(
+        range,
+        insertText,
+        snippetInfo,
+        displayLocation,
+        inlineCompletion.additionalTextEdits || getReadonlyEmptyArray(),
+        inlineCompletion,
+        source,
+        context,
+        inlineCompletion.isInlineEdit ?? false
+    ));
+}
+class InlineSuggestData {
+    constructor(range, insertText, snippetInfo, displayLocation, additionalTextEdits, sourceInlineCompletion, source, context, isInlineEdit) {
         this.range = range;
         this.insertText = insertText;
         this.snippetInfo = snippetInfo;
-        this.cursorShowRange = cursorShowRange;
+        this.displayLocation = displayLocation;
         this.additionalTextEdits = additionalTextEdits;
         this.sourceInlineCompletion = sourceInlineCompletion;
         this.source = source;
-        this.id = id;
-        this._didCallShow = false;
+        this.context = context;
+        this.isInlineEdit = isInlineEdit;
+        this._didShow = false;
+        this._didReportEndOfLife = false;
+        this._lastSetEndOfLifeReason = undefined;
     }
-    get isInlineEdit() {
-        return this.sourceInlineCompletion.isInlineEdit;
+    get showInlineEditMenu() { return this.sourceInlineCompletion.showInlineEditMenu ?? false; }
+    getSingleTextEdit() {
+        return ( new SingleTextEdit(this.range, this.insertText));
     }
-    get didShow() {
-        return this._didCallShow;
+    async reportInlineEditShown(commandService, updatedInsertText) {
+        if (this._didShow) {
+            return;
+        }
+        this._didShow = true;
+        this.source.provider.handleItemDidShow?.(this.source.inlineSuggestions, this.sourceInlineCompletion, updatedInsertText);
+        if (this.sourceInlineCompletion.shownCommand) {
+            await commandService.executeCommand(this.sourceInlineCompletion.shownCommand.id, ...(this.sourceInlineCompletion.shownCommand.arguments || []));
+        }
     }
-    markAsShown() {
-        this._didCallShow = true;
+    reportPartialAccept(acceptedCharacters, info) {
+        this.source.provider.handlePartialAccept?.(this.source.inlineSuggestions, this.sourceInlineCompletion, acceptedCharacters, info);
     }
-    withRangeInsertTextAndFilterText(updatedRange, updatedInsertText, updatedFilterText) {
-        return ( new InlineCompletionItem(
-            updatedFilterText,
-            this.command,
-            this.shownCommand,
-            this.action,
-            updatedRange,
-            updatedInsertText,
-            this.snippetInfo,
-            this.cursorShowRange,
-            this.additionalTextEdits,
-            this.sourceInlineCompletion,
-            this.source,
-            this.id
-        ));
+    reportEndOfLife(reason) {
+        if (this._didReportEndOfLife) {
+            return;
+        }
+        this._didReportEndOfLife = true;
+        if (!reason) {
+            reason = this._lastSetEndOfLifeReason ?? { kind: InlineCompletionEndOfLifeReasonKind.Ignored, userTypingDisagreed: false, supersededBy: undefined };
+        }
+        if (reason.kind === InlineCompletionEndOfLifeReasonKind.Rejected && this.source.provider.handleRejection) {
+            this.source.provider.handleRejection(this.source.inlineSuggestions, this.sourceInlineCompletion);
+        }
+        if (this.source.provider.handleEndOfLifetime) {
+            this.source.provider.handleEndOfLifetime(this.source.inlineSuggestions, this.sourceInlineCompletion, reason);
+        }
     }
-    hash() {
-        return JSON.stringify({ insertText: this.insertText, range: ( this.range.toString()) });
+    setEndOfLifeReason(reason) {
+        this._lastSetEndOfLifeReason = reason;
     }
-    toSingleTextEdit() {
-        return ( new SingleTextEdit(this.range, this.insertText));
+}
+class InlineSuggestionList {
+    constructor(inlineSuggestions, inlineSuggestionsData, provider) {
+        this.inlineSuggestions = inlineSuggestions;
+        this.inlineSuggestionsData = inlineSuggestionsData;
+        this.provider = provider;
+        this.refCount = 1;
+    }
+    addRef() {
+        this.refCount++;
+    }
+    removeRef() {
+        this.refCount--;
+        if (this.refCount === 0) {
+            for (const item of this.inlineSuggestionsData) {
+                item.reportEndOfLife();
+            }
+            this.provider.freeInlineCompletions(this.inlineSuggestions);
+        }
     }
 }
 function getDefaultRange(position, model) {
@@ -337,4 +346,4 @@ function closeBrackets(text, position, model, languageConfigurationService) {
     return fixedText;
 }
 
-export { InlineCompletionItem, InlineCompletionList, InlineCompletionProviderResult, provideInlineCompletions };
+export { InlineCompletionProviderResult, InlineSuggestData, InlineSuggestionList, provideInlineCompletions };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/suggestWidgetAdapter.d.ts

@@ -35,7 +35,7 @@ export declare class SuggestItemInfo {
     private constructor();
     equals(other: SuggestItemInfo): boolean;
     toSelectedSuggestionInfo(): SelectedSuggestionInfo;
-    toSingleTextEdit(): SingleTextEdit;
+    getSingleTextEdit(): SingleTextEdit;
 }
 export declare class ObservableSuggestWidgetAdapter extends Disposable {
     private readonly _editorObs;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/suggestWidgetAdapter.js

@@ -59,7 +59,7 @@ class SuggestWidgetAdaptor extends Disposable {
                     const candidates = ( suggestItems
                         .map((suggestItem, index) => {
                         const suggestItemInfo = SuggestItemInfo.fromSuggestion(suggestController, textModel, position, suggestItem, this.isShiftKeyPressed);
-                        const suggestItemTextEdit = singleTextRemoveCommonPrefix(suggestItemInfo.toSingleTextEdit(), textModel);
+                        const suggestItemTextEdit = singleTextRemoveCommonPrefix(suggestItemInfo.getSingleTextEdit(), textModel);
                         const valid = singleTextEditAugments(itemToPreselect, suggestItemTextEdit);
                         return { index, valid, prefixLength: suggestItemTextEdit.text.length, suggestItem };
                     }))
@@ -167,7 +167,7 @@ class SuggestItemInfo {
     toSelectedSuggestionInfo() {
         return ( new SelectedSuggestionInfo(this.range, this.insertText, this.completionItemKind, this.isSnippetText));
     }
-    toSingleTextEdit() {
+    getSingleTextEdit() {
         return ( new SingleTextEdit(this.range, this.insertText));
     }
 }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/structuredLogger.d.ts

@@ -10,6 +10,31 @@ export interface IRecordableEditorLogEntry extends IRecordableLogEntry {
     modelUri: string;
     modelVersion: number;
 }
+export type EditorLogEntryData = IDocumentEventDataSetChangeReason | IDocumentEventFetchStart;
+export type LogEntryData = IEventFetchEnd;
+export interface IDocumentEventDataSetChangeReason {
+    sourceId: "TextModel.setChangeReason";
+    source: "inlineSuggestion.accept" | "snippet" | string;
+    detailedSource?: string;
+}
+interface IDocumentEventFetchStart {
+    sourceId: "InlineCompletions.fetch";
+    kind: "start";
+    requestId: number;
+}
+export interface IEventFetchEnd {
+    sourceId: "InlineCompletions.fetch";
+    kind: "end";
+    requestId: number;
+    error: string | undefined;
+    result: IFetchResult[];
+}
+interface IFetchResult {
+    range: string;
+    text: string;
+    isInlineEdit: boolean;
+    source: string;
+}
 export declare function formatRecordableLogEntry<T extends IRecordableLogEntry>(entry: T): string;
 export declare class StructuredLogger<T extends IRecordableLogEntry> extends Disposable {
     private readonly _contextKey;
@@ -21,3 +46,4 @@ export declare class StructuredLogger<T extends IRecordableLogEntry> extends Dis
     constructor(_contextKey: string, _contextKeyService: IContextKeyService, _commandService: ICommandService);
     log(data: T): boolean;
 }
+export {};

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/utils.d.ts

@@ -1,3 +1,4 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { DisposableStore, IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable, IReader } from "../../../../base/common/observable.js";
 import { ContextKeyValue, RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
@@ -6,13 +7,6 @@ import { Position } from "../../../common/core/position.js";
 import { Range } from "../../../common/core/range.js";
 import { SingleTextEdit } from "../../../common/core/textEdit.js";
 export declare function getReadonlyEmptyArray<T>(): readonly T[];
-export declare class ColumnRange {
-    readonly startColumn: number;
-    readonly endColumnExclusive: number;
-    constructor(startColumn: number, endColumnExclusive: number);
-    toRange(lineNumber: number): Range;
-    equals(other: ColumnRange): boolean;
-}
 export declare function addPositions(pos1: Position, pos2: Position): Position;
 export declare function subtractPositions(pos1: Position, pos2: Position): Position;
 export declare function substringPos(text: string, pos: Position): string;
@@ -25,3 +19,4 @@ export declare class ObservableContextKeyService {
     bind<T extends ContextKeyValue>(key: RawContextKey<T>, obs: IObservable<T>): IDisposable;
     bind<T extends ContextKeyValue>(key: RawContextKey<T>, fn: (reader: IReader) => T): IDisposable;
 }
+export declare function wait(ms: number, cancellationToken?: CancellationToken): Promise<void>;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/utils.js

@@ -1,6 +1,5 @@
 
 import { Permutation, compareBy } from '../../../../base/common/arrays.js';
-import { BugIndicatingError } from '../../../../base/common/errors.js';
 import '../../../../base/common/observableInternal/index.js';
 import { bindContextKey } from '../../../../platform/observable/common/platformObservableUtils.js';
 import { Position } from '../../../common/core/position.js';
@@ -14,24 +13,6 @@ const array = [];
 function getReadonlyEmptyArray() {
     return array;
 }
-class ColumnRange {
-    constructor(startColumn, endColumnExclusive) {
-        this.startColumn = startColumn;
-        this.endColumnExclusive = endColumnExclusive;
-        if (startColumn > endColumnExclusive) {
-            throw ( new BugIndicatingError(
-                `startColumn ${startColumn} cannot be after endColumnExclusive ${endColumnExclusive}`
-            ));
-        }
-    }
-    toRange(lineNumber) {
-        return ( new Range(lineNumber, this.startColumn, lineNumber, this.endColumnExclusive));
-    }
-    equals(other) {
-        return this.startColumn === other.startColumn
-            && this.endColumnExclusive === other.endColumnExclusive;
-    }
-}
 function addPositions(pos1, pos2) {
     return ( new Position(
         pos1.lineNumber + pos2.lineNumber - 1,
@@ -87,5 +68,25 @@ class ObservableContextKeyService {
         return bindContextKey(key, this._contextKeyService, obs instanceof Function ? obs : reader => obs.read(reader));
     }
 }
+function wait(ms, cancellationToken) {
+    return ( new Promise(resolve => {
+        let d = undefined;
+        const handle = setTimeout(() => {
+            if (d) {
+                d.dispose();
+            }
+            resolve();
+        }, ms);
+        if (cancellationToken) {
+            d = cancellationToken.onCancellationRequested(() => {
+                clearTimeout(handle);
+                if (d) {
+                    d.dispose();
+                }
+                resolve();
+            });
+        }
+    }));
+}
 
-export { ColumnRange, ObservableContextKeyService, addPositions, convertItemsToStableObservables, getEndPositionsAfterApplying, getModifiedRangesAfterApplying, getReadonlyEmptyArray, substringPos, subtractPositions };
+export { ObservableContextKeyService, addPositions, convertItemsToStableObservables, getEndPositionsAfterApplying, getModifiedRangesAfterApplying, getReadonlyEmptyArray, substringPos, subtractPositions, wait };