@codingame/monaco-vscode-extensions-service-override 2.0.3 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,9 +18,9 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.0.3",
+    "vscode": "npm:@codingame/monaco-vscode-api@2.1.0",
     "vscode-marked": "npm:marked@=3.0.2",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-files-service-override": "2.0.3"
+    "@codingame/monaco-vscode-files-service-override": "2.1.0"
   }
 }

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

@@ -1,134 +1,28 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { getAuthenticationProviderActivationEvent, addAccountUsage, readAllowedExtensions, readAccountUsages, removeAccountUsage } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
+import { getAuthenticationProviderActivationEvent, addAccountUsage } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
 import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
 import Severity from 'vscode/vscode/vs/base/common/severity';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { fromNow } from 'vscode/vscode/vs/base/common/date';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 class MainThreadAuthenticationProvider extends Disposable {
-    constructor(_proxy, id, label, supportsMultipleAccounts, notificationService, storageService, quickInputService, dialogService) {
+    constructor(_proxy, id, label, supportsMultipleAccounts, notificationService, onDidChangeSessionsEmitter) {
         super();
         this._proxy = _proxy;
         this.id = id;
         this.label = label;
         this.supportsMultipleAccounts = supportsMultipleAccounts;
         this.notificationService = notificationService;
-        this.storageService = storageService;
-        this.quickInputService = quickInputService;
-        this.dialogService = dialogService;
-    }
-    manageTrustedExtensions(accountName) {
-        const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
-        if (!allowedExtensions.length) {
-            this.dialogService.info(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadAuthentication',
-                'noTrustedExtensions',
-                "This account has not been used by any extensions."
-            )));
-            return;
-        }
-        const quickPick = this.quickInputService.createQuickPick();
-        quickPick.canSelectMany = true;
-        quickPick.customButton = true;
-        quickPick.customLabel = ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'manageTrustedExtensions.cancel',
-            'Cancel'
-        ));
-        const usages = readAccountUsages(this.storageService, this.id, accountName);
-        const items = ( allowedExtensions.map(extension => {
-            const usage = usages.find(usage => extension.id === usage.extensionId);
-            return {
-                label: extension.name,
-                description: usage
-                    ? ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadAuthentication',
-                    { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
-                    "Last used this account {0}",
-                    fromNow(usage.lastUsed, true)
-                ))
-                    : ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadAuthentication',
-                    'notUsed',
-                    "Has not used this account"
-                )),
-                extension
-            };
-        }));
-        quickPick.items = items;
-        quickPick.selectedItems = items.filter(item => item.extension.allowed === undefined || item.extension.allowed);
-        quickPick.title = ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'manageTrustedExtensions',
-            "Manage Trusted Extensions"
-        ));
-        quickPick.placeholder = ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadAuthentication',
-            'manageExtensions',
-            "Choose which extensions can access this account"
-        ));
-        quickPick.onDidAccept(() => {
-            const updatedAllowedList = ( quickPick.items
-                .map(i => i.extension));
-            this.storageService.store(`${this.id}-${accountName}`, JSON.stringify(updatedAllowedList), -1 , 0 );
-            quickPick.dispose();
-        });
-        quickPick.onDidChangeSelection((changed) => {
-            quickPick.items.forEach(item => {
-                if (item.extension) {
-                    item.extension.allowed = false;
-                }
-            });
-            changed.forEach((item) => item.extension.allowed = true);
-        });
-        quickPick.onDidHide(() => {
-            quickPick.dispose();
-        });
-        quickPick.onDidCustom(() => {
-            quickPick.hide();
-        });
-        quickPick.show();
-    }
-    async removeAccountSessions(accountName, sessions) {
-        const accountUsages = readAccountUsages(this.storageService, this.id, accountName);
-        const { confirmed } = await this.dialogService.confirm({
-            type: Severity.Info,
-            message: accountUsages.length
-                ? ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadAuthentication',
-                'signOutMessage',
-                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
-                accountName,
-                ( accountUsages.map(usage => usage.extensionName)).join('\n')
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadAuthentication',
-                'signOutMessageSimple',
-                "Sign out of '{0}'?",
-                accountName
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadAuthentication',
-                { key: 'signOut', comment: ['&& denotes a mnemonic'] },
-                "&&Sign Out"
-            ))
-        });
-        if (confirmed) {
-            const removeSessionPromises = ( sessions.map(session => this.removeSession(session.id)));
-            await Promise.all(removeSessionPromises);
-            removeAccountUsage(this.storageService, this.id, accountName);
-            this.storageService.remove(`${this.id}-${accountName}`, -1 );
-        }
+        this.onDidChangeSessions = onDidChangeSessionsEmitter.event;
     }
     async getSessions(scopes) {
         return this._proxy.$getSessions(this.id, scopes);
@@ -146,45 +40,47 @@ class MainThreadAuthenticationProvider extends Disposable {
     }
 }
 let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
-    constructor(extHostContext, authenticationService, dialogService, storageService, notificationService, quickInputService, extensionService, telemetryService) {
+    constructor(extHostContext, authenticationService, dialogService, storageService, notificationService, extensionService, telemetryService) {
         super();
         this.authenticationService = authenticationService;
         this.dialogService = dialogService;
         this.storageService = storageService;
         this.notificationService = notificationService;
-        this.quickInputService = quickInputService;
         this.extensionService = extensionService;
         this.telemetryService = telemetryService;
+        this._registrations = this._register(( new DisposableMap()));
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostAuthentication));
         this._register(this.authenticationService.onDidChangeSessions(e => {
             this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label);
         }));
-        this._proxy.$setProviders(this.authenticationService.declaredProviders);
-        this._register(this.authenticationService.onDidChangeDeclaredProviders(e => {
-            this._proxy.$setProviders(e);
-        }));
     }
     async $registerAuthenticationProvider(id, label, supportsMultipleAccounts) {
+        const emitter = ( new Emitter());
+        this._registrations.set(id, emitter);
         const provider = ( new MainThreadAuthenticationProvider(
             this._proxy,
             id,
             label,
             supportsMultipleAccounts,
             this.notificationService,
-            this.storageService,
-            this.quickInputService,
-            this.dialogService
+            emitter
         ));
         this.authenticationService.registerAuthenticationProvider(id, provider);
     }
     $unregisterAuthenticationProvider(id) {
+        this._registrations.deleteAndDispose(id);
         this.authenticationService.unregisterAuthenticationProvider(id);
     }
-    $ensureProvider(id) {
-        return this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), 1 );
+    async $ensureProvider(id) {
+        if (!this.authenticationService.isAuthenticationProviderRegistered(id)) {
+            return await this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), 1 );
+        }
     }
-    $sendDidChangeSessions(id, event) {
-        this.authenticationService.sessionsUpdate(id, event);
+    $sendDidChangeSessions(providerId, event) {
+        const obj = this._registrations.get(providerId);
+        if (obj instanceof Emitter) {
+            obj.fire(event);
+        }
     }
     $removeSession(providerId, sessionId) {
         return this.authenticationService.removeSession(providerId, sessionId);
@@ -324,9 +220,8 @@ MainThreadAuthentication = __decorate([
     ( __param(2, IDialogService)),
     ( __param(3, IStorageService)),
     ( __param(4, INotificationService)),
-    ( __param(5, IQuickInputService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, ITelemetryService))
+    ( __param(5, IExtensionService)),
+    ( __param(6, ITelemetryService))
 ], MainThreadAuthentication);
 
 export { MainThreadAuthentication, MainThreadAuthenticationProvider };

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

@@ -17,11 +17,6 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         this._providerRegistrations = this._register(( new DisposableMap()));
         this._stateEmitters = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChat));
-        this._register(this._chatService.onDidPerformUserAction(e => {
-            if (!e.agentId) {
-                this._proxy.$onDidPerformUserAction(e);
-            }
-        }));
     }
     $transferChatSession(sessionId, toWorkspace) {
         const sessionIdStr = this._chatService.getSessionId(sessionId);

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

@@ -1,5 +1,4 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
 import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { revive } from 'vscode/vscode/vs/base/common/marshalling';
 import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
@@ -28,8 +27,6 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._agents = this._register(( new DisposableMap()));
         this._agentCompletionProviders = this._register(( new DisposableMap()));
         this._pendingProgress = ( new Map());
-        this._responsePartHandlePool = 0;
-        this._activeResponsePartPromises = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
         this._register(this._chatService.onDidDisposeSession(e => {
             this._proxy.$releaseSession(e.sessionId);
@@ -60,7 +57,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             invoke: async (request, progress, history, token) => {
                 this._pendingProgress.set(request.requestId, progress);
                 try {
-                    return (await this._proxy.$invokeAgent(handle, request.sessionId, request.requestId, request, { history }, token)) ?? {};
+                    return (await this._proxy.$invokeAgent(handle, request, { history }, token)) ?? {};
                 }
                 finally {
                     this._pendingProgress.delete(request.requestId);
@@ -95,32 +92,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         data.hasFollowups = metadataUpdate.hasFollowups;
         this._chatAgentService.updateAgent(data.name, revive(metadataUpdate));
     }
-    async $handleProgressChunk(requestId, progress, responsePartHandle) {
-        if (progress.kind === 'asyncContent') {
-            const handle = ++this._responsePartHandlePool;
-            const responsePartId = `${requestId}_${handle}`;
-            const deferredContentPromise = ( new DeferredPromise());
-            this._activeResponsePartPromises.set(responsePartId, deferredContentPromise);
-            this._pendingProgress.get(requestId)?.({ ...progress, resolvedContent: deferredContentPromise.p });
-            return handle;
-        }
-        else if (typeof responsePartHandle === 'number') {
-            const responsePartId = `${requestId}_${responsePartHandle}`;
-            const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
-            if (deferredContentPromise && progress.kind === 'treeData') {
-                const withRevivedUris = revive(progress);
-                deferredContentPromise.complete(withRevivedUris);
-                this._activeResponsePartPromises.delete(responsePartId);
-            }
-            else if (deferredContentPromise && progress.kind === 'content') {
-                deferredContentPromise.complete(progress.content);
-                this._activeResponsePartPromises.delete(responsePartId);
-            }
-            return responsePartHandle;
-        }
-        if (progress.kind === 'treeData') {
-            return;
-        }
+    async $handleProgressChunk(requestId, progress) {
         const revivedProgress = revive(progress);
         this._pendingProgress.get(requestId)?.(revivedProgress);
     }
@@ -165,7 +137,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                         kind: 18 ,
                         detail: v.detail,
                         documentation: v.documentation,
-                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: v.values }] }
+                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: revive(v.values) }] }
                     };
                 }));
                 return {

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

@@ -9,13 +9,14 @@ import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/bro
 import { CommentsPanel } from '../../contrib/comments/browser/commentsView.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from '../../contrib/comments/browser/commentsTreeViewer.js';
-import { IViewsService, IViewDescriptorService, Extensions } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService, Extensions } from 'vscode/vscode/vs/workbench/common/views';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 
 class MainThreadCommentThread {
     get input() {

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

@@ -1,19 +1,23 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { DisposableStore, DisposableMap, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IDebugService, IDebugVisualization } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import Severity from 'vscode/vscode/vs/base/common/severity';
 import { AbstractDebugAdapter } from 'vscode/vscode/vs/workbench/contrib/debug/common/abstractDebugAdapter';
 import { isSessionAttach, convertToVSCPaths, convertToDAPaths } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
+import { IDebugVisualizerService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugVisualizers';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 
 let MainThreadDebugService = class MainThreadDebugService {
-    constructor(extHostContext, debugService) {
+    constructor(extHostContext, debugService, visualizerService) {
         this.debugService = debugService;
+        this.visualizerService = visualizerService;
         this._toDispose = ( new DisposableStore());
         this._debugAdaptersHandleCounter = 1;
+        this._visualizerHandles = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
         const sessionListeners = ( new DisposableMap());
         this._toDispose.add(sessionListeners);
@@ -32,15 +36,17 @@ let MainThreadDebugService = class MainThreadDebugService {
             }
             store.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
         }));
-        this._toDispose.add(debugService.onDidEndSession(session => {
+        this._toDispose.add(debugService.onDidEndSession(({ session, restart }) => {
             this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
-            this._sessions.delete(session.getId());
+            this._extHostKnownSessions.delete(session.getId());
+            if (!restart) {
+                sessionListeners.deleteAndDispose(session);
+            }
             for (const [handle, value] of this._debugAdapters) {
                 if (value.session === session) {
                     this._debugAdapters.delete(handle);
                 }
             }
-            sessionListeners.deleteAndDispose(session);
         }));
         this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
             this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
@@ -53,7 +59,7 @@ let MainThreadDebugService = class MainThreadDebugService {
         this._debugAdapters = ( new Map());
         this._debugConfigurationProviders = ( new Map());
         this._debugAdapterDescriptorFactories = ( new Map());
-        this._sessions = ( new Set());
+        this._extHostKnownSessions = ( new Set());
         this._toDispose.add(this.debugService.getViewModel().onDidFocusThread(({ thread, explicit, session }) => {
             if (session) {
                 const dto = {
@@ -77,6 +83,22 @@ let MainThreadDebugService = class MainThreadDebugService {
         }));
         this.sendBreakpointsAndListen();
     }
+    $registerDebugVisualizer(extensionId, id) {
+        const handle = this.visualizerService.register({
+            extensionId: ( new ExtensionIdentifier(extensionId)),
+            id,
+            disposeDebugVisualizers: ids => this._proxy.$disposeDebugVisualizers(ids),
+            executeDebugVisualizerCommand: id => this._proxy.$executeDebugVisualizerCommand(id),
+            provideDebugVisualizers: (context, token) => this._proxy.$provideDebugVisualizers(extensionId, id, context, token).then(r => ( r.map(IDebugVisualization.deserialize))),
+            resolveDebugVisualizer: (viz, token) => this._proxy.$resolveDebugVisualizer(viz.id, token),
+        });
+        this._visualizerHandles.set(`${extensionId}/${id}`, handle);
+    }
+    $unregisterDebugVisualizer(extensionId, id) {
+        const key = `${extensionId}/${id}`;
+        this._visualizerHandles.get(key)?.dispose();
+        this._visualizerHandles.delete(key);
+    }
     sendBreakpointsAndListen() {
         this._toDispose.add(this.debugService.getModel().onDidChangeBreakpoints(e => {
             if (e && !e.sessionOnly) {
@@ -288,12 +310,12 @@ let MainThreadDebugService = class MainThreadDebugService {
         return adapter;
     }
     $sessionCached(sessionID) {
-        this._sessions.add(sessionID);
+        this._extHostKnownSessions.add(sessionID);
     }
     getSessionDto(session) {
         if (session) {
             const sessionID = session.getId();
-            if (( this._sessions.has(sessionID))) {
+            if (( this._extHostKnownSessions.has(sessionID))) {
                 return sessionID;
             }
             else {
@@ -356,7 +378,8 @@ let MainThreadDebugService = class MainThreadDebugService {
 };
 MainThreadDebugService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadDebugService),
-    ( __param(1, IDebugService))
+    ( __param(1, IDebugService)),
+    ( __param(2, IDebugVisualizerService))
 ], MainThreadDebugService);
 class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
     constructor(_ds, _handle, _proxy, session) {

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

@@ -44,7 +44,7 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
     $unregisterTextContentProvider(handle) {
         this._resourceContentProvider.deleteAndDispose(handle);
     }
-    $onVirtualDocumentChange(uri, value) {
+    async $onVirtualDocumentChange(uri, value) {
         const model = this._modelService.getModel(URI.revive(uri));
         if (!model) {
             return;
@@ -53,7 +53,8 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
         pending?.cancel();
         const myToken = ( new CancellationTokenSource());
         this._pendingUpdate.set(model.id, myToken);
-        this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]).then(edits => {
+        try {
+            const edits = await this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]);
             this._pendingUpdate.delete(model.id);
             if (myToken.token.isCancellationRequested) {
                 return;
@@ -61,7 +62,10 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
             if (edits && edits.length > 0) {
                 model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
             }
-        }).catch(onUnexpectedError);
+        }
+        catch (error) {
+            onUnexpectedError(error);
+        }
     }
 };
 MainThreadDocumentContentProviders = __decorate([

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

@@ -59,6 +59,7 @@ class MainThreadTextEditorProperties {
             insertSpaces: modelOptions.insertSpaces,
             tabSize: modelOptions.tabSize,
             indentSize: modelOptions.indentSize,
+            originalIndentSize: modelOptions.originalIndentSize,
             cursorStyle: cursorStyle,
             lineNumbers: lineNumbers
         };
@@ -396,10 +397,9 @@ class MainThreadTextEditor {
         if (!snippetController) {
             return false;
         }
-        const selections = ( ranges.map(r => ( new Selection(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn))));
-        this._codeEditor.setSelections(selections);
         this._codeEditor.focus();
-        snippetController.insert(template, {
+        const edits = ( ranges.map(range => ({ range: Range.lift(range), template })));
+        snippetController.apply(edits, {
             overwriteBefore: 0, overwriteAfter: 0,
             undoStopBefore: opts.undoStopBefore, undoStopAfter: opts.undoStopAfter,
             clipboardText

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

@@ -43,7 +43,7 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
         }));
         this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));
         this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
-        this._editorGroupsService.mainPart.whenReady.then(() => this._createTabsModel());
+        this._editorGroupsService.whenReady.then(() => this._createTabsModel());
     }
     dispose() {
         this._groupLookup.clear();

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

@@ -203,7 +203,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                             checkbox: { label: ( localizeWithPath(
                                 'vs/workbench/api/browser/mainThreadFileSystemEventService',
                                 'again',
-                                "Don't ask again"
+                                "Do not ask me again"
                             )) }
                         });
                         if (result === Choice.Cancel) {

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

@@ -9,7 +9,8 @@ let MainThreadIssueReporter = class MainThreadIssueReporter extends Disposable {
     constructor(context, _issueService) {
         super();
         this._issueService = _issueService;
-        this._registrations = this._register(( new DisposableMap()));
+        this._registrationsUri = this._register(( new DisposableMap()));
+        this._registrationsData = this._register(( new DisposableMap()));
         this._proxy = ( context.getProxy(ExtHostContext.ExtHostIssueReporter));
     }
     $registerIssueUriRequestHandler(extensionId) {
@@ -19,10 +20,10 @@ let MainThreadIssueReporter = class MainThreadIssueReporter extends Disposable {
                 return ( URI.from(parts));
             }
         };
-        this._registrations.set(extensionId, this._issueService.registerIssueUriRequestHandler(extensionId, handler));
+        this._registrationsUri.set(extensionId, this._issueService.registerIssueUriRequestHandler(extensionId, handler));
     }
     $unregisterIssueUriRequestHandler(extensionId) {
-        this._registrations.deleteAndDispose(extensionId);
+        this._registrationsUri.deleteAndDispose(extensionId);
     }
     $registerIssueDataProvider(extensionId) {
         const provider = {
@@ -35,10 +36,10 @@ let MainThreadIssueReporter = class MainThreadIssueReporter extends Disposable {
                 return parts;
             }
         };
-        this._registrations.set(extensionId, this._issueService.registerIssueDataProvider(extensionId, provider));
+        this._registrationsData.set(extensionId, this._issueService.registerIssueDataProvider(extensionId, provider));
     }
     $unregisterIssueDataProvider(extensionId) {
-        this._registrations.deleteAndDispose(extensionId);
+        this._registrationsData.deleteAndDispose(extensionId);
     }
 };
 MainThreadIssueReporter = __decorate([

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

@@ -552,7 +552,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                 return {
                     ...hint,
                     tooltip: result.tooltip,
-                    label: revive(result.label)
+                    label: revive(result.label),
+                    textEdits: result.textEdits
                 };
             };
         }
@@ -828,7 +829,7 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
             };
         }
         if (metadata.supportsPaste) {
-            this.provideDocumentPasteEdits = async (model, selections, dataTransfer, token) => {
+            this.provideDocumentPasteEdits = async (model, selections, dataTransfer, context, token) => {
                 const request = this.dataTransfers.add(dataTransfer);
                 try {
                     const dataTransferDto = await DataTransfer.from(dataTransfer);

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

@@ -6,14 +6,21 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 let MainThreadMessageService = class MainThreadMessageService {
-    constructor(extHostContext, _notificationService, _dialogService) {
+    constructor(extHostContext, _notificationService, _dialogService, extensionService) {
         this._notificationService = _notificationService;
         this._dialogService = _dialogService;
+        this.extensionsListener = extensionService.onDidChangeExtensions(e => {
+            for (const extension of e.removed) {
+                this._notificationService.removeFilter(extension.identifier.value);
+            }
+        });
     }
     dispose() {
+        this.extensionsListener.dispose();
     }
     $showMessage(severity, message, options, commands) {
         if (options.modal) {
@@ -37,12 +44,7 @@ let MainThreadMessageService = class MainThreadMessageService {
             let source;
             if (options.source) {
                 source = {
-                    label: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadMessageService',
-                        'extensionSource',
-                        "{0} (Extension)",
-                        options.source.label
-                    )),
+                    label: options.source.label,
                     id: options.source.identifier.value
                 };
             }
@@ -112,7 +114,8 @@ let MainThreadMessageService = class MainThreadMessageService {
 MainThreadMessageService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadMessageService),
     ( __param(1, INotificationService)),
-    ( __param(2, IDialogService))
+    ( __param(2, IDialogService)),
+    ( __param(3, IExtensionService))
 ], MainThreadMessageService);
 
 export { MainThreadMessageService };

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

@@ -184,14 +184,14 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
             async cancelNotebookCellExecution(uri, handles) {
                 await that._proxy.$cancelCells(handle, uri, handles);
             }
-            provideVariables(notebookUri, parentName, kind, start, token) {
+            provideVariables(notebookUri, parentId, kind, start, token) {
                 const requestId = `${handle}variables${that.variableRequestIndex++}`;
                 if (( that.variableRequestMap.has(requestId))) {
                     return that.variableRequestMap.get(requestId).asyncIterable;
                 }
                 const source = ( new AsyncIterableSource());
                 that.variableRequestMap.set(requestId, source);
-                that._proxy.$provideVariables(handle, requestId, notebookUri, parentName, kind, start, token).then(() => {
+                that._proxy.$provideVariables(handle, requestId, notebookUri, parentId, kind, start, token).then(() => {
                     source.resolve();
                     that.variableRequestMap.delete(requestId);
                 }).catch((err) => {

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

@@ -6,7 +6,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Event } from 'vscode/vscode/vs/base/common/event';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { isNumber } from 'vscode/vscode/vs/base/common/types';
 
 var MainThreadOutputService_1;