@codingame/monaco-vscode-api 2.2.1 → 3.0.0

package/vscode/src/vs/workbench/api/common/extHostDebugService.js

@@ -17,12 +17,13 @@ import { IExtHostVariableResolverProvider } from './extHostVariableResolverServi
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
 import { IExtHostCommands } from './extHostCommands.js';
+import { DebugTreeItem } from './extHostTypeConverters.js';
 const IExtHostDebugService = ( createDecorator('IExtHostDebugService'));
 let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     get onDidStartDebugSession() { return this._onDidStartDebugSession.event; }
     get onDidTerminateDebugSession() { return this._onDidTerminateDebugSession.event; }
     get onDidChangeActiveDebugSession() { return this._onDidChangeActiveDebugSession.event; }
-    get activeDebugSession() { return this._activeDebugSession; }
+    get activeDebugSession() { return this._activeDebugSession?.api; }
     get onDidReceiveDebugSessionCustomEvent() { return this._onDidReceiveDebugSessionCustomEvent.event; }
     get activeDebugConsole() { return this._activeDebugConsole.value; }
     constructor(extHostRpcService, _workspaceService, _extensionService, _configurationService, _editorTabs, _variableResolver, _commands) {
@@ -33,7 +34,11 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         this._variableResolver = _variableResolver;
         this._commands = _commands;
         this._debugSessions = ( new Map());
+        this._debugVisualizationTreeItemIdsCounter = 0;
         this._debugVisualizationProviders = ( new Map());
+        this._debugVisualizationTrees = ( new Map());
+        this._debugVisualizationTreeItemIds = ( new WeakMap());
+        this._debugVisualizationElements = ( new Map());
         this._visualizers = ( new Map());
         this._visualizerIdCounter = 0;
         this._configProviderHandleCounter = 0;
@@ -60,6 +65,67 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
             this.registerAllDebugTypes(extensionRegistry);
         });
     }
+    async $getVisualizerTreeItem(treeId, element) {
+        const context = this.hydrateVisualizationContext(element);
+        if (!context) {
+            return undefined;
+        }
+        const item = await this._debugVisualizationTrees.get(treeId)?.getTreeItem?.(context);
+        return item ? this.convertVisualizerTreeItem(treeId, item) : undefined;
+    }
+    registerDebugVisualizationTree(manifest, id, provider) {
+        const extensionId = ExtensionIdentifier.toKey(manifest.identifier);
+        const key = this.extensionVisKey(extensionId, id);
+        if (( this._debugVisualizationProviders.has(key))) {
+            throw new Error(`A debug visualization provider with id '${id}' is already registered`);
+        }
+        this._debugVisualizationTrees.set(key, provider);
+        this._debugServiceProxy.$registerDebugVisualizerTree(key, !!provider.editItem);
+        return toDisposable(() => {
+            this._debugServiceProxy.$unregisterDebugVisualizerTree(key);
+            this._debugVisualizationTrees.delete(id);
+        });
+    }
+    async $getVisualizerTreeItemChildren(treeId, element) {
+        const item = this._debugVisualizationElements.get(element)?.item;
+        if (!item) {
+            return [];
+        }
+        const children = await this._debugVisualizationTrees.get(treeId)?.getChildren?.(item);
+        return children?.map(i => this.convertVisualizerTreeItem(treeId, i)) || [];
+    }
+    async $editVisualizerTreeItem(element, value) {
+        const e = this._debugVisualizationElements.get(element);
+        if (!e) {
+            return undefined;
+        }
+        const r = await this._debugVisualizationTrees.get(e.provider)?.editItem?.(e.item, value);
+        return this.convertVisualizerTreeItem(e.provider, r || e.item);
+    }
+    $disposeVisualizedTree(element) {
+        const root = this._debugVisualizationElements.get(element);
+        if (!root) {
+            return;
+        }
+        const queue = [root.children];
+        for (const children of queue) {
+            if (children) {
+                for (const child of children) {
+                    queue.push(this._debugVisualizationElements.get(child)?.children);
+                    this._debugVisualizationElements.delete(child);
+                }
+            }
+        }
+    }
+    convertVisualizerTreeItem(treeId, item) {
+        let id = this._debugVisualizationTreeItemIds.get(item);
+        if (!id) {
+            id = this._debugVisualizationTreeItemIdsCounter++;
+            this._debugVisualizationTreeItemIds.set(item, id);
+            this._debugVisualizationElements.set(id, { provider: treeId, item });
+        }
+        return DebugTreeItem.from(item, id);
+    }
     asDebugSourceUri(src, session) {
         const source = src;
         if (typeof source.sourceReference === 'number' && source.sourceReference > 0) {
@@ -114,7 +180,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         if (!visualizer) {
             throw new Error(`No debug visualizer found with id '${id}'`);
         }
-        let { v, provider } = visualizer;
+        let { v, provider, extensionId } = visualizer;
         if (!v.visualization) {
             v = (await provider.resolveDebugVisualization?.(v, token)) || v;
             visualizer.v = v;
@@ -122,7 +188,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         if (!v.visualization) {
             throw new Error(`No visualization returned from resolveDebugVisualization in '${provider}'`);
         }
-        return this.serializeVisualization(v.visualization);
+        return this.serializeVisualization(extensionId, v.visualization);
     }
     async $executeDebugVisualizerCommand(id) {
         const visualizer = this._visualizers.get(id);
@@ -134,33 +200,37 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
             this._commands.executeCommand(command.command, ...(command.arguments || []));
         }
     }
-    async $provideDebugVisualizers(extensionId, id, context, token) {
+    hydrateVisualizationContext(context) {
         const session = this._debugSessions.get(context.sessionId);
-        const key = this.extensionVisKey(extensionId, id);
-        const provider = this._debugVisualizationProviders.get(key);
-        if (!session || !provider) {
-            return [];
-        }
-        const visualizations = await provider.provideDebugVisualization({
-            session,
+        return session && {
+            session: session.api,
             variable: context.variable,
             containerId: context.containerId,
             frameId: context.frameId,
             threadId: context.threadId,
-        }, token);
+        };
+    }
+    async $provideDebugVisualizers(extensionId, id, context, token) {
+        const contextHydrated = this.hydrateVisualizationContext(context);
+        const key = this.extensionVisKey(extensionId, id);
+        const provider = this._debugVisualizationProviders.get(key);
+        if (!contextHydrated || !provider) {
+            return [];
+        }
+        const visualizations = await provider.provideDebugVisualization(contextHydrated, token);
         if (!visualizations) {
             return [];
         }
         return ( visualizations.map(v => {
             const id = ++this._visualizerIdCounter;
-            this._visualizers.set(id, { v, provider });
+            this._visualizers.set(id, { v, provider, extensionId });
             const icon = v.iconPath ? this.getIconPathOrClass(v.iconPath) : undefined;
             return {
                 id,
                 name: v.name,
                 iconClass: icon?.iconClass,
                 iconPath: icon?.iconPath,
-                visualization: this.serializeVisualization(v.visualization),
+                visualization: this.serializeVisualization(extensionId, v.visualization),
             };
         }));
     }
@@ -216,7 +286,8 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
                     hitCondition: bp.hitCondition,
                     logMessage: bp.logMessage,
                     line: bp.location.range.start.line,
-                    character: bp.location.range.start.character
+                    character: bp.location.range.start.character,
+                    mode: bp.mode,
                 });
             }
             else if (bp instanceof FunctionBreakpoint) {
@@ -227,7 +298,8 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
                     hitCondition: bp.hitCondition,
                     logMessage: bp.logMessage,
                     condition: bp.condition,
-                    functionName: bp.functionName
+                    functionName: bp.functionName,
+                    mode: bp.mode,
                 });
             }
         }
@@ -440,7 +512,8 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
                             bpd.enabled,
                             bpd.condition,
                             bpd.hitCondition,
-                            bpd.logMessage
+                            bpd.logMessage,
+                            bpd.mode
                         ));
                     }
                     else if (bpd.type === 'data') {
@@ -451,12 +524,13 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
                             bpd.enabled,
                             bpd.hitCondition,
                             bpd.condition,
-                            bpd.logMessage
+                            bpd.logMessage,
+                            bpd.mode
                         ));
                     }
                     else {
                         const uri = URI.revive(bpd.uri);
-                        bp = ( new SourceBreakpoint(( new Location(uri, ( new Position(bpd.line, bpd.character)))), bpd.enabled, bpd.condition, bpd.hitCondition, bpd.logMessage));
+                        bp = ( new SourceBreakpoint(( new Location(uri, ( new Position(bpd.line, bpd.character)))), bpd.enabled, bpd.condition, bpd.hitCondition, bpd.logMessage, bpd.mode));
                     }
                     setBreakpointId(bp, id);
                     this._breakpoints.set(id, bp);
@@ -508,10 +582,10 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
             throw new Error('no DebugSession found for debug focus context');
         }
         if (focusDto.kind === 'thread') {
-            focus = ( new ThreadFocus(session, focusDto.threadId));
+            focus = ( new ThreadFocus(session.api, focusDto.threadId));
         }
         else {
-            focus = ( new StackFrameFocus(session, focusDto.threadId, focusDto.frameId));
+            focus = ( new StackFrameFocus(session.api, focusDto.threadId, focusDto.frameId));
         }
         this._stackFrameFocus = focus;
         this._onDidChangeStackFrameFocus.fire(this._stackFrameFocus);
@@ -575,18 +649,18 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     }
     async $acceptDebugSessionStarted(sessionDto) {
         const session = await this.getSession(sessionDto);
-        this._onDidStartDebugSession.fire(session);
+        this._onDidStartDebugSession.fire(session.api);
     }
     async $acceptDebugSessionTerminated(sessionDto) {
         const session = await this.getSession(sessionDto);
         if (session) {
-            this._onDidTerminateDebugSession.fire(session);
+            this._onDidTerminateDebugSession.fire(session.api);
             this._debugSessions.delete(session.id);
         }
     }
     async $acceptDebugSessionActiveChanged(sessionDto) {
         this._activeDebugSession = sessionDto ? await this.getSession(sessionDto) : undefined;
-        this._onDidChangeActiveDebugSession.fire(this._activeDebugSession);
+        this._onDidChangeActiveDebugSession.fire(this._activeDebugSession?.api);
     }
     async $acceptDebugSessionNameChanged(sessionDto, name) {
         const session = await this.getSession(sessionDto);
@@ -595,7 +669,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     async $acceptDebugSessionCustomEvent(sessionDto, event) {
         const session = await this.getSession(sessionDto);
         const ee = {
-            session: session,
+            session: session.api,
             event: event.event,
             body: event.body
         };
@@ -675,7 +749,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         const promises = ( this._trackerFactories
             .filter(tuple => tuple.type === type || tuple.type === '*')
             .map(
-            tuple => asPromise(() => tuple.factory.createDebugAdapterTracker(session)).then(p => p, err => null)
+            tuple => asPromise(() => tuple.factory.createDebugAdapterTracker(session.api)).then(p => p, err => null)
         ));
         return Promise.race([
             Promise.all(promises).then(result => {
@@ -697,7 +771,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         }
         if (adapterDescriptorFactory) {
             const extensionRegistry = await this._extensionService.getExtensionRegistry();
-            return asPromise(() => adapterDescriptorFactory.createDebugAdapterDescriptor(session, this.daExecutableFromPackage(session, extensionRegistry))).then(daDescriptor => {
+            return asPromise(() => adapterDescriptorFactory.createDebugAdapterDescriptor(session.api, this.daExecutableFromPackage(session, extensionRegistry))).then(daDescriptor => {
                 if (daDescriptor) {
                     return daDescriptor;
                 }
@@ -739,7 +813,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
                         dto.name,
                         folder,
                         dto.configuration,
-                        parent
+                        parent?.api
                     ));
                     this._debugSessions.set(ds.id, ds);
                     this._debugServiceProxy.$sessionCached(ds.id);
@@ -759,13 +833,16 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     extensionVisKey(extensionId, id) {
         return `${extensionId}\0${id}`;
     }
-    serializeVisualization(viz) {
+    serializeVisualization(extensionId, viz) {
         if (!viz) {
             return undefined;
         }
         if ('title' in viz && 'command' in viz) {
             return { type: 0  };
         }
+        if ('treeId' in viz) {
+            return { type: 1 , id: `${extensionId}\0${viz.treeId}` };
+        }
         throw new Error('Unsupported debug visualization type');
     }
     getIconPathOrClass(icon) {
@@ -814,37 +891,41 @@ class ExtHostDebugSession {
         this._configuration = _configuration;
         this._parentSession = _parentSession;
     }
+    get api() {
+        const that = this;
+        return this.apiSession ??= ( Object.freeze({
+            id: that._id,
+            type: that._type,
+            get name() {
+                return that._name;
+            },
+            set name(name) {
+                that._name = name;
+                that._debugServiceProxy.$setDebugSessionName(that._id, name);
+            },
+            parentSession: that._parentSession,
+            workspaceFolder: that._workspaceFolder,
+            configuration: that._configuration,
+            customRequest(command, args) {
+                return that._debugServiceProxy.$customDebugAdapterRequest(that._id, command, args);
+            },
+            getDebugProtocolBreakpoint(breakpoint) {
+                return that._debugServiceProxy.$getDebugProtocolBreakpoint(that._id, breakpoint.id);
+            }
+        }));
+    }
     get id() {
         return this._id;
     }
     get type() {
         return this._type;
     }
-    get name() {
-        return this._name;
-    }
-    set name(name) {
-        this._name = name;
-        this._debugServiceProxy.$setDebugSessionName(this._id, name);
-    }
-    get parentSession() {
-        return this._parentSession;
-    }
     _acceptNameChanged(name) {
         this._name = name;
     }
-    get workspaceFolder() {
-        return this._workspaceFolder;
-    }
     get configuration() {
         return this._configuration;
     }
-    customRequest(command, args) {
-        return this._debugServiceProxy.$customDebugAdapterRequest(this._id, command, args);
-    }
-    getDebugProtocolBreakpoint(breakpoint) {
-        return this._debugServiceProxy.$getDebugProtocolBreakpoint(this._id, breakpoint.id);
-    }
 }
 class ExtHostDebugConsole {
     constructor(proxy) {

package/vscode/src/vs/workbench/api/common/extHostDocumentData.js

@@ -18,12 +18,11 @@ function getWordDefinitionFor(languageId) {
     return _languageId2WordDefinition.get(languageId);
 }
 class ExtHostDocumentData extends MirrorTextModel {
-    constructor(_proxy, uri, lines, eol, versionId, _languageId, _isDirty, notebook) {
+    constructor(_proxy, uri, lines, eol, versionId, _languageId, _isDirty) {
         super(uri, lines, eol, versionId);
         this._proxy = _proxy;
         this._languageId = _languageId;
         this._isDirty = _isDirty;
-        this.notebook = notebook;
         this._isDisposed = false;
     }
     dispose() {

package/vscode/src/vs/workbench/api/common/extHostDocumentsAndEditors.js

@@ -69,7 +69,7 @@ let ExtHostDocumentsAndEditors = class ExtHostDocumentsAndEditors {
                     }
                 }
                 if (!ref) {
-                    ref = ( new Reference(( new ExtHostDocumentData(( this._extHostRpc.getProxy(MainContext.MainThreadDocuments)), resource, data.lines, data.EOL, data.versionId, data.languageId, data.isDirty, data.notebook))));
+                    ref = ( new Reference(( new ExtHostDocumentData(( this._extHostRpc.getProxy(MainContext.MainThreadDocuments)), resource, data.lines, data.EOL, data.versionId, data.languageId, data.isDirty))));
                     this._documents.set(resource, ref);
                     addedDocuments.push(ref.value);
                 }

package/vscode/src/vs/workbench/api/common/extHostInlineChat.js

@@ -1,10 +1,10 @@
+import { raceCancellation } from '../../../base/common/async.js';
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
-import { Range, Selection as Selection$1, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, ChatFollowup, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
-import { Selection, WorkspaceEdit, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
 import { ApiCommand, ApiCommandArgument, ApiCommandResult } from './extHostCommands.js';
-import { raceCancellation } from '../../../base/common/async.js';
+import { Range, Selection as Selection$1, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, ChatInlineFollowup, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
+import { Selection, WorkspaceEdit, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
 class ProviderWrapper {
     static { this._pool = 0; }
     constructor(extension, provider) {
@@ -96,6 +96,7 @@ class ExtHostInteractiveEditor {
             wholeRange: Range.to(request.wholeRange),
             attempt: request.attempt,
             live: request.live,
+            previewDocument: this._documents.getDocument(URI.revive(request.previewDocument)),
             withIntentDetection: request.withIntentDetection,
         };
         let done = false;
@@ -169,7 +170,7 @@ class ExtHostInteractiveEditor {
         if (entry && response && entry.provider.provideFollowups) {
             const task = Promise.resolve(entry.provider.provideFollowups(sessionData.session, response, token));
             const followups = await raceCancellation(task, token);
-            return followups?.map(ChatFollowup.from);
+            return followups?.map(ChatInlineFollowup.from);
         }
         return undefined;
     }

package/vscode/src/vs/workbench/api/common/extHostInteractive.js

@@ -37,7 +37,6 @@ class ExtHostInteractive {
                     uri: uri,
                     isDirty: false,
                     versionId: 1,
-                    notebook: this._extHostNotebooks.getNotebookDocument(URI.revive(notebookUri))?.apiNotebook
                 }]
         });
     }

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -1,25 +1,25 @@
-import { URI } from '../../../base/common/uri.js';
+import { isFalsyOrEmpty, coalesce, isNonEmptyArray } from '../../../base/common/arrays.js';
+import { raceCancellationError } from '../../../base/common/async.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { isCancellationError, NotImplementedError } from '../../../base/common/errors.js';
+import { IdGenerator } from '../../../base/common/idGenerator.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
 import { mixin, equals } from '../../../base/common/objects.js';
-import { DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Range, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, MultiDocumentHighlight, location, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
-import { Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, Location, CompletionList, InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from './extHostTypes.js';
-import { InlineCompletionTriggerKind } from '../../../editor/common/languages.js';
-import { MainContext } from './extHost.protocol.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
 import { regExpLeadsToEndlessLoop } from '../../../base/common/strings.js';
-import { Range as Range$1 } from '../../../editor/common/core/range.js';
-import { isFalsyOrEmpty, coalesce, isNonEmptyArray } from '../../../base/common/arrays.js';
 import { assertType, isObject } from '../../../base/common/types.js';
+import { URI } from '../../../base/common/uri.js';
+import { Range as Range$1 } from '../../../editor/common/core/range.js';
 import { Selection } from '../../../editor/common/core/selection.js';
-import { CancellationToken } from '../../../base/common/cancellation.js';
-import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
-import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { InlineEditTriggerKind, InlineCompletionTriggerKind } from '../../../editor/common/languages.js';
 import { encodeSemanticTokensDto } from '../../../editor/common/services/semanticTokensDto.js';
-import { IdGenerator } from '../../../base/common/idGenerator.js';
-import { Cache } from './cache.js';
-import { StopWatch } from '../../../base/common/stopwatch.js';
-import { isCancellationError, NotImplementedError } from '../../../base/common/errors.js';
-import { raceCancellationError } from '../../../base/common/async.js';
-import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { localizeWithPath } from '../../../nls.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+import { DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Range, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, MultiDocumentHighlight, location, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
+import { Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, InlineEditTriggerKind as InlineEditTriggerKind$1, Location, CompletionList, InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from './extHostTypes.js';
+import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { Cache } from './cache.js';
+import { MainContext } from './extHost.protocol.js';
 class DocumentSymbolAdapter {
     constructor(_documents, _provider) {
         this._documents = _documents;
@@ -667,6 +667,43 @@ class RenameAdapter {
         }
     }
 }
+class NewSymbolNamesAdapter {
+    constructor(_documents, _provider, _logService) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._logService = _logService;
+    }
+    async provideNewSymbolNames(resource, range, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Range.to(range);
+        try {
+            const value = await this._provider.provideNewSymbolNames(doc, pos, token);
+            if (!value) {
+                return undefined;
+            }
+            return ( value.map(
+                v => typeof v === 'string'
+                    ? { newSymbolName: v }
+                    : { newSymbolName: v.newSymbolName, tags: v.tags }
+            ));
+        }
+        catch (err) {
+            this._logService.error(NewSymbolNamesAdapter._asMessage(err) ?? JSON.stringify(err, null, '\t') );
+            return undefined;
+        }
+    }
+    static _asMessage(err) {
+        if (typeof err === 'string') {
+            return err;
+        }
+        else if (err instanceof Error && typeof err.message === 'string') {
+            return err.message;
+        }
+        else {
+            return undefined;
+        }
+    }
+}
 class SemanticTokensPreviousResult {
     constructor(resultId, tokens) {
         this.resultId = resultId;
@@ -1054,6 +1091,63 @@ class InlineCompletionAdapter extends InlineCompletionAdapterBase {
         }
     }
 }
+class InlineEditAdapter {
+    async provideInlineEdits(uri, context, token) {
+        const doc = this._documents.getDocument(uri);
+        const result = await this._provider.provideInlineEdit(doc, {
+            triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind]
+        }, token);
+        if (!result) {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        let disposableStore = undefined;
+        const pid = this._references.createReferenceId({
+            dispose() {
+                disposableStore?.dispose();
+            },
+            item: result
+        });
+        let acceptCommand = undefined;
+        if (result.accepted) {
+            if (!disposableStore) {
+                disposableStore = ( new DisposableStore());
+            }
+            acceptCommand = this._commands.toInternal(result.accepted, disposableStore);
+        }
+        let rejectCommand = undefined;
+        if (result.rejected) {
+            if (!disposableStore) {
+                disposableStore = ( new DisposableStore());
+            }
+            rejectCommand = this._commands.toInternal(result.rejected, disposableStore);
+        }
+        const langResult = {
+            pid,
+            text: result.text,
+            range: Range.from(result.range),
+            accepted: acceptCommand,
+            rejected: rejectCommand,
+        };
+        return langResult;
+    }
+    disposeEdit(pid) {
+        const data = this._references.disposeReferenceId(pid);
+        data?.dispose();
+    }
+    constructor(_extension, _documents, _provider, _commands) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._commands = _commands;
+        this._references = ( new ReferenceMap());
+        this.languageTriggerKindToVSCodeTriggerKind = {
+            [InlineEditTriggerKind.Automatic]: InlineEditTriggerKind$1.Automatic,
+            [InlineEditTriggerKind.Invoke]: InlineEditTriggerKind$1.Invoke,
+        };
+    }
+}
 class ReferenceMap {
     constructor() {
         this._references = ( new Map());
@@ -1834,6 +1928,14 @@ class ExtHostLanguageFeatures {
     $resolveRenameLocation(handle, resource, position, token) {
         return this._withAdapter(handle, RenameAdapter, adapter => adapter.resolveRenameLocation(URI.revive(resource), position, token), undefined, token);
     }
+    registerNewSymbolNamesProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( new NewSymbolNamesAdapter(this._documents, provider, this._logService)), extension);
+        this._proxy.$registerNewSymbolNamesProvider(handle, this._transformDocumentSelector(selector, extension));
+        return this._createDisposable(handle);
+    }
+    $provideNewSymbolNames(handle, resource, range, token) {
+        return this._withAdapter(handle, NewSymbolNamesAdapter, adapter => adapter.provideNewSymbolNames(URI.revive(resource), range, token), undefined, token);
+    }
     registerDocumentSemanticTokensProvider(extension, selector, provider, legend) {
         const handle = this._addNewAdapter(( new DocumentSemanticTokensAdapter(this._documents, provider)), extension);
         const eventHandle = (typeof provider.onDidChangeSemanticTokens === 'function' ? this._nextHandle() : undefined);
@@ -1901,6 +2003,18 @@ class ExtHostLanguageFeatures {
     $freeInlineCompletionsList(handle, pid) {
         this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => { adapter.disposeCompletions(pid); }, undefined, undefined);
     }
+    registerInlineEditProvider(extension, selector, provider) {
+        const adapter = ( new InlineEditAdapter(extension, this._documents, provider, this._commands.converter));
+        const handle = this._addNewAdapter(adapter, extension);
+        this._proxy.$registerInlineEditProvider(handle, this._transformDocumentSelector(selector, extension), extension.identifier);
+        return this._createDisposable(handle);
+    }
+    $provideInlineEdit(handle, resource, context, token) {
+        return this._withAdapter(handle, InlineEditAdapter, adapter => adapter.provideInlineEdits(URI.revive(resource), context, token), undefined, token);
+    }
+    $freeInlineEdit(handle, pid) {
+        this._withAdapter(handle, InlineEditAdapter, async (adapter) => { adapter.disposeEdit(pid); }, undefined, undefined);
+    }
     registerSignatureHelpProvider(extension, selector, provider, metadataOrTriggerChars) {
         const metadata = Array.isArray(metadataOrTriggerChars)
             ? { triggerCharacters: metadataOrTriggerChars, retriggerCharacters: [] }

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -319,6 +319,17 @@ class ExtHostNotebookController {
                         }
                         finalMatchedTargets.add(uri);
                     });
+                }).catch(err => {
+                    if (err.code === 'ENOENT') {
+                        console.warn(`Could not find notebook search results, ignoring notebook results.`);
+                        return {
+                            limitHit: false,
+                            messages: [],
+                        };
+                    }
+                    else {
+                        throw err;
+                    }
                 });
             }))))));
             return;
@@ -448,7 +459,7 @@ class ExtHostNotebookController {
                     uri,
                     modelData
                 ));
-                addedCellDocuments.push(...( modelData.cells.map(cell => ExtHostCell.asModelAddData(document.apiNotebook, cell))));
+                addedCellDocuments.push(...( modelData.cells.map(cell => ExtHostCell.asModelAddData(cell))));
                 this._documents.get(uri)?.dispose();
                 this._documents.set(uri, document);
                 this._textDocumentsAndEditors.$acceptDocumentsAndEditorsDelta({ addedDocuments: addedCellDocuments });