@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -4,7 +4,7 @@ import { compareUndefinedSmallest, numberComparator } from '../../../../../base/
 import { findLastMax } from '../../../../../base/common/arraysFind.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { equalsIfDefined, itemEquals } from '../../../../../base/common/equals.js';
-import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
 import { observableReducerSettable } from '../../../../../base/common/observableInternal/experimental/reducer.js';
 import { isDefined } from '../../../../../base/common/types.js';
@@ -19,7 +19,7 @@ import { offsetEditFromContentChanges } from '../../../../common/model/textModel
 import { StructuredLogger, formatRecordableLogEntry } from '../structuredLogger.js';
 import { wait } from '../utils.js';
 import { InlineSuggestionItem } from './inlineSuggestionItem.js';
-import { provideInlineCompletions } from './provideInlineCompletions.js';
+import { provideInlineCompletions, runWhenCancelled } from './provideInlineCompletions.js';
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
@@ -29,11 +29,12 @@ var InlineCompletionsSource_1;
 let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
     static { InlineCompletionsSource_1 = this; }
     static { this._requestId = 0; }
-    constructor(_textModel, _versionId, _debounceValue, _languageConfigurationService, _logService, _configurationService, _instantiationService) {
+    constructor(_textModel, _versionId, _debounceValue, _cursorPosition, _languageConfigurationService, _logService, _configurationService, _instantiationService) {
         super();
         this._textModel = _textModel;
         this._versionId = _versionId;
         this._debounceValue = _debounceValue;
+        this._cursorPosition = _cursorPosition;
         this._languageConfigurationService = _languageConfigurationService;
         this._logService = _logService;
         this._configurationService = _configurationService;
@@ -87,8 +88,9 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         }
         this._structuredFetchLogger.log(entry);
     }
-    fetch(providers, position, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion, providerhasChangedCompletion) {
-        const request = ( new UpdateRequest(position, context, this._textModel.getVersionId()));
+    fetch(providers, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion, providerhasChangedCompletion, requestInfo) {
+        const position = this._cursorPosition.get();
+        const request = ( new UpdateRequest(position, context, this._textModel.getVersionId(), ( new Set(providers))));
         const target = context.selectedSuggestionInfo ? this.suggestWidgetInlineCompletions.get() : this.inlineCompletions.get();
         if (!providerhasChangedCompletion && this._updateOperation.value?.request.satisfies(request)) {
             return this._updateOperation.value.promise;
@@ -101,6 +103,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         const source = ( new CancellationTokenSource());
         const promise = (async () => {
             this._loadingCount.set(this._loadingCount.get() + 1, undefined);
+            const store = ( new DisposableStore());
             try {
                 const recommendedDebounceValue = this._debounceValue.get(this._textModel);
                 const debounceValue = findLastMax(( providers.map(p => p.debounceDelayMs)), compareUndefinedSmallest(numberComparator)) ?? recommendedDebounceValue;
@@ -116,57 +119,79 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                     this._log({ sourceId: 'InlineCompletions.fetch', kind: 'start', requestId, modelUri: this._textModel.uri, modelVersion: this._textModel.getVersionId(), context: { triggerKind: context.triggerKind }, time: Date.now() });
                 }
                 const startTime = ( new Date());
-                let providerResult = undefined;
-                let error = undefined;
-                try {
-                    providerResult = await provideInlineCompletions(providers, position, this._textModel, context, source.token, this._languageConfigurationService);
-                }
-                catch (e) {
-                    error = e;
-                    throw e;
-                }
-                finally {
-                    if (this._loggingEnabled.get() || this._structuredFetchLogger.isEnabled.get()) {
-                        if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId) {
-                            error = 'canceled';
+                const providerResult = provideInlineCompletions(providers, this._cursorPosition.get(), this._textModel, context, requestInfo, this._languageConfigurationService);
+                runWhenCancelled(source.token, () => providerResult.cancelAndDispose({ kind: 'tokenCancellation' }));
+                let shouldStopEarly = false;
+                const suggestions = [];
+                for await (const list of providerResult.lists) {
+                    if (!list) {
+                        continue;
+                    }
+                    list.addRef();
+                    store.add(toDisposable(() => list.removeRef(list.inlineSuggestionsData.length === 0 ? { kind: 'empty' } : { kind: 'notTaken' })));
+                    for (const item of list.inlineSuggestionsData) {
+                        if (!context.includeInlineEdits && (item.isInlineEdit || item.showInlineEditMenu)) {
+                            continue;
                         }
-                        const result = providerResult?.completions.map(c => ({
-                            range: ( c.range.toString()),
-                            text: c.insertText,
-                            isInlineEdit: !!c.isInlineEdit,
-                            source: c.source.provider.groupId,
-                        }));
-                        this._log({ sourceId: 'InlineCompletions.fetch', kind: 'end', requestId, durationMs: (Date.now() - startTime.getTime()), error, result, time: Date.now() });
+                        if (!context.includeInlineCompletions && !(item.isInlineEdit || item.showInlineEditMenu)) {
+                            continue;
+                        }
+                        const i = InlineSuggestionItem.create(item, this._textModel);
+                        suggestions.push(i);
+                        if (!i.isInlineEdit && !i.showInlineEditMenu && context.triggerKind === InlineCompletionTriggerKind.Automatic) {
+                            if (i.isVisible(this._textModel, this._cursorPosition.get())) {
+                                shouldStopEarly = true;
+                            }
+                        }
+                    }
+                    if (shouldStopEarly) {
+                        break;
                     }
                 }
-                if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId || userJumpedToActiveCompletion.get() ) {
-                    providerResult.dispose();
+                providerResult.cancelAndDispose({ kind: 'lostRace' });
+                if (this._loggingEnabled.get() || this._structuredFetchLogger.isEnabled.get()) {
+                    const didAllProvidersReturn = providerResult.didAllProvidersReturn;
+                    let error = undefined;
+                    if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId) {
+                        error = 'canceled';
+                    }
+                    const result = ( suggestions.map(c => ({
+                        range: ( c.editRange.toString()),
+                        text: c.insertText,
+                        isInlineEdit: !!c.isInlineEdit,
+                        source: c.source.provider.groupId,
+                    })));
+                    this._log({ sourceId: 'InlineCompletions.fetch', kind: 'end', requestId, durationMs: (Date.now() - startTime.getTime()), error, result, time: Date.now(), didAllProvidersReturn });
+                }
+                if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId
+                    || userJumpedToActiveCompletion.get() ) {
                     return false;
                 }
                 const endTime = ( new Date());
                 this._debounceValue.update(this._textModel, endTime.getTime() - startTime.getTime());
+                const cursorPosition = this._cursorPosition.get();
                 this._updateOperation.clear();
                 transaction(tx => {
                     const v = this._state.get();
                     if (context.selectedSuggestionInfo) {
                         this._state.set({
                             inlineCompletions: InlineCompletionsState.createEmpty(),
-                            suggestWidgetInlineCompletions: v.suggestWidgetInlineCompletions.createStateWithAppliedResults(providerResult, request, this._textModel, activeInlineCompletion),
+                            suggestWidgetInlineCompletions: v.suggestWidgetInlineCompletions.createStateWithAppliedResults(suggestions, request, this._textModel, cursorPosition, activeInlineCompletion),
                         }, tx);
                     }
                     else {
                         this._state.set({
-                            inlineCompletions: v.inlineCompletions.createStateWithAppliedResults(providerResult, request, this._textModel, activeInlineCompletion),
+                            inlineCompletions: v.inlineCompletions.createStateWithAppliedResults(suggestions, request, this._textModel, cursorPosition, activeInlineCompletion),
                             suggestWidgetInlineCompletions: InlineCompletionsState.createEmpty(),
                         }, tx);
                     }
-                    providerResult.dispose();
                     v.inlineCompletions.dispose();
                     v.suggestWidgetInlineCompletions.dispose();
                 });
             }
             finally {
                 this._loadingCount.set(this._loadingCount.get() - 1, undefined);
+                store.dispose();
             }
             return true;
         })();
@@ -214,28 +239,33 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
     }
 };
 InlineCompletionsSource = InlineCompletionsSource_1 = ( __decorate([
-    ( __param(3, ILanguageConfigurationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IInstantiationService))
+    ( __param(4, ILanguageConfigurationService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IInstantiationService))
 ], InlineCompletionsSource));
 class UpdateRequest {
-    constructor(position, context, versionId) {
+    constructor(position, context, versionId, providers) {
         this.position = position;
         this.context = context;
         this.versionId = versionId;
+        this.providers = providers;
     }
     satisfies(other) {
         return this.position.equals(other.position)
             && equalsIfDefined(this.context.selectedSuggestionInfo, other.context.selectedSuggestionInfo, itemEquals())
             && (other.context.triggerKind === InlineCompletionTriggerKind.Automatic
                 || this.context.triggerKind === InlineCompletionTriggerKind.Explicit)
-            && this.versionId === other.versionId;
+            && this.versionId === other.versionId
+            && isSubset(other.providers, this.providers);
     }
     get isExplicitRequest() {
         return this.context.triggerKind === InlineCompletionTriggerKind.Explicit;
     }
 }
+function isSubset(set1, set2) {
+    return [...set1].every(item => ( set2.has(item)));
+}
 class UpdateOperation {
     constructor(request, cancellationTokenSource, promise) {
         this.request = request;
@@ -275,30 +305,51 @@ class InlineCompletionsState extends Disposable {
         const newInlineCompletions = ( this.inlineCompletions.map(i => i.withEdit(edit, textModel))).filter(isDefined);
         return ( new InlineCompletionsState(newInlineCompletions, this.request));
     }
-    createStateWithAppliedResults(update, request, textModel, itemToPreserve) {
-        const items = [];
-        for (const item of update.completions) {
-            const i = InlineSuggestionItem.create(item, textModel);
+    createStateWithAppliedResults(updatedSuggestions, request, textModel, cursorPosition, itemIdToPreserveAtTop) {
+        let itemToPreserve = undefined;
+        if (itemIdToPreserveAtTop) {
+            const itemToPreserveCandidate = this._findById(itemIdToPreserveAtTop);
+            if (itemToPreserveCandidate && itemToPreserveCandidate.canBeReused(textModel, request.position)) {
+                itemToPreserve = itemToPreserveCandidate;
+                const updatedItemToPreserve = updatedSuggestions.find(i => i.hash === itemToPreserveCandidate.hash);
+                if (updatedItemToPreserve) {
+                    updatedSuggestions = moveToFront(updatedItemToPreserve, updatedSuggestions);
+                }
+                else {
+                    updatedSuggestions = [itemToPreserveCandidate, ...updatedSuggestions];
+                }
+            }
+        }
+        const preferInlineCompletions = itemToPreserve
+            ? !itemToPreserve.isInlineEdit
+            : ( updatedSuggestions.some(i => !i.isInlineEdit && i.isVisible(textModel, cursorPosition)));
+        const updatedItems = [];
+        for (const i of updatedSuggestions) {
             const oldItem = this._findByHash(i.hash);
-            if (oldItem) {
-                items.push(i.withIdentity(oldItem.identity));
+            let item;
+            if (oldItem && oldItem !== i) {
+                item = i.withIdentity(oldItem.identity);
                 oldItem.setEndOfLifeReason({ kind: InlineCompletionEndOfLifeReasonKind.Ignored, userTypingDisagreed: false, supersededBy: i.getSourceCompletion() });
             }
             else {
-                items.push(i);
+                item = i;
             }
-        }
-        if (itemToPreserve) {
-            const item = this._findById(itemToPreserve);
-            if (item && !( update.has(item.getSingleTextEdit())) && item.canBeReused(textModel, request.position)) {
-                items.unshift(item);
+            if (preferInlineCompletions !== item.isInlineEdit) {
+                updatedItems.push(item);
             }
         }
-        return ( new InlineCompletionsState(items, request));
+        return ( new InlineCompletionsState(updatedItems, request));
     }
     clone() {
         return ( new InlineCompletionsState(this.inlineCompletions, this.request));
     }
 }
+function moveToFront(item, items) {
+    const index = items.indexOf(item);
+    if (index > -1) {
+        return [item, ...items.slice(0, index), ...items.slice(index + 1)];
+    }
+    return items;
+}
 
 export { InlineCompletionsSource };

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

@@ -1,11 +1,11 @@
 import { TextReplacement } from "../../../../common/core/edits/textEdit.js";
-import { Command } from "../../../../common/languages.js";
+import { InlineCompletionCommand } from "../../../../common/languages.js";
 import { InlineSuggestionItem } from "./inlineSuggestionItem.js";
 export declare class InlineEdit {
     readonly edit: TextReplacement;
-    readonly commands: readonly Command[];
+    readonly commands: readonly InlineCompletionCommand[];
     readonly inlineCompletion: InlineSuggestionItem;
-    constructor(edit: TextReplacement, commands: readonly Command[], inlineCompletion: InlineSuggestionItem);
+    constructor(edit: TextReplacement, commands: readonly InlineCompletionCommand[], inlineCompletion: InlineSuggestionItem);
     get range(): import("../../../../common/core/range.js").Range;
     get text(): string;
     equals(other: InlineEdit): boolean;

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

@@ -9,6 +9,7 @@ import { TextReplacement } from "../../../../common/core/edits/textEdit.js";
 import { InlineCompletion, Command, InlineCompletionWarning, PartialAcceptInfo, InlineCompletionEndOfLifeReason } from "../../../../common/languages.js";
 import { ITextModel } from "../../../../common/model.js";
 import { IDisplayLocation, InlineSuggestData, InlineSuggestionList, SnippetInfo } from "./provideInlineCompletions.js";
+import { InlineCompletionViewData, InlineCompletionViewKind } from "../view/inlineEdits/inlineEditsViewInterface.js";
 export type InlineSuggestionItem = InlineEditItem | InlineCompletionItem;
 export declare namespace InlineSuggestionItem {
     function create(data: InlineSuggestData, textModel: ITextModel): InlineSuggestionItem;
@@ -39,10 +40,11 @@ declare abstract class InlineSuggestionItemBase {
     abstract canBeReused(model: ITextModel, position: Position): boolean;
     addRef(): void;
     removeRef(): void;
-    reportInlineEditShown(commandService: ICommandService): void;
+    reportInlineEditShown(commandService: ICommandService, viewKind: InlineCompletionViewKind, viewData: InlineCompletionViewData): void;
     reportPartialAccept(acceptedCharacters: number, info: PartialAcceptInfo): void;
     reportEndOfLife(reason: InlineCompletionEndOfLifeReason): void;
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
+    reportInlineEditError(reason: string): void;
     getSourceCompletion(): InlineCompletion;
 }
 export declare class InlineSuggestionIdentity {
@@ -77,6 +79,7 @@ export declare class InlineCompletionItem extends InlineSuggestionItemBase {
     canBeReused(model: ITextModel, position: Position): boolean;
     isVisible(model: ITextModel, cursorPosition: Position): boolean;
 }
+export declare function inlineCompletionIsVisible(singleTextEdit: TextReplacement, originalRange: Range | undefined, model: ITextModel, cursorPosition: Position): boolean;
 export declare class InlineEditItem extends InlineSuggestionItemBase {
     private readonly _edit;
     private readonly _textEdit;

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

@@ -63,8 +63,8 @@ class InlineSuggestionItemBase {
         this.identity.removeRef();
         this.source.removeRef();
     }
-    reportInlineEditShown(commandService) {
-        this._data.reportInlineEditShown(commandService, this.insertText);
+    reportInlineEditShown(commandService, viewKind, viewData) {
+        this._data.reportInlineEditShown(commandService, this.insertText, viewKind, viewData);
     }
     reportPartialAccept(acceptedCharacters, info) {
         this._data.reportPartialAccept(acceptedCharacters, info);
@@ -75,6 +75,9 @@ class InlineSuggestionItemBase {
     setEndOfLifeReason(reason) {
         this._data.setEndOfLifeReason(reason);
     }
+    reportInlineEditError(reason) {
+        this._data.reportInlineEditError(reason);
+    }
     getSourceCompletion() {
         return this._sourceInlineCompletion;
     }
@@ -195,35 +198,40 @@ class InlineCompletionItem extends InlineSuggestionItemBase {
         return result;
     }
     isVisible(model, cursorPosition) {
-        const minimizedReplacement = singleTextRemoveCommonPrefix(this.getSingleTextEdit(), model);
-        if (!this.editRange
-            || !this._originalRange.getStartPosition().equals(this.editRange.getStartPosition())
-            || cursorPosition.lineNumber !== minimizedReplacement.range.startLineNumber
-            || minimizedReplacement.isEmpty
-        ) {
-            return false;
+        const singleTextEdit = this.getSingleTextEdit();
+        return inlineCompletionIsVisible(singleTextEdit, this._originalRange, model, cursorPosition);
+    }
+}
+function inlineCompletionIsVisible(singleTextEdit, originalRange, model, cursorPosition) {
+    const minimizedReplacement = singleTextRemoveCommonPrefix(singleTextEdit, model);
+    const editRange = singleTextEdit.range;
+    if (!editRange
+        || (originalRange && !originalRange.getStartPosition().equals(editRange.getStartPosition()))
+        || cursorPosition.lineNumber !== minimizedReplacement.range.startLineNumber
+        || minimizedReplacement.isEmpty
+    ) {
+        return false;
+    }
+    const originalValue = model.getValueInRange(minimizedReplacement.range, EndOfLinePreference.LF);
+    const filterText = minimizedReplacement.text;
+    const cursorPosIndex = Math.max(0, cursorPosition.column - minimizedReplacement.range.startColumn);
+    let filterTextBefore = filterText.substring(0, cursorPosIndex);
+    let filterTextAfter = filterText.substring(cursorPosIndex);
+    let originalValueBefore = originalValue.substring(0, cursorPosIndex);
+    let originalValueAfter = originalValue.substring(cursorPosIndex);
+    const originalValueIndent = model.getLineIndentColumn(minimizedReplacement.range.startLineNumber);
+    if (minimizedReplacement.range.startColumn <= originalValueIndent) {
+        originalValueBefore = originalValueBefore.trimStart();
+        if (originalValueBefore.length === 0) {
+            originalValueAfter = originalValueAfter.trimStart();
         }
-        const originalValue = model.getValueInRange(minimizedReplacement.range, EndOfLinePreference.LF);
-        const filterText = minimizedReplacement.text;
-        const cursorPosIndex = Math.max(0, cursorPosition.column - minimizedReplacement.range.startColumn);
-        let filterTextBefore = filterText.substring(0, cursorPosIndex);
-        let filterTextAfter = filterText.substring(cursorPosIndex);
-        let originalValueBefore = originalValue.substring(0, cursorPosIndex);
-        let originalValueAfter = originalValue.substring(cursorPosIndex);
-        const originalValueIndent = model.getLineIndentColumn(minimizedReplacement.range.startLineNumber);
-        if (minimizedReplacement.range.startColumn <= originalValueIndent) {
-            originalValueBefore = originalValueBefore.trimStart();
-            if (originalValueBefore.length === 0) {
-                originalValueAfter = originalValueAfter.trimStart();
-            }
-            filterTextBefore = filterTextBefore.trimStart();
-            if (filterTextBefore.length === 0) {
-                filterTextAfter = filterTextAfter.trimStart();
-            }
+        filterTextBefore = filterTextBefore.trimStart();
+        if (filterTextBefore.length === 0) {
+            filterTextAfter = filterTextAfter.trimStart();
         }
-        return filterTextBefore.startsWith(originalValueBefore)
-            && !!matchesSubString(originalValueAfter, filterTextAfter);
     }
+    return filterTextBefore.startsWith(originalValueBefore)
+        && !!matchesSubString(originalValueAfter, filterTextAfter);
 }
 class InlineEditItem extends InlineSuggestionItemBase {
     static create(data, textModel) {
@@ -499,4 +507,4 @@ function reshapeMultiLineInsertion(edit, textModel) {
     return edit;
 }
 
-export { InlineCompletionItem, InlineEditItem, InlineSuggestionIdentity, InlineSuggestionItem };
+export { InlineCompletionItem, InlineEditItem, InlineSuggestionIdentity, InlineSuggestionItem, inlineCompletionIsVisible };

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

@@ -1,3 +1,4 @@
+import { AsyncIterableObject } from "../../../../../base/common/async.js";
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
 import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
@@ -5,20 +6,30 @@ import { ISingleEditOperation } from "../../../../common/core/editOperation.js";
 import { Position } from "../../../../common/core/position.js";
 import { Range } from "../../../../common/core/range.js";
 import { TextReplacement } from "../../../../common/core/edits/textEdit.js";
-import { InlineCompletionEndOfLifeReason, InlineCompletion, InlineCompletionContext, InlineCompletions, InlineCompletionsProvider, PartialAcceptInfo } from "../../../../common/languages.js";
+import { InlineCompletionEndOfLifeReason, InlineCompletion, InlineCompletionContext, InlineCompletions, InlineCompletionsProvider, PartialAcceptInfo, InlineCompletionsDisposeReason } from "../../../../common/languages.js";
 import { ILanguageConfigurationService } from "../../../../common/languages/languageConfigurationRegistry.service.js";
 import { ITextModel } from "../../../../common/model.js";
+import { InlineCompletionViewData, InlineCompletionViewKind } from "../view/inlineEdits/inlineEditsViewInterface.js";
 export type InlineCompletionContextWithoutUuid = Omit<InlineCompletionContext, "requestUuid">;
-export declare function provideInlineCompletions(providers: InlineCompletionsProvider[], positionOrRange: Position | Range, model: ITextModel, context: InlineCompletionContextWithoutUuid, baseToken?: CancellationToken, languageConfigurationService?: ILanguageConfigurationService): Promise<InlineCompletionProviderResult>;
-export declare class InlineCompletionProviderResult implements IDisposable {
-    readonly completions: readonly InlineSuggestData[];
-    private readonly hashs;
-    private readonly providerResults;
-    constructor(completions: readonly InlineSuggestData[], hashs: Set<string>, providerResults: readonly InlineSuggestionList[]);
-    has(edit: TextReplacement): boolean;
-    isEmpty(): boolean;
-    dispose(): void;
+export declare function provideInlineCompletions(providers: InlineCompletionsProvider[], position: Position, model: ITextModel, context: InlineCompletionContextWithoutUuid, requestInfo: InlineSuggestRequestInfo, languageConfigurationService?: ILanguageConfigurationService): IInlineCompletionProviderResult;
+export declare function runWhenCancelled(token: CancellationToken, callback: () => void): IDisposable;
+export interface IInlineCompletionProviderResult {
+    get didAllProvidersReturn(): boolean;
+    cancelAndDispose(reason: InlineCompletionsDisposeReason): void;
+    lists: AsyncIterableObject<InlineSuggestionList>;
 }
+export type InlineSuggestRequestInfo = {
+    startTime: number;
+    editorType: InlineCompletionEditorType;
+    languageId: string;
+    reason: string;
+};
+export type InlineSuggestViewData = {
+    editorType: InlineCompletionEditorType;
+    renderData?: InlineCompletionViewData;
+    viewKind?: InlineCompletionViewKind;
+    error?: string;
+};
 export declare class InlineSuggestData {
     readonly range: Range;
     readonly insertText: string;
@@ -29,16 +40,27 @@ export declare class InlineSuggestData {
     readonly source: InlineSuggestionList;
     readonly context: InlineCompletionContext;
     readonly isInlineEdit: boolean;
+    private readonly _requestInfo;
     private _didShow;
+    private _timeUntilShown;
+    private _showStartTime;
+    private _shownDuration;
+    private _showUncollapsedStartTime;
+    private _showUncollapsedDuration;
+    private _viewData;
     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);
+    private _partiallyAcceptedCount;
+    constructor(range: Range, insertText: string, snippetInfo: SnippetInfo | undefined, displayLocation: IDisplayLocation | undefined, additionalTextEdits: readonly ISingleEditOperation[], sourceInlineCompletion: InlineCompletion, source: InlineSuggestionList, context: InlineCompletionContext, isInlineEdit: boolean, _requestInfo: InlineSuggestRequestInfo);
     get showInlineEditMenu(): boolean;
     getSingleTextEdit(): TextReplacement;
-    reportInlineEditShown(commandService: ICommandService, updatedInsertText: string): Promise<void>;
+    reportInlineEditShown(commandService: ICommandService, updatedInsertText: string, viewKind: InlineCompletionViewKind, viewData: InlineCompletionViewData): Promise<void>;
     reportPartialAccept(acceptedCharacters: number, info: PartialAcceptInfo): void;
     reportEndOfLife(reason?: InlineCompletionEndOfLifeReason): void;
+    reportInlineEditError(message: string): void;
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
+    private updateShownDuration;
+    private reportInlineEditHidden;
 }
 export interface SnippetInfo {
     snippet: string;
@@ -48,6 +70,10 @@ export interface IDisplayLocation {
     range: Range;
     label: string;
 }
+export declare enum InlineCompletionEditorType {
+    TextEditor = "textEditor",
+    DiffEditor = "diffEditor"
+}
 export declare class InlineSuggestionList {
     readonly inlineSuggestions: InlineCompletions;
     readonly inlineSuggestionsData: readonly InlineSuggestData[];
@@ -55,5 +81,5 @@ export declare class InlineSuggestionList {
     private refCount;
     constructor(inlineSuggestions: InlineCompletions, inlineSuggestionsData: readonly InlineSuggestData[], provider: InlineCompletionsProvider);
     addRef(): void;
-    removeRef(): void;
+    removeRef(reason?: InlineCompletionsDisposeReason): void;
 }