@codingame/monaco-vscode-extensions-service-override 6.0.2 → 7.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadSCM.js

@@ -1,11 +1,17 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import 'vscode/vscode/vs/base/common/arrays';
 import { Disposable, DisposableStore, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm.service';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { MarshalledId } from 'vscode/vscode/vs/base/common/marshallingIds';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff.service';
@@ -17,6 +23,7 @@ import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/langu
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 
 function getIconFromIconDto(iconDto) {
     if (iconDto === undefined) {
@@ -33,6 +40,11 @@ function getIconFromIconDto(iconDto) {
         return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
     }
 }
+function toISCMHistoryItem(historyItemDto) {
+    const icon = getIconFromIconDto(historyItemDto.icon);
+    const labels = historyItemDto.labels?.map(l => ({ title: l.title, icon: getIconFromIconDto(l.icon) }));
+    return { ...historyItemDto, icon, labels };
+}
 class SCMInputBoxContentProvider extends Disposable {
     constructor(textModelService, modelService, languageService) {
         super();
@@ -128,22 +140,28 @@ class MainThreadSCMHistoryProvider {
         this._currentHistoryItemGroup = historyItemGroup;
         this._onDidChangeCurrentHistoryItemGroup.fire();
     }
+    get currentHistoryItemGroupObs() { return this._currentHistoryItemGroupObs; }
     constructor(proxy, handle) {
         this.proxy = proxy;
         this.handle = handle;
         this._onDidChangeCurrentHistoryItemGroup = ( new Emitter());
         this.onDidChangeCurrentHistoryItemGroup = this._onDidChangeCurrentHistoryItemGroup.event;
+        this._currentHistoryItemGroupObs = observableValue(this, undefined);
     }
     async resolveHistoryItemGroupCommonAncestor(historyItemGroupId1, historyItemGroupId2) {
         return this.proxy.$resolveHistoryItemGroupCommonAncestor(this.handle, historyItemGroupId1, historyItemGroupId2, CancellationToken.None);
     }
     async provideHistoryItems(historyItemGroupId, options) {
         const historyItems = await this.proxy.$provideHistoryItems(this.handle, historyItemGroupId, options, CancellationToken.None);
-        return historyItems?.map(historyItem => ({ ...historyItem, icon: getIconFromIconDto(historyItem.icon) }));
+        return historyItems?.map(historyItem => toISCMHistoryItem(historyItem));
+    }
+    async provideHistoryItems2(options) {
+        const historyItems = await this.proxy.$provideHistoryItems2(this.handle, options, CancellationToken.None);
+        return historyItems?.map(historyItem => toISCMHistoryItem(historyItem));
     }
     async provideHistoryItemSummary(historyItemId, historyItemParentId) {
         const historyItem = await this.proxy.$provideHistoryItemSummary(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
-        return historyItem ? { ...historyItem, icon: getIconFromIconDto(historyItem.icon) } : undefined;
+        return historyItem ? toISCMHistoryItem(historyItem) : undefined;
     }
     async provideHistoryItemChanges(historyItemId, historyItemParentId) {
         const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
@@ -154,6 +172,9 @@ class MainThreadSCMHistoryProvider {
             renameUri: change.renameUri && URI.revive(change.renameUri)
         }));
     }
+    $onDidChangeCurrentHistoryItemGroup(historyItemGroup) {
+        this._currentHistoryItemGroupObs.set(historyItemGroup, undefined);
+    }
 }
 class MainThreadSCMProvider {
     static { this.ID_HANDLE = 0; }
@@ -163,15 +184,15 @@ class MainThreadSCMProvider {
     get rootUri() { return this._rootUri; }
     get inputBoxTextModel() { return this._inputBoxTextModel; }
     get contextValue() { return this._providerId; }
-    get commitTemplate() { return this.features.commitTemplate || ''; }
     get historyProvider() { return this._historyProvider; }
     get acceptInputCommand() { return this.features.acceptInputCommand; }
     get actionButton() { return this.features.actionButton ?? undefined; }
-    get statusBarCommands() { return this.features.statusBarCommands; }
-    get count() { return this.features.count; }
+    get count() { return this._count; }
+    get statusBarCommands() { return this._statusBarCommands; }
     get name() { return this._name ?? this._label; }
-    get onDidChangeStatusBarCommands() { return this._onDidChangeStatusBarCommands.event; }
-    constructor(proxy, _handle, _providerId, _label, _rootUri, _inputBoxTextModel, _quickDiffService, _uriIdentService, _workspaceContextService) {
+    get commitTemplate() { return this._commitTemplate; }
+    get historyProviderObs() { return this._historyProviderObs; }
+    constructor(proxy, _handle, _providerId, _label, _rootUri, _inputBoxTextModel, _quickDiffService, _uriIdentService, _workspaceContextService, _logService) {
         this.proxy = proxy;
         this._handle = _handle;
         this._providerId = _providerId;
@@ -181,6 +202,7 @@ class MainThreadSCMProvider {
         this._quickDiffService = _quickDiffService;
         this._uriIdentService = _uriIdentService;
         this._workspaceContextService = _workspaceContextService;
+        this._logService = _logService;
         this._id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
         this.groups = [];
         this._onDidChangeResourceGroups = ( new Emitter());
@@ -189,14 +211,15 @@ class MainThreadSCMProvider {
         this.onDidChangeResources = this._onDidChangeResources.event;
         this._groupsByHandle = Object.create(null);
         this.features = {};
-        this._onDidChangeCommitTemplate = ( new Emitter());
-        this.onDidChangeCommitTemplate = this._onDidChangeCommitTemplate.event;
-        this._onDidChangeStatusBarCommands = ( new Emitter());
+        this._count = observableValue(this, undefined);
+        this._statusBarCommands = observableValue(this, undefined);
+        this._commitTemplate = observableValue(this, '');
         this._onDidChangeHistoryProvider = ( new Emitter());
         this.onDidChangeHistoryProvider = this._onDidChangeHistoryProvider.event;
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
         this.isSCM = true;
+        this._historyProviderObs = observableValue(this, undefined);
         if (_rootUri) {
             const folder = this._workspaceContextService.getWorkspaceFolder(_rootUri);
             if (folder?.uri.toString() === ( _rootUri.toString())) {
@@ -211,10 +234,14 @@ class MainThreadSCMProvider {
         this.features = { ...this.features, ...features };
         this._onDidChange.fire();
         if (typeof features.commitTemplate !== 'undefined') {
-            this._onDidChangeCommitTemplate.fire(this.commitTemplate);
+            this._commitTemplate.set(features.commitTemplate, undefined);
+        }
+        if (typeof features.count !== 'undefined') {
+            this._count.set(features.count, undefined);
         }
         if (typeof features.statusBarCommands !== 'undefined') {
-            this._onDidChangeStatusBarCommands.fire(this.statusBarCommands);
+            this._logService.trace(`MainThreadSCMProvider#updateSourceControl (${this._id}): ${( features.statusBarCommands.map(c => c.title)).join(', ')}`);
+            this._statusBarCommands.set(features.statusBarCommands, undefined);
         }
         if (features.hasQuickDiffProvider && !this._quickDiff) {
             this._quickDiff = this._quickDiffService.addQuickDiffProvider({
@@ -229,10 +256,13 @@ class MainThreadSCMProvider {
             this._quickDiff = undefined;
         }
         if (features.hasHistoryProvider && !this._historyProvider) {
-            this._historyProvider = ( new MainThreadSCMHistoryProvider(this.proxy, this.handle));
+            const historyProvider = ( new MainThreadSCMHistoryProvider(this.proxy, this.handle));
+            this._historyProviderObs.set(historyProvider, undefined);
+            this._historyProvider = historyProvider;
             this._onDidChangeHistoryProvider.fire();
         }
         else if (features.hasHistoryProvider === false && this._historyProvider) {
+            this._historyProviderObs.set(undefined, undefined);
             this._historyProvider = undefined;
             this._onDidChangeHistoryProvider.fire();
         }
@@ -330,6 +360,7 @@ class MainThreadSCMProvider {
             return;
         }
         this._historyProvider.currentHistoryItemGroup = currentHistoryItemGroup ?? undefined;
+        this._historyProviderObs.get()?.$onDidChangeCurrentHistoryItemGroup(currentHistoryItemGroup);
     }
     toJSON() {
         return {
@@ -342,7 +373,7 @@ class MainThreadSCMProvider {
     }
 }
 let MainThreadSCM = class MainThreadSCM {
-    constructor(extHostContext, scmService, scmViewService, languageService, modelService, textModelService, quickDiffService, _uriIdentService, workspaceContextService) {
+    constructor(extHostContext, scmService, scmViewService, languageService, modelService, textModelService, quickDiffService, _uriIdentService, workspaceContextService, logService) {
         this.scmService = scmService;
         this.scmViewService = scmViewService;
         this.languageService = languageService;
@@ -351,7 +382,9 @@ let MainThreadSCM = class MainThreadSCM {
         this.quickDiffService = quickDiffService;
         this._uriIdentService = _uriIdentService;
         this.workspaceContextService = workspaceContextService;
+        this.logService = logService;
         this._repositories = ( new Map());
+        this._repositoryBarriers = ( new Map());
         this._repositoryDisposables = ( new Map());
         this._disposables = ( new DisposableStore());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSCM));
@@ -365,6 +398,7 @@ let MainThreadSCM = class MainThreadSCM {
         this._disposables.dispose();
     }
     async $registerSourceControl(handle, id, label, rootUri, inputBoxDocumentUri) {
+        this._repositoryBarriers.set(handle, ( new Barrier()));
         const inputBoxTextModelRef = await this.textModelService.createModelReference(URI.revive(inputBoxDocumentUri));
         const provider = ( new MainThreadSCMProvider(
             this._proxy,
@@ -375,20 +409,23 @@ let MainThreadSCM = class MainThreadSCM {
             inputBoxTextModelRef.object.textEditorModel,
             this.quickDiffService,
             this._uriIdentService,
-            this.workspaceContextService
+            this.workspaceContextService,
+            this.logService
         ));
         const repository = this.scmService.registerSCMProvider(provider);
         this._repositories.set(handle, repository);
         const disposable = combinedDisposable(inputBoxTextModelRef, Event.filter(this.scmViewService.onDidFocusRepository, r => r === repository)(_ => this._proxy.$setSelectedSourceControl(handle)), repository.input.onDidChange(({ value }) => this._proxy.$onInputBoxValueChange(handle, value)));
+        this._repositoryDisposables.set(handle, disposable);
         if (this.scmViewService.focusedRepository === repository) {
             setTimeout(() => this._proxy.$setSelectedSourceControl(handle), 0);
         }
         if (repository.input.value) {
             setTimeout(() => this._proxy.$onInputBoxValueChange(handle, repository.input.value), 0);
         }
-        this._repositoryDisposables.set(handle, disposable);
+        this._repositoryBarriers.get(handle)?.open();
     }
-    $updateSourceControl(handle, features) {
+    async $updateSourceControl(handle, features) {
+        await this._repositoryBarriers.get(handle)?.wait();
         const repository = this._repositories.get(handle);
         if (!repository) {
             return;
@@ -396,7 +433,8 @@ let MainThreadSCM = class MainThreadSCM {
         const provider = repository.provider;
         provider.$updateSourceControl(features);
     }
-    $unregisterSourceControl(handle) {
+    async $unregisterSourceControl(handle) {
+        await this._repositoryBarriers.get(handle)?.wait();
         const repository = this._repositories.get(handle);
         if (!repository) {
             return;
@@ -406,7 +444,8 @@ let MainThreadSCM = class MainThreadSCM {
         repository.dispose();
         this._repositories.delete(handle);
     }
-    $registerGroups(sourceControlHandle, groups, splices) {
+    async $registerGroups(sourceControlHandle, groups, splices) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -415,7 +454,8 @@ let MainThreadSCM = class MainThreadSCM {
         provider.$registerGroups(groups);
         provider.$spliceGroupResourceStates(splices);
     }
-    $updateGroup(sourceControlHandle, groupHandle, features) {
+    async $updateGroup(sourceControlHandle, groupHandle, features) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -423,7 +463,8 @@ let MainThreadSCM = class MainThreadSCM {
         const provider = repository.provider;
         provider.$updateGroup(groupHandle, features);
     }
-    $updateGroupLabel(sourceControlHandle, groupHandle, label) {
+    async $updateGroupLabel(sourceControlHandle, groupHandle, label) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -431,7 +472,8 @@ let MainThreadSCM = class MainThreadSCM {
         const provider = repository.provider;
         provider.$updateGroupLabel(groupHandle, label);
     }
-    $spliceResourceStates(sourceControlHandle, splices) {
+    async $spliceResourceStates(sourceControlHandle, splices) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -439,7 +481,8 @@ let MainThreadSCM = class MainThreadSCM {
         const provider = repository.provider;
         provider.$spliceGroupResourceStates(splices);
     }
-    $unregisterGroup(sourceControlHandle, handle) {
+    async $unregisterGroup(sourceControlHandle, handle) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -447,42 +490,48 @@ let MainThreadSCM = class MainThreadSCM {
         const provider = repository.provider;
         provider.$unregisterGroup(handle);
     }
-    $setInputBoxValue(sourceControlHandle, value) {
+    async $setInputBoxValue(sourceControlHandle, value) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
         }
         repository.input.setValue(value, false);
     }
-    $setInputBoxPlaceholder(sourceControlHandle, placeholder) {
+    async $setInputBoxPlaceholder(sourceControlHandle, placeholder) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
         }
         repository.input.placeholder = placeholder;
     }
-    $setInputBoxEnablement(sourceControlHandle, enabled) {
+    async $setInputBoxEnablement(sourceControlHandle, enabled) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
         }
         repository.input.enabled = enabled;
     }
-    $setInputBoxVisibility(sourceControlHandle, visible) {
+    async $setInputBoxVisibility(sourceControlHandle, visible) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
         }
         repository.input.visible = visible;
     }
-    $showValidationMessage(sourceControlHandle, message, type) {
+    async $showValidationMessage(sourceControlHandle, message, type) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
         }
         repository.input.showValidationMessage(message, type);
     }
-    $setValidationProviderIsEnabled(sourceControlHandle, enabled) {
+    async $setValidationProviderIsEnabled(sourceControlHandle, enabled) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -497,7 +546,8 @@ let MainThreadSCM = class MainThreadSCM {
             repository.input.validateInput = async () => undefined;
         }
     }
-    $onDidChangeHistoryProviderCurrentHistoryItemGroup(sourceControlHandle, historyItemGroup) {
+    async $onDidChangeHistoryProviderCurrentHistoryItemGroup(sourceControlHandle, historyItemGroup) {
+        await this._repositoryBarriers.get(sourceControlHandle)?.wait();
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
             return;
@@ -515,7 +565,8 @@ MainThreadSCM = __decorate([
     ( __param(5, ITextModelService)),
     ( __param(6, IQuickDiffService)),
     ( __param(7, IUriIdentityService)),
-    ( __param(8, IWorkspaceContextService))
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, ILogService))
 ], MainThreadSCM);
 
 export { MainThreadSCM };

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -106,7 +106,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
                 let value = task.coverage.read(undefined);
                 if (!value) {
                     value = ( new TestCoverage(run, taskId, this.uriIdentityService, {
-                        getCoverageDetails: (id, token) => this.proxy.$getCoverageDetails(id, token)
+                        getCoverageDetails: (id, testId, token) => this.proxy.$getCoverageDetails(id, testId, token)
                             .then(r => ( r.map(CoverageDetails.deserialize))),
                     }));
                     value.append(deserialized, tx);

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -3,7 +3,6 @@ import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
-import { ExtensionType } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
@@ -53,16 +52,6 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         });
         this._initFetchFileSystem();
     }
-    async _scanSingleExtension(extension) {
-        if (extension.location.scheme === Schemas.vscodeRemote) {
-            return this._remoteExtensionsScannerService.scanSingleExtension(extension.location, extension.type === ExtensionType.System);
-        }
-        const scannedExtension = await this._webExtensionsScannerService.scanExistingExtension(extension.location, extension.type, this._userDataProfileService.currentProfile.extensionsResource);
-        if (scannedExtension) {
-            return toExtensionDescription(scannedExtension);
-        }
-        return null;
-    }
     _initFetchFileSystem() {
         const provider = ( new FetchFileSystemProvider());
         this._register(this._fileService.registerProvider(Schemas.http, provider));

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -3,7 +3,7 @@ import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { mark } from 'vscode/vscode/vs/base/common/performance';
 import { isCI } from 'vscode/vscode/vs/base/common/platform';
@@ -40,7 +40,7 @@ import { ExtensionHostManager } from './extensionHostManager.js';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
 import { ExtensionRunningLocationTracker, filterExtensionIdentifiers } from './extensionRunningLocationTracker.js';
-import { ExtensionHostStartup, ActivationKind, ExtensionPointContribution, ActivationTimes, toExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { toExtensionDescription, ExtensionHostStartup, ActivationKind, ExtensionPointContribution, ActivationTimes, toExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionsRegistry, ExtensionMessageCollector } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { LazyCreateExtensionHostManager } from './lazyCreateExtensionHostManager.js';
 import { ResponsiveState } from 'vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol';
@@ -96,7 +96,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._remoteCrashTracker = ( (new ExtensionHostCrashTracker()));
         this._deltaExtensionsQueue = [];
         this._inHandleDeltaExtensions = false;
-        this._extensionHostManagers = [];
+        this._extensionHostManagers = this._register(( (new ExtensionHostCollection())));
         this._resolveAuthorityAttempt = 0;
         this._register(this._fileService.onWillActivateFileSystemProvider(e => {
             if (e.scheme !== Schemas.vscodeRemote) {
@@ -172,15 +172,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }));
     }
     _getExtensionHostManagers(kind) {
-        return this._extensionHostManagers.filter(extHostManager => extHostManager.kind === kind);
-    }
-    _getExtensionHostManagerByRunningLocation(runningLocation) {
-        for (const extensionHostManager of this._extensionHostManagers) {
-            if (extensionHostManager.representsRunningLocation(runningLocation)) {
-                return extensionHostManager;
-            }
-        }
-        return null;
+        return this._extensionHostManagers.getByKind(kind);
     }
     async _handleDeltaExtensions(item) {
         this._deltaExtensionsQueue.push(item);
@@ -226,7 +218,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const toAdd = [];
         for (let i = 0, len = _toAdd.length; i < len; i++) {
             const extension = _toAdd[i];
-            const extensionDescription = await this._scanSingleExtension(extension);
+            const extensionDescription = toExtensionDescription(extension, false);
             if (!extensionDescription) {
                 continue;
             }
@@ -458,7 +450,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             }
         }
         if (runningLocation !== null) {
-            return this._getExtensionHostManagerByRunningLocation(runningLocation);
+            return this._extensionHostManagers.getByRunningLocation(runningLocation);
         }
         return null;
     }
@@ -547,8 +539,8 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             bestErrorResult.error.detail
         )));
     }
-    stopExtensionHosts(reason) {
-        return this._doStopExtensionHostsWithVeto(reason);
+    stopExtensionHosts(reason, auto) {
+        return this._doStopExtensionHostsWithVeto(reason, auto);
     }
     _doStopExtensionHosts() {
         const previouslyActivatedExtensionIds = [];
@@ -557,10 +549,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 previouslyActivatedExtensionIds.push(extensionStatus.id);
             }
         }
-        for (let i = this._extensionHostManagers.length - 1; i >= 0; i--) {
-            this._extensionHostManagers[i].dispose();
-        }
-        this._extensionHostManagers = [];
+        this._extensionHostManagers.disposeAllInReverse();
         for (const extensionStatus of ( (this._extensionStatus.values()))) {
             extensionStatus.clearRuntimeStatus();
         }
@@ -568,7 +557,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._onDidChangeExtensionsStatus.fire(previouslyActivatedExtensionIds);
         }
     }
-    async _doStopExtensionHostsWithVeto(reason) {
+    async _doStopExtensionHostsWithVeto(reason, auto) {
         const vetos = [];
         const vetoReasons = ( (new Set()));
         this._onWillStop.fire({
@@ -596,21 +585,23 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._doStopExtensionHosts();
         }
         else {
-            const vetoReasonsArray = Array.from(vetoReasons);
-            this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
-            await this._dialogService.warn(( localizeWithPath(_moduleId, 3, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
-                ( localizeWithPath(
-                    _moduleId,
-                    4,
-                    "The reason for blocking the operation: {0}",
-                    vetoReasonsArray[0]
-                )) :
-                ( localizeWithPath(
-                    _moduleId,
-                    5,
-                    "The reasons for blocking the operation:\n- {0}",
-                    vetoReasonsArray.join('\n -')
-                )));
+            if (!auto) {
+                const vetoReasonsArray = Array.from(vetoReasons);
+                this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
+                await this._dialogService.warn(( localizeWithPath(_moduleId, 3, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
+                    ( localizeWithPath(
+                        _moduleId,
+                        4,
+                        "The reason for blocking the operation: {0}",
+                        vetoReasonsArray[0]
+                    )) :
+                    ( localizeWithPath(
+                        _moduleId,
+                        5,
+                        "The reasons for blocking the operation:\n- {0}",
+                        vetoReasonsArray.join('\n -')
+                    )));
+            }
         }
         return !veto;
     }
@@ -624,12 +615,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         locations.push(( (new RemoteRunningLocation())));
         for (const location of locations) {
-            if (this._getExtensionHostManagerByRunningLocation(location)) {
+            if (this._extensionHostManagers.getByRunningLocation(location)) {
                 continue;
             }
-            const extHostManager = this._createExtensionHostManager(location, isInitialStart, initialActivationEvents);
-            if (extHostManager) {
-                this._extensionHostManagers.push(extHostManager);
+            const res = this._createExtensionHostManager(location, isInitialStart, initialActivationEvents);
+            if (res) {
+                const [extHostManager, disposableStore] = res;
+                this._extensionHostManagers.add(extHostManager, disposableStore);
             }
         }
     }
@@ -639,8 +631,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             return null;
         }
         const processManager = this._doCreateExtensionHostManager(extensionHost, initialActivationEvents);
-        processManager.onDidExit(([code, signal]) => this._onExtensionHostCrashOrExit(processManager, code, signal));
-        processManager.onDidChangeResponsiveState((responsiveState) => {
+        const disposableStore = ( (new DisposableStore()));
+        disposableStore.add(processManager.onDidExit(([code, signal]) => this._onExtensionHostCrashOrExit(processManager, code, signal)));
+        disposableStore.add(processManager.onDidChangeResponsiveState((responsiveState) => {
             this._logService.info(`Extension host (${processManager.friendyName}) is ${responsiveState === ResponsiveState.Responsive ? 'responsive' : 'unresponsive'}.`);
             this._onDidChangeResponsiveChange.fire({
                 extensionHostKind: processManager.kind,
@@ -649,8 +642,8 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                     return processManager.getInspectPort(tryEnableInspector);
                 }
             });
-        });
-        return processManager;
+        }));
+        return [processManager, disposableStore];
     }
     _doCreateExtensionHostManager(extensionHost, initialActivationEvents) {
         const internalExtensionService = this._acquireInternalAPI(extensionHost);
@@ -676,13 +669,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (signal) {
                 this._onRemoteExtensionHostCrashed(extensionHost, signal);
             }
-            for (let i = 0; i < this._extensionHostManagers.length; i++) {
-                if (this._extensionHostManagers[i] === extensionHost) {
-                    this._extensionHostManagers[i].dispose();
-                    this._extensionHostManagers.splice(i, 1);
-                    break;
-                }
-            }
+            this._extensionHostManagers.disposeOne(extensionHost);
         }
     }
     _getExtensionHostExitInfoWithTimeout(reconnectionToken) {
@@ -995,6 +982,71 @@ AbstractExtensionService = AbstractExtensionService_1 = ( (__decorate([
     ( (__param(18, IRemoteAuthorityResolverService))),
     ( (__param(19, IDialogService)))
 ], AbstractExtensionService)));
+class ExtensionHostCollection extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._extensionHostManagers = [];
+    }
+    dispose() {
+        this.disposeAllInReverse();
+        super.dispose();
+    }
+    add(extensionHostManager, disposableStore) {
+        this._extensionHostManagers.push(( (new ExtensionHostManagerData(extensionHostManager, disposableStore))));
+    }
+    disposeAllInReverse() {
+        for (let i = this._extensionHostManagers.length - 1; i >= 0; i--) {
+            this._extensionHostManagers[i].dispose();
+        }
+        this._extensionHostManagers = [];
+    }
+    disposeOne(extensionHostManager) {
+        const index = this._extensionHostManagers.findIndex(el => el.extensionHost === extensionHostManager);
+        if (index >= 0) {
+            this._extensionHostManagers.splice(index, 1);
+            extensionHostManager.dispose();
+        }
+    }
+    getByKind(kind) {
+        return this.filter(el => el.kind === kind);
+    }
+    getByRunningLocation(runningLocation) {
+        for (const el of this._extensionHostManagers) {
+            if (el.extensionHost.representsRunningLocation(runningLocation)) {
+                return el.extensionHost;
+            }
+        }
+        return null;
+    }
+    *[Symbol.iterator]() {
+        for (const extensionHostManager of this._extensionHostManagers) {
+            yield extensionHostManager.extensionHost;
+        }
+    }
+    map(callback) {
+        return (
+             (this._extensionHostManagers.map(el => callback(el.extensionHost)))
+        );
+    }
+    every(callback) {
+        return this._extensionHostManagers.every(el => callback(el.extensionHost));
+    }
+    filter(callback) {
+        return (
+             (this._extensionHostManagers.filter(el => callback(el.extensionHost)).map(el => el.extensionHost))
+        );
+    }
+}
+class ExtensionHostManagerData {
+    constructor(extensionHost, disposableStore) {
+        this.extensionHost = extensionHost;
+        this.disposableStore = disposableStore;
+    }
+    dispose() {
+        this.disposableStore.dispose();
+        this.extensionHost.dispose();
+    }
+}
 class ResolvedExtensions {
     constructor(local, remote, hasLocalProcess, allowRemoteExtensionsInLocalWebWorker) {
         this.local = local;