@codingame/monaco-vscode-api 4.5.2 → 5.0.1

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

@@ -11,12 +11,12 @@ 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 { InlineEditTriggerKind, InlineCompletionTriggerKind } from '../../../editor/common/languages.js';
+import { NewSymbolNameTriggerKind, InlineEditTriggerKind, InlineCompletionTriggerKind } from '../../../editor/common/languages.js';
 import { encodeSemanticTokensDto } from '../../../editor/common/services/semanticTokensDto.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, PartialAcceptInfo } from './extHostTypeConverters.js';
-import { Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, DocumentPasteEditKind, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, InlineEditTriggerKind as InlineEditTriggerKind$1, Location, CompletionList, InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from './extHostTypes.js';
+import { Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, DocumentDropOrPasteEditKind, NewSymbolNameTriggerKind as NewSymbolNameTriggerKind$1, 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';
@@ -212,14 +212,29 @@ class TypeDefinitionAdapter {
     }
 }
 class HoverAdapter {
+    static { this.HOVER_MAP_MAX_SIZE = 10; }
     constructor(_documents, _provider) {
         this._documents = _documents;
         this._provider = _provider;
+        this._hoverCounter = 0;
+        this._hoverMap = ( (new Map()));
     }
-    async provideHover(resource, position, token) {
+    async provideHover(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
         const pos = Position.to(position);
-        const value = await this._provider.provideHover(doc, pos, token);
+        let value;
+        if (context && context.verbosityRequest) {
+            const previousHoverId = context.verbosityRequest.previousHover.id;
+            const previousHover = this._hoverMap.get(previousHoverId);
+            if (!previousHover) {
+                throw ( (new Error(`Hover with id ${previousHoverId} not found`)));
+            }
+            const hoverContext = { action: context.verbosityRequest.action, previousHover };
+            value = await this._provider.provideHover(doc, pos, token, hoverContext);
+        }
+        else {
+            value = await this._provider.provideHover(doc, pos, token);
+        }
         if (!value || isFalsyOrEmpty(value.contents)) {
             return undefined;
         }
@@ -229,7 +244,22 @@ class HoverAdapter {
         if (!value.range) {
             value.range = ( (new Range$2(pos, pos)));
         }
-        return Hover.from(value);
+        const convertedHover = Hover.from(value);
+        const id = this._hoverCounter;
+        if (this._hoverMap.size === HoverAdapter.HOVER_MAP_MAX_SIZE) {
+            const minimumId = Math.min(...( (this._hoverMap.keys())));
+            this._hoverMap.delete(minimumId);
+        }
+        this._hoverMap.set(id, value);
+        this._hoverCounter += 1;
+        const hover = {
+            ...convertedHover,
+            id
+        };
+        return hover;
+    }
+    releaseHover(id) {
+        this._hoverMap.delete(id);
     }
 }
 class EvaluatableExpressionAdapter {
@@ -479,7 +509,7 @@ class DocumentPasteEditProvider {
             return (await this._proxy.$resolvePasteFileData(this._handle, requestId, id)).buffer;
         });
         const edits = await this._provider.provideDocumentPasteEdits(doc, vscodeRanges, dataTransfer, {
-            only: context.only ? ( (new DocumentPasteEditKind(context.only))) : undefined,
+            only: context.only ? ( (new DocumentDropOrPasteEditKind(context.only))) : undefined,
             triggerKind: context.triggerKind,
         }, token);
         if (!edits || token.isCancellationRequested) {
@@ -705,16 +735,24 @@ class RenameAdapter {
     }
 }
 class NewSymbolNamesAdapter {
+    static { this.languageTriggerKindToVSCodeTriggerKind = {
+        [NewSymbolNameTriggerKind.Invoke]: NewSymbolNameTriggerKind$1.Invoke,
+        [NewSymbolNameTriggerKind.Automatic]: NewSymbolNameTriggerKind$1.Automatic,
+    }; }
     constructor(_documents, _provider, _logService) {
         this._documents = _documents;
         this._provider = _provider;
         this._logService = _logService;
     }
-    async provideNewSymbolNames(resource, range, token) {
+    async supportsAutomaticNewSymbolNamesTriggerKind() {
+        return this._provider.supportsAutomaticTriggerKind;
+    }
+    async provideNewSymbolNames(resource, range, triggerKind, token) {
         const doc = this._documents.getDocument(resource);
         const pos = Range.to(range);
         try {
-            const value = await this._provider.provideNewSymbolNames(doc, pos, token);
+            const kind = NewSymbolNamesAdapter.languageTriggerKindToVSCodeTriggerKind[triggerKind];
+            const value = await this._provider.provideNewSymbolNames(doc, pos, kind, token);
             if (!value) {
                 return undefined;
             }
@@ -1649,13 +1687,14 @@ class TypeHierarchyAdapter {
         return map?.get(itemId);
     }
 }
-class DocumentOnDropEditAdapter {
+class DocumentDropEditAdapter {
     constructor(_proxy, _documents, _provider, _handle, _extension) {
         this._proxy = _proxy;
         this._documents = _documents;
         this._provider = _provider;
         this._handle = _handle;
         this._extension = _extension;
+        this._cache = ( (new Cache('DocumentDropEdit')));
     }
     async provideDocumentOnDropEdits(requestId, uri, position, dataTransferDto, token) {
         const doc = this._documents.getDocument(uri);
@@ -1667,8 +1706,11 @@ class DocumentOnDropEditAdapter {
         if (!edits) {
             return undefined;
         }
+        const editsArray = asArray(edits);
+        const cacheId = this._cache.add(editsArray);
         return (
-             (asArray(edits).map((edit) => ({
+             (editsArray.map((edit, i) => ({
+                _cacheId: [cacheId, i],
                 title: edit.title ?? ( localizeWithPath(
                     _moduleId,
                     1,
@@ -1682,6 +1724,19 @@ class DocumentOnDropEditAdapter {
             })))
         );
     }
+    async resolveDropEdit(id, token) {
+        const [sessionId, itemId] = id;
+        const item = this._cache.get(sessionId, itemId);
+        if (!item || !this._provider.resolveDocumentDropEdit) {
+            return {};
+        }
+        const resolvedItem = (await this._provider.resolveDocumentDropEdit(item, token)) ?? item;
+        const additionalEdit = resolvedItem.additionalEdit ? WorkspaceEdit.from(resolvedItem.additionalEdit, undefined) : undefined;
+        return { additionalEdit };
+    }
+    releaseDropEdits(id) {
+        this._cache.delete(id);
+    }
 }
 class MappedEditsAdapter {
     constructor(_documents, _provider) {
@@ -1847,8 +1902,11 @@ class ExtHostLanguageFeatures {
         this._proxy.$registerHoverProvider(handle, this._transformDocumentSelector(selector, extension));
         return this._createDisposable(handle);
     }
-    $provideHover(handle, resource, position, token) {
-        return this._withAdapter(handle, HoverAdapter, adapter => adapter.provideHover(URI.revive(resource), position, token), undefined, token);
+    $provideHover(handle, resource, position, context, token) {
+        return this._withAdapter(handle, HoverAdapter, adapter => adapter.provideHover(URI.revive(resource), position, context, token), undefined, token);
+    }
+    $releaseHover(handle, id) {
+        this._withAdapter(handle, HoverAdapter, adapter => Promise.resolve(adapter.releaseHover(id)), undefined, undefined);
     }
     registerEvaluatableExpressionProvider(extension, selector, provider, extensionId) {
         const handle = this._addNewAdapter(( (new EvaluatableExpressionAdapter(this._documents, provider))), extension);
@@ -2001,8 +2059,11 @@ class ExtHostLanguageFeatures {
         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);
+    $supportsAutomaticNewSymbolNamesTriggerKind(handle) {
+        return this._withAdapter(handle, NewSymbolNamesAdapter, adapter => adapter.supportsAutomaticNewSymbolNamesTriggerKind(), false, undefined);
+    }
+    $provideNewSymbolNames(handle, resource, range, triggerKind, token) {
+        return this._withAdapter(handle, NewSymbolNamesAdapter, adapter => adapter.provideNewSymbolNames(URI.revive(resource), range, triggerKind, token), undefined, token);
     }
     registerDocumentSemanticTokensProvider(extension, selector, provider, legend) {
         const handle = this._addNewAdapter(( (new DocumentSemanticTokensAdapter(this._documents, provider))), extension);
@@ -2211,14 +2272,23 @@ class ExtHostLanguageFeatures {
     registerDocumentOnDropEditProvider(extension, selector, provider, metadata) {
         const handle = this._nextHandle();
         this._adapter.set(handle, ( (new AdapterData(
-             (new DocumentOnDropEditAdapter(this._proxy, this._documents, provider, handle, extension)),
+             (new DocumentDropEditAdapter(this._proxy, this._documents, provider, handle, extension)),
             extension
         ))));
-        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), isProposedApiEnabled(extension, 'dropMetadata') ? metadata : undefined);
+        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), isProposedApiEnabled(extension, 'documentPaste') && metadata ? {
+            supportsResolve: !!provider.resolveDocumentDropEdit,
+            dropMimeTypes: metadata.dropMimeTypes,
+        } : undefined);
         return this._createDisposable(handle);
     }
     $provideDocumentOnDropEdits(handle, requestId, resource, position, dataTransferDto, token) {
-        return this._withAdapter(handle, DocumentOnDropEditAdapter, adapter => Promise.resolve(adapter.provideDocumentOnDropEdits(requestId, URI.revive(resource), position, dataTransferDto, token)), undefined, undefined);
+        return this._withAdapter(handle, DocumentDropEditAdapter, adapter => Promise.resolve(adapter.provideDocumentOnDropEdits(requestId, URI.revive(resource), position, dataTransferDto, token)), undefined, undefined);
+    }
+    $resolveDropEdit(handle, id, token) {
+        return this._withAdapter(handle, DocumentDropEditAdapter, adapter => adapter.resolveDropEdit(id, token), {}, undefined);
+    }
+    $releaseDropEdits(handle, cacheId) {
+        this._withAdapter(handle, DocumentDropEditAdapter, adapter => Promise.resolve(adapter.releaseDropEdits(cacheId)), undefined, undefined);
     }
     registerMappedEditsProvider(extension, selector, provider) {
         const handle = this._addNewAdapter(( (new MappedEditsAdapter(this._documents, provider))), extension);

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

@@ -14,6 +14,7 @@ import { createDecorator } from '../../../platform/instantiation/common/instanti
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { IExtHostAuthentication } from './extHostAuthentication.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
+import { Iterable } from '../../../base/common/iterator.js';
 var ExtHostLanguageModels_1;
 const _moduleId = "vs/workbench/api/common/extHostLanguageModels";
 const IExtHostLanguageModels = ( (createDecorator('IExtHostLanguageModels')));
@@ -111,12 +112,18 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         this._proxy.$registerLanguageModelProvider(handle, identifier, {
             extension: extension.identifier,
             identifier: identifier,
-            model: metadata.name ?? '',
+            name: metadata.name ?? '',
+            version: metadata.version,
+            tokens: metadata.tokens,
             auth
         });
+        const responseReceivedListener = provider.onDidReceiveLanguageModelResponse2?.(({ extensionId, participant, tokenCount }) => {
+            this._proxy.$whenLanguageModelChatRequestMade(identifier, ( (new ExtensionIdentifier(extensionId))), participant, tokenCount);
+        });
         return toDisposable(() => {
             this._languageModels.delete(handle);
             this._proxy.$unregisterProvider(handle);
+            responseReceivedListener?.dispose();
         });
     }
     async $provideLanguageModelResponse(handle, requestId, from, messages, options, token) {
@@ -133,13 +140,20 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         })));
         return data.provider.provideLanguageModelResponse2(( (messages.map(LanguageModelMessage.to))), options, ExtensionIdentifier.toKey(from), progress, token);
     }
+    $provideTokenLength(handle, value, token) {
+        const data = this._languageModels.get(handle);
+        if (!data) {
+            return Promise.resolve(0);
+        }
+        return Promise.resolve(data.provider.provideTokenCount(value, token));
+    }
     $updateLanguageModels(data) {
         const added = [];
         const removed = [];
         if (data.added) {
             for (const metadata of data.added) {
                 this._allLanguageModelData.set(metadata.identifier, metadata);
-                added.push(metadata.model);
+                added.push(metadata.identifier);
             }
         }
         if (data.removed) {
@@ -276,6 +290,29 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             }
         }
     }
+    async computeTokenLength(languageModelId, value, token) {
+        const data = this._allLanguageModelData.get(languageModelId);
+        if (!data) {
+            throw LanguageModelError.NotFound(`Language model '${languageModelId}' is unknown.`);
+        }
+        const local = Iterable.find(( (this._languageModels.values())), candidate => candidate.languageModelId === languageModelId);
+        if (local) {
+            return local.provider.provideTokenCount(value, token);
+        }
+        return this._proxy.$countTokens(data.identifier, (typeof value === 'string' ? value : LanguageModelMessage.from(value)), token);
+    }
+    getLanguageModelInfo(languageModelId) {
+        const data = this._allLanguageModelData.get(languageModelId);
+        if (!data) {
+            return undefined;
+        }
+        return {
+            id: data.identifier,
+            name: data.name,
+            version: data.version,
+            tokens: data.tokens,
+        };
+    }
     createLanguageModelAccessInformation(from) {
         this._languageAccessInformationExtensions.add(from);
         const that = this;

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

@@ -2,6 +2,7 @@ import { AsyncEmitter } from '../../../base/common/event.js';
 import { URI } from '../../../base/common/uri.js';
 import { TextDocumentSaveReason, WorkspaceEdit as WorkspaceEdit$1 } from './extHostTypeConverters.js';
 import { WorkspaceEdit } from './extHostTypes.js';
+import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 class ExtHostNotebookDocumentSaveParticipant {
     constructor(_logService, _notebooksAndEditors, _mainThreadBulkEdits, _thresholds = { timeout: 1500, errors: 3 }) {
         this._logService = _logService;
@@ -56,7 +57,7 @@ class ExtHostNotebookDocumentSaveParticipant {
             const { edits } = WorkspaceEdit$1.from(edit);
             dto.edits = dto.edits.concat(edits);
         }
-        return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(dto);
+        return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(( new SerializableObjectWithBuffers(dto)));
     }
 }
 export { ExtHostNotebookDocumentSaveParticipant };

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

@@ -1,11 +1,12 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { TerminalShellExecutionCommandLineConfidence } from './extHostTypes.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { IExtHostTerminalService } from './extHostTerminalService.js';
 import { Emitter } from '../../../base/common/event.js';
-import { URI } from '../../../base/common/uri.js';
+import { isUriComponents, URI } from '../../../base/common/uri.js';
 import { AsyncIterableObject, Barrier } from '../../../base/common/async.js';
 const IExtHostTerminalShellIntegration = ( createDecorator('IExtHostTerminalShellIntegration'));
 let ExtHostTerminalShellIntegration = class ExtHostTerminalShellIntegration extends Disposable {
@@ -39,7 +40,7 @@ let ExtHostTerminalShellIntegration = class ExtHostTerminalShellIntegration exte
             this._activeShellIntegrations.set(instanceId, shellIntegration);
             shellIntegration.store.add(terminal.onWillDispose(() => this._activeShellIntegrations.get(instanceId)?.dispose()));
             shellIntegration.store.add(shellIntegration.onDidRequestShellExecution(commandLine => this._proxy.$executeCommand(instanceId, commandLine)));
-            shellIntegration.store.add(shellIntegration.onDidRequestEndExecution(e => this._onDidEndTerminalShellExecution.fire(e.value)));
+            shellIntegration.store.add(shellIntegration.onDidRequestEndExecution(e => this._onDidEndTerminalShellExecution.fire(e)));
             shellIntegration.store.add(shellIntegration.onDidRequestChangeShellIntegration(e => this._onDidChangeTerminalShellIntegration.fire(e)));
             terminal.shellIntegration = shellIntegration.value;
         }
@@ -48,20 +49,30 @@ let ExtHostTerminalShellIntegration = class ExtHostTerminalShellIntegration exte
             shellIntegration: shellIntegration.value
         });
     }
-    $shellExecutionStart(instanceId, commandLine, cwd) {
+    $shellExecutionStart(instanceId, commandLineValue, commandLineConfidence, isTrusted, cwd) {
         if (!( this._activeShellIntegrations.has(instanceId))) {
             this.$shellIntegrationChange(instanceId);
         }
+        const commandLine = {
+            value: commandLineValue,
+            confidence: commandLineConfidence,
+            isTrusted
+        };
         this._activeShellIntegrations.get(instanceId)?.startShellExecution(commandLine, cwd);
     }
-    $shellExecutionEnd(instanceId, commandLine, exitCode) {
+    $shellExecutionEnd(instanceId, commandLineValue, commandLineConfidence, isTrusted, exitCode) {
+        const commandLine = {
+            value: commandLineValue,
+            confidence: commandLineConfidence,
+            isTrusted
+        };
         this._activeShellIntegrations.get(instanceId)?.endShellExecution(commandLine, exitCode);
     }
     $shellExecutionData(instanceId, data) {
         this._activeShellIntegrations.get(instanceId)?.emitData(data);
     }
     $cwdChange(instanceId, cwd) {
-        this._activeShellIntegrations.get(instanceId)?.setCwd(cwd);
+        this._activeShellIntegrations.get(instanceId)?.setCwd(isUriComponents(cwd) ? URI.revive(cwd) : cwd);
     }
     $closeTerminal(instanceId) {
         this._activeShellIntegrations.get(instanceId)?.dispose();
@@ -91,25 +102,39 @@ class InternalTerminalShellIntegration extends Disposable {
             get cwd() {
                 return that._cwd;
             },
-            executeCommand(commandLine) {
-                that._onDidRequestShellExecution.fire(commandLine);
-                const execution = that.startShellExecution(commandLine, that._cwd).value;
+            executeCommand(commandLineOrExecutable, args) {
+                let commandLineValue = commandLineOrExecutable;
+                if (args) {
+                    commandLineValue += ` "${( args.map(e => `${e.replaceAll('"', '\\"')}`)).join('" "')}"`;
+                }
+                that._onDidRequestShellExecution.fire(commandLineValue);
+                const commandLine = {
+                    value: commandLineValue,
+                    confidence: TerminalShellExecutionCommandLineConfidence.High,
+                    isTrusted: true
+                };
+                const execution = that.startShellExecution(commandLine, that._cwd, true).value;
                 that._ignoreNextExecution = true;
                 return execution;
             }
         };
     }
-    startShellExecution(commandLine, cwd) {
+    startShellExecution(commandLine, cwd, fireEventInMicrotask) {
         if (this._ignoreNextExecution && this._currentExecution) {
             this._ignoreNextExecution = false;
         }
         else {
             if (this._currentExecution) {
-                this._currentExecution.endExecution(undefined, undefined);
-                this._onDidRequestEndExecution.fire(this._currentExecution);
+                this._currentExecution.endExecution(undefined);
+                this._onDidRequestEndExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value, exitCode: undefined });
+            }
+            const currentExecution = this._currentExecution = ( new InternalTerminalShellExecution(commandLine, cwd));
+            if (fireEventInMicrotask) {
+                queueMicrotask(() => this._onDidStartTerminalShellExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: currentExecution.value }));
+            }
+            else {
+                this._onDidStartTerminalShellExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value });
             }
-            this._currentExecution = ( new InternalTerminalShellExecution(this._terminal, commandLine, cwd));
-            this._onDidStartTerminalShellExecution.fire(this._currentExecution.value);
         }
         return this._currentExecution;
     }
@@ -118,17 +143,15 @@ class InternalTerminalShellIntegration extends Disposable {
     }
     endShellExecution(commandLine, exitCode) {
         if (this._currentExecution) {
-            this._currentExecution.endExecution(commandLine, exitCode);
-            this._onDidRequestEndExecution.fire(this._currentExecution);
+            this._currentExecution.endExecution(commandLine);
+            this._onDidRequestEndExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value, exitCode });
             this._currentExecution = undefined;
         }
     }
     setCwd(cwd) {
         let wasChanged = false;
         if (URI.isUri(this._cwd)) {
-            if (( this._cwd.toString()) !== ( cwd.toString())) {
-                wasChanged = true;
-            }
+            wasChanged = !URI.isUri(cwd) || ( this._cwd.toString()) !== ( cwd.toString());
         }
         else if (this._cwd !== cwd) {
             wasChanged = true;
@@ -140,35 +163,26 @@ class InternalTerminalShellIntegration extends Disposable {
     }
 }
 class InternalTerminalShellExecution {
-    constructor(terminal, _commandLine, cwd) {
-        this.terminal = terminal;
+    constructor(_commandLine, cwd) {
         this._commandLine = _commandLine;
         this.cwd = cwd;
-        this._exitCode = ( new Promise(resolve => {
-            this._exitCodeResolve = resolve;
-        }));
+        this._ended = false;
         const that = this;
         this.value = {
-            get terminal() {
-                return terminal;
-            },
             get commandLine() {
                 return that._commandLine;
             },
             get cwd() {
-                return cwd;
+                return that.cwd;
             },
-            get exitCode() {
-                return that._exitCode;
-            },
-            createDataStream() {
+            read() {
                 return that._createDataStream();
             }
         };
     }
     _createDataStream() {
         if (!this._dataStream) {
-            if (this._exitCodeResolve === undefined) {
+            if (this._ended) {
                 return AsyncIterableObject.EMPTY;
             }
             this._dataStream = ( new ShellExecutionDataStream());
@@ -178,14 +192,13 @@ class InternalTerminalShellExecution {
     emitData(data) {
         this._dataStream?.emitData(data);
     }
-    endExecution(commandLine, exitCode) {
+    endExecution(commandLine) {
         if (commandLine) {
             this._commandLine = commandLine;
         }
         this._dataStream?.endExecution();
         this._dataStream = undefined;
-        this._exitCodeResolve?.(exitCode);
-        this._exitCodeResolve = undefined;
+        this._ended = true;
     }
 }
 class ShellExecutionDataStream extends Disposable {
@@ -194,7 +207,10 @@ class ShellExecutionDataStream extends Disposable {
         this._emitters = [];
     }
     createIterable() {
-        const barrier = this._barrier = ( new Barrier());
+        if (!this._barrier) {
+            this._barrier = ( new Barrier());
+        }
+        const barrier = this._barrier;
         const iterable = ( new AsyncIterableObject(async (emitter) => {
             this._emitters.push(emitter);
             await barrier.wait();

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

@@ -162,7 +162,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
             throw ( new Error('Controller not found'));
         }
         await this.proxy.$runTests({
-            isUiTriggered: false,
+            preserveFocus: req.preserveFocus ?? true,
             targets: [{
                     testIds: req.include?.map(t => ( TestId.fromExtHostTestItem(t, controller.collection.root.id).toString())) ?? [controller.collection.root.id],
                     profileGroup: profileGroupToBitset[profile.kind],
@@ -339,18 +339,15 @@ class TestRunTracker extends Disposable {
     }
     getCoverageDetails(id, token) {
         const [, taskId, covId] = TestId.fromString(id).path;
-        const obj = this.publishedCoverage.get(covId);
-        if (!obj) {
+        const coverage = this.publishedCoverage.get(covId);
+        if (!coverage) {
             return [];
         }
-        if (obj.backCompatResolve) {
-            return obj.backCompatResolve(token);
-        }
         const task = this.tasks.get(taskId);
         if (!task) {
             throw ( new Error('unreachable: run task was not found'));
         }
-        return this.profile?.loadDetailedCoverage?.(task.run, obj.coverage, token) ?? [];
+        return this.profile?.loadDetailedCoverage?.(task.run, coverage, token) ?? [];
     }
     createRun(name) {
         const runId = this.dto.id;
@@ -379,34 +376,18 @@ class TestRunTracker extends Disposable {
             }
             this.proxy.$appendTestMessagesInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), converted);
         };
-        const addCoverage = (coverage, backCompatResolve) => {
-            const uriStr = ( coverage.uri.toString());
-            const id = ( ( new TestId([runId, taskId, uriStr])).toString());
-            this.publishedCoverage.set(uriStr, { coverage, backCompatResolve });
-            this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
-        };
         let ended = false;
-        let coverageProvider;
         const run = {
             isPersisted: this.dto.isPersisted,
             token: this.cts.token,
             name,
             onDidDispose: this.onDidDispose,
-            get coverageProvider() {
-                return coverageProvider;
-            },
-            set coverageProvider(provider) {
-                coverageProvider = provider;
-                if (provider) {
-                    Promise.resolve(provider.provideFileCoverage(CancellationToken.None)).then(coverage => {
-                        coverage?.forEach(c => addCoverage(c, provider.resolveFileCoverage && (async (token) => {
-                            const r = await provider.resolveFileCoverage(c, token);
-                            return (r || c).detailedCoverage;
-                        })));
-                    });
-                }
+            addCoverage: coverage => {
+                const uriStr = ( coverage.uri.toString());
+                const id = ( ( new TestId([runId, taskId, uriStr])).toString());
+                this.publishedCoverage.set(uriStr, coverage);
+                this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
             },
-            addCoverage,
             enqueued: guardTestMutation(test => {
                 this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 1 );
             }),
@@ -544,6 +525,7 @@ class TestRunCoordinator {
             exclude: request.exclude?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [],
             id: dto.id,
             include: request.include?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [collection.root.id],
+            preserveFocus: request.preserveFocus ?? true,
             persist
         });
         const tracker = this.getTracker(request, dto, request.profile);

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

@@ -298,7 +298,12 @@ class ExtHostTreeView extends Disposable {
         this.dataProvider = options.treeDataProvider;
         this.dndController = options.dragAndDropController;
         if (this.dataProvider.onDidChangeTreeData) {
-            this._register(this.dataProvider.onDidChangeTreeData(elementOrElements => this._onDidChangeData.fire({ message: false, element: elementOrElements })));
+            this._register(this.dataProvider.onDidChangeTreeData(elementOrElements => {
+                if (Array.isArray(elementOrElements) && elementOrElements.length === 0) {
+                    return;
+                }
+                this._onDidChangeData.fire({ message: false, element: elementOrElements });
+            }));
         }
         let refreshingPromise;
         let promiseCallback;