@codingame/monaco-vscode-extensions-service-override 4.5.1 → 5.0.0

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

@@ -18,6 +18,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadExtensionService";
 let MainThreadExtensionService = class MainThreadExtensionService {
     constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
         this._extensionService = _extensionService;
@@ -31,8 +32,10 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._extensionHostKind = extHostContext.extensionHostKind;
         const internalExtHostContext = extHostContext;
         this._internalExtensionService = internalExtHostContext.internalExtensionService;
-        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
+        internalExtHostContext._setExtensionHostProxy(( (new ExtensionHostProxy(
+             (extHostContext.getProxy(ExtHostContext.ExtHostExtensionService))
+        ))));
+        internalExtHostContext._setAllMainProxyIdentifiers(( (( (Object.keys(MainContext))).map((key) => MainContext[key]))));
     }
     dispose() {
     }
@@ -49,7 +52,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
     }
     $onExtensionRuntimeError(extensionId, data) {
-        const error = ( new Error());
+        const error = ( (new Error()));
         error.name = data.name;
         error.message = data.message;
         error.stack = data.stack;
@@ -58,7 +61,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         console.error(error.stack);
     }
     async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
-        const error = ( new Error());
+        const error = ( (new Error()));
         error.name = data.name;
         error.message = data.message;
         error.stack = data.stack;
@@ -91,18 +94,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'reload window',
+                    _moduleId,
+                    0,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                 )),
                 actions: {
-                    primary: [( new Action('reload', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'reload',
-                        "Reload Window"
-                    )), '', true, () => this._hostService.reload()))]
+                    primary: [( (new Action('reload', ( localizeWithPath(_moduleId, 1, "Reload Window")), '', true, () => this._hostService.reload())))]
                 }
             });
         }
@@ -112,8 +111,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'notSupportedInWorkspace',
+                        _moduleId,
+                        2,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -124,18 +123,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'restrictedMode',
+                        _moduleId,
+                        3,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( new Action('manageWorkspaceTrust', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'manageWorkspaceTrust',
-                            "Manage Workspace Trust"
-                        )), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
+                        primary: [( (new Action('manageWorkspaceTrust', ( localizeWithPath(_moduleId, 4, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage'))))]
                     }
                 });
             }
@@ -143,19 +138,15 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDep',
+                        _moduleId,
+                        5,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( new Action('enable', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'enable dep',
-                            "Enable and Reload"
-                        )), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                        primary: [( (new Action('enable', ( localizeWithPath(_moduleId, 6, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
+                                .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                     }
                 });
             }
@@ -163,8 +154,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDepNoAction',
+                        _moduleId,
+                        7,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -185,27 +176,23 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'uninstalledDep',
+                    _moduleId,
+                    8,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
                     dependencyExtension.publisherDisplayName
                 )),
                 actions: {
-                    primary: [( new Action('install', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'install missing dep',
-                        "Install and Reload"
-                    )), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
-                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                    primary: [( (new Action('install', ( localizeWithPath(_moduleId, 9, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
+                            .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                 }
             });
         }
         else {
             this._notificationService.error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadExtensionService',
-                'unknownDep',
+                _moduleId,
+                10,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency
@@ -235,14 +222,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
 };
 MainThreadExtensionService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadExtensionService),
-    ( __param(1, IExtensionService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, ITimerService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, IWorkbenchEnvironmentService))
+    ( (__param(1, IExtensionService))),
+    ( (__param(2, INotificationService))),
+    ( (__param(3, IExtensionsWorkbenchService))),
+    ( (__param(4, IHostService))),
+    ( (__param(5, IWorkbenchExtensionEnablementService))),
+    ( (__param(6, ITimerService))),
+    ( (__param(7, ICommandService))),
+    ( (__param(8, IWorkbenchEnvironmentService)))
 ], MainThreadExtensionService);
 class ExtensionHostProxy {
     constructor(_actual) {
@@ -309,9 +296,13 @@ function reviveResolvedAuthority(resolvedAuthority) {
 }
 function reviveConnection(connection) {
     if (connection.type === 0 ) {
-        return ( new WebSocketRemoteConnection(connection.host, connection.port));
+        return (
+             (new WebSocketRemoteConnection(connection.host, connection.port))
+        );
     }
-    return ( new ManagedRemoteConnection(connection.id));
+    return (
+         (new ManagedRemoteConnection(connection.id))
+    );
 }
 
 export { MainThreadExtensionService };

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

@@ -42,7 +42,7 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     $onFileSystemChange(handle, changes) {
         const fileProvider = this._fileProvider.get(handle);
         if (!fileProvider) {
-            throw new Error('Unknown file provider');
+            throw ( new Error('Unknown file provider'));
         }
         fileProvider.$onFileSystemChange(changes);
     }

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

@@ -25,6 +25,7 @@ import { normalizeWatcherPattern } from 'vscode/vscode/vs/platform/files/common/
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 
 var MainThreadFileSystemEventService_1;
+const _moduleId = "vs/workbench/api/browser/mainThreadFileSystemEventService";
 let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
     static { MainThreadFileSystemEventService_1 = this; }
     static { this.MementoKeyAdditionalEdits = `file.particpants.additionalEdits`; }
@@ -33,9 +34,9 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
         this._contextService = _contextService;
         this._logService = _logService;
         this._configurationService = _configurationService;
-        this._listener = ( new DisposableStore());
-        this._watches = ( new DisposableMap());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
+        this._listener = ( (new DisposableStore()));
+        this._watches = ( (new DisposableMap()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService)));
         this._listener.add(_fileService.onDidFilesChange(event => {
             this._proxy.$onFileEvent({
                 created: event.rawAdded,
@@ -49,7 +50,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (undoInfo?.isUndoing) {
                     return;
                 }
-                const cts = ( new CancellationTokenSource(token));
+                const cts = ( (new CancellationTokenSource(token)));
                 const timer = setTimeout(() => cts.cancel(), timeout);
                 const data = await progressService.withProgress({
                     location: 15 ,
@@ -68,7 +69,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (!data || data.edit.edits.length === 0) {
                     return;
                 }
-                const needsConfirmation = ( data.edit.edits.some(edit => edit.metadata?.needsConfirmation));
+                const needsConfirmation = ( (data.edit.edits.some(edit => edit.metadata?.needsConfirmation)));
                 let showPreview = storageService.getBoolean(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, 0 );
                 if (envService.extensionTestsLocationURI) {
                     showPreview = false;
@@ -78,32 +79,32 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     if (data.extensionNames.length === 1) {
                         if (operation === 0 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.create',
+                                _moduleId,
+                                0,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === 3 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.copy',
+                                _moduleId,
+                                1,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === 2 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.move',
+                                _moduleId,
+                                2,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         }
                         else  {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.delete',
+                                _moduleId,
+                                3,
                                 "Extension '{0}' wants to make refactoring changes with this file deletion",
                                 data.extensionNames[0]
                             ));
@@ -112,32 +113,32 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     else {
                         if (operation === 0 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.create', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                4,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === 3 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.copy', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                5,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === 2 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.move', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                6,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         }
                         else  {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.delete', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                7,
                                 "{0} extensions want to make refactoring changes with this file deletion",
                                 data.extensionNames.length
                             ));
@@ -147,16 +148,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                         const { confirmed } = await dialogService.confirm({
                             type: Severity$1.Info,
                             message,
-                            primaryButton: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'preview',
-                                "Show &&Preview"
-                            )),
-                            cancelButton: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'cancel',
-                                "Skip Changes"
-                            ))
+                            primaryButton: ( localizeWithPath(_moduleId, 8, "Show &&Preview")),
+                            cancelButton: ( localizeWithPath(_moduleId, 9, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -165,45 +158,29 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                     else {
                         let Choice;
-                        ( (function(Choice) {
+                        ( ((function(Choice) {
                             Choice[Choice["OK"] = 0] = "OK";
                             Choice[Choice["Preview"] = 1] = "Preview";
                             Choice[Choice["Cancel"] = 2] = "Cancel";
-                        })(Choice || (Choice = {})));
+                        })(Choice || (Choice = {}))));
                         const { result, checkboxChecked } = await dialogService.prompt({
                             type: Severity$1.Info,
                             message,
                             buttons: [
                                 {
-                                    label: ( localizeWithPath(
-                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
-                                        "&&OK"
-                                    )),
+                                    label: ( localizeWithPath(_moduleId, 10, "&&OK")),
                                     run: () => Choice.OK
                                 },
                                 {
-                                    label: ( localizeWithPath(
-                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                        { key: 'preview', comment: ['&& denotes a mnemonic'] },
-                                        "Show &&Preview"
-                                    )),
+                                    label: ( localizeWithPath(_moduleId, 8, "Show &&Preview")),
                                     run: () => Choice.Preview
                                 }
                             ],
                             cancelButton: {
-                                label: ( localizeWithPath(
-                                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                    'cancel',
-                                    "Skip Changes"
-                                )),
+                                label: ( localizeWithPath(_moduleId, 9, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
-                            checkbox: { label: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'again',
-                                "Do not ask me again"
-                            )) }
+                            checkbox: { label: ( localizeWithPath(_moduleId, 11, "Do not ask me again")) }
                         });
                         if (result === Choice.Cancel) {
                             return;
@@ -220,35 +197,15 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             _progressLabel(operation) {
                 switch (operation) {
                     case 0 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-create',
-                            "Running 'File Create' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 12, "Running 'File Create' participants..."));
                     case 2 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-rename',
-                            "Running 'File Rename' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 13, "Running 'File Rename' participants..."));
                     case 3 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-copy',
-                            "Running 'File Copy' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 14, "Running 'File Copy' participants..."));
                     case 1 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-delete',
-                            "Running 'File Delete' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 15, "Running 'File Delete' participants..."));
                     case 4 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-write',
-                            "Running 'File Write' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 16, "Running 'File Write' participants..."));
                 }
             }
         });
@@ -271,8 +228,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             }
         }
         if (correlate) {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-            const watcherDisposables = ( new DisposableStore());
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+            const watcherDisposables = ( (new DisposableStore()));
             const subscription = watcherDisposables.add(this._fileService.createWatcher(uri, opts));
             watcherDisposables.add(subscription.onDidChange(event => {
                 this._proxy.$onFileEvent({
@@ -285,7 +242,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             this._watches.set(session, watcherDisposables);
         }
         else {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
             const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
             if (opts.recursive && opts.excludes.length === 0) {
                 const config = this._configurationService.getValue();
@@ -311,7 +268,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                 }
                 if (!opts.includes || opts.includes.length === 0) {
-                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
                     return;
                 }
             }
@@ -320,7 +277,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
         }
     }
     $unwatch(session) {
-        if (( this._watches.has(session))) {
+        if (( (this._watches.has(session)))) {
             this._logService.trace(`MainThreadFileSystemEventService#$unwatch(): request to stop watching (session: ${session})`);
             this._watches.deleteAndDispose(session);
         }
@@ -332,29 +289,25 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
 };
 MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadFileSystemEventService),
-    ( __param(1, IFileService)),
-    ( __param(2, IWorkingCopyFileService)),
-    ( __param(3, IBulkEditService)),
-    ( __param(4, IProgressService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IEnvironmentService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IWorkspaceContextService)),
-    ( __param(11, ILogService)),
-    ( __param(12, IConfigurationService))
+    ( (__param(1, IFileService))),
+    ( (__param(2, IWorkingCopyFileService))),
+    ( (__param(3, IBulkEditService))),
+    ( (__param(4, IProgressService))),
+    ( (__param(5, IDialogService))),
+    ( (__param(6, IStorageService))),
+    ( (__param(7, ILogService))),
+    ( (__param(8, IEnvironmentService))),
+    ( (__param(9, IUriIdentityService))),
+    ( (__param(10, IWorkspaceContextService))),
+    ( (__param(11, ILogService))),
+    ( (__param(12, IConfigurationService)))
 ], MainThreadFileSystemEventService);
 registerAction2(class ResetMemento extends Action2 {
     constructor() {
         super({
             id: 'files.participants.resetChoice',
             title: {
-                value: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                    'label',
-                    "Reset choice for 'File operation needs preview'"
-                )),
+                value: ( localizeWithPath(_moduleId, 17, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -1,8 +1,11 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { isFalsyOrEmpty } from 'vscode/vscode/vs/base/common/arrays';
 import { VSDataTransfer, createStringDataTransferItem } from 'vscode/vscode/vs/base/common/dataTransfer';
 import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { HierarchicalKind } from 'vscode/vscode/vs/base/common/hierarchicalKind';
 import { Disposable, DisposableMap, combinedDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
 import { revive } from 'vscode/vscode/vs/base/common/marshalling';
 import { mixin } from 'vscode/vscode/vs/base/common/objects';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -19,9 +22,6 @@ import { WorkspaceSymbolProviderRegistry } from 'vscode/vscode/vs/workbench/cont
 import { TypeHierarchyProviderRegistry } from 'vscode/vscode/vs/workbench/contrib/typeHierarchy/common/typeHierarchy';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { isFalsyOrEmpty } from 'vscode/vscode/vs/base/common/arrays';
-import { HierarchicalKind } from 'vscode/vscode/vs/base/common/hierarchicalKind';
 
 var MainThreadLanguageFeatures_1;
 let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThreadLanguageFeatures extends Disposable {
@@ -202,8 +202,15 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $registerHoverProvider(handle, selector) {
         this._registrations.set(handle, this._languageFeaturesService.hoverProvider.register(selector, {
-            provideHover: (model, position, token) => {
-                return this._proxy.$provideHover(handle, model.uri, position, token);
+            provideHover: async (model, position, token, context) => {
+                const serializedContext = {
+                    verbosityRequest: context?.verbosityRequest ? {
+                        action: context.verbosityRequest.action,
+                        previousHover: { id: context.verbosityRequest.previousHover.id }
+                    } : undefined,
+                };
+                const hover = await this._proxy.$provideHover(handle, model.uri, position, serializedContext, token);
+                return hover;
             }
         }));
     }
@@ -326,7 +333,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     $resolvePasteFileData(handle, requestId, dataId) {
         const provider = this._pasteEditProviders.get(handle);
         if (!provider) {
-            throw new Error('Could not find provider');
+            throw ( new Error('Could not find provider'));
         }
         return provider.resolveFileData(requestId, dataId);
     }
@@ -394,8 +401,9 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $registerNewSymbolNamesProvider(handle, selector) {
         this._registrations.set(handle, this._languageFeaturesService.newSymbolNamesProvider.register(selector, {
-            provideNewSymbolNames: (model, range, token) => {
-                return this._proxy.$provideNewSymbolNames(handle, model.uri, range, token);
+            supportsAutomaticNewSymbolNamesTriggerKind: this._proxy.$supportsAutomaticNewSymbolNamesTriggerKind(handle),
+            provideNewSymbolNames: (model, range, triggerKind, token) => {
+                return this._proxy.$provideNewSymbolNames(handle, model.uri, range, triggerKind, token);
             }
         }));
     }
@@ -563,7 +571,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                 }
                 const result = await this._proxy.$resolveInlayHint(handle, dto.cacheId, token);
                 if (token.isCancellationRequested) {
-                    throw new CancellationError();
+                    throw ( new CancellationError());
                 }
                 if (!result) {
                     return hint;
@@ -800,12 +808,12 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     $registerDocumentOnDropEditProvider(handle, selector, metadata) {
         const provider = ( new MainThreadDocumentOnDropEditProvider(handle, this._proxy, metadata, this._uriIdentService));
         this._documentOnDropEditProviders.set(handle, provider);
-        this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentOnDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
+        this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
     }
     async $resolveDocumentOnDropFileData(handle, requestId, dataId) {
         const provider = this._documentOnDropEditProviders.get(handle);
         if (!provider) {
-            throw new Error('Could not find provider');
+            throw ( new Error('Could not find provider'));
         }
         return provider.resolveDocumentOnDropFileData(requestId, dataId);
     }
@@ -905,8 +913,17 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
         this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( new DataTransferFileCache());
         this.dropMimeTypes = metadata?.dropMimeTypes ?? ['*/*'];
+        if (metadata?.supportsResolve) {
+            this.resolveDocumentDropEdit = async (edit, token) => {
+                const resolved = await this._proxy.$resolvePasteEdit(this._handle, edit._cacheId, token);
+                if (resolved.additionalEdit) {
+                    edit.additionalEdit = reviveWorkspaceEditDto(resolved.additionalEdit, this._uriIdentService);
+                }
+                return edit;
+            };
+        }
     }
-    async provideDocumentOnDropEdits(model, position, dataTransfer, token) {
+    async provideDocumentDropEdits(model, position, dataTransfer, token) {
         const request = this.dataTransfers.add(dataTransfer);
         try {
             const dataTransferDto = await DataTransfer.from(dataTransfer);
@@ -998,7 +1015,7 @@ class MainThreadDocumentRangeSemanticTokensProvider {
                 data: dto.data
             };
         }
-        throw new Error(`Unexpected`);
+        throw ( new Error(`Unexpected`));
     }
 }
 class MainThreadMappedEditsProvider {