@codingame/monaco-vscode-debug-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/debug/browser/debugMemory.js

@@ -17,10 +17,12 @@ class DebugMemoryFileSystemProvider extends Disposable {
         this.changeEmitter = ( new Emitter());
         this.onDidChangeCapabilities = Event.None;
         this.onDidChangeFile = this.changeEmitter.event;
-        this.capabilities = 0
-            | FileSystemProviderCapabilities.PathCaseSensitive
-            | FileSystemProviderCapabilities.FileOpenReadWriteClose;
-        this._register(debugService.onDidEndSession(({ session }) => {
+        this.capabilities = 0 | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileOpenReadWriteClose;
+        this._register(debugService.onDidEndSession((
+            {
+                session
+            }
+        ) => {
             for (const [fd, memory] of this.fdMemory) {
                 if (memory.session === session) {
                     this.close(fd);
@@ -30,13 +32,20 @@ class DebugMemoryFileSystemProvider extends Disposable {
     }
     watch(resource, opts) {
         if (opts.recursive) {
-            return toDisposable(() => { });
+            return toDisposable(() => {});
         }
-        const { session, memoryReference, offset } = this.parseUri(resource);
+        const {
+            session,
+            memoryReference,
+            offset
+        } = this.parseUri(resource);
         const disposable = ( new DisposableStore());
         disposable.add(session.onDidChangeState(() => {
             if (session.state === State.Running || session.state === State.Inactive) {
-                this.changeEmitter.fire([{ type: FileChangeType.DELETED, resource }]);
+                this.changeEmitter.fire([{
+                    type: FileChangeType.DELETED,
+                    resource
+                }]);
             }
         }));
         disposable.add(session.onDidInvalidateMemory(e => {
@@ -46,18 +55,23 @@ class DebugMemoryFileSystemProvider extends Disposable {
             if (offset && (e.body.offset >= offset.toOffset || e.body.offset + e.body.count < offset.fromOffset)) {
                 return;
             }
-            this.changeEmitter.fire([{ resource, type: FileChangeType.UPDATED }]);
+            this.changeEmitter.fire([{
+                resource,
+                type: FileChangeType.UPDATED
+            }]);
         }));
         return disposable;
     }
     stat(file) {
-        const { readOnly } = this.parseUri(file);
+        const {
+            readOnly
+        } = this.parseUri(file);
         return Promise.resolve({
             type: FileType.File,
             mtime: 0,
             ctime: 0,
             size: 0,
-            permissions: readOnly ? FilePermission.Readonly : undefined,
+            permissions: readOnly ? FilePermission.Readonly : undefined
         });
     }
     mkdir() {
@@ -73,13 +87,20 @@ class DebugMemoryFileSystemProvider extends Disposable {
         throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
     }
     open(resource, _opts) {
-        const { session, memoryReference, offset } = this.parseUri(resource);
+        const {
+            session,
+            memoryReference,
+            offset
+        } = this.parseUri(resource);
         const fd = this.memoryFdCounter++;
         let region = session.getMemory(memoryReference);
         if (offset) {
             region = ( new MemoryRegionView(region, offset));
         }
-        this.fdMemory.set(fd, { session, region });
+        this.fdMemory.set(fd, {
+            session,
+            region
+        });
         return Promise.resolve(fd);
     }
     close(fd) {
@@ -88,60 +109,75 @@ class DebugMemoryFileSystemProvider extends Disposable {
         return Promise.resolve();
     }
     async writeFile(resource, content) {
-        const { offset } = this.parseUri(resource);
+        const {
+            offset
+        } = this.parseUri(resource);
         if (!offset) {
-            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
+            throw createFileSystemProviderError(
+                `Range must be present to read a file`,
+                FileSystemProviderErrorCode.FileNotFound
+            );
         }
-        const fd = await this.open(resource, { create: false });
+        const fd = await this.open(resource, {
+            create: false
+        });
         try {
             await this.write(fd, offset.fromOffset, content, 0, content.length);
-        }
-        finally {
+        } finally {
             this.close(fd);
         }
     }
     async readFile(resource) {
-        const { offset } = this.parseUri(resource);
+        const {
+            offset
+        } = this.parseUri(resource);
         if (!offset) {
-            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
+            throw createFileSystemProviderError(
+                `Range must be present to read a file`,
+                FileSystemProviderErrorCode.FileNotFound
+            );
         }
         const data = ( new Uint8Array(offset.toOffset - offset.fromOffset));
-        const fd = await this.open(resource, { create: false });
+        const fd = await this.open(resource, {
+            create: false
+        });
         try {
             await this.read(fd, offset.fromOffset, data, 0, data.length);
             return data;
-        }
-        finally {
+        } finally {
             this.close(fd);
         }
     }
     async read(fd, pos, data, offset, length) {
         const memory = this.fdMemory.get(fd);
         if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+            throw createFileSystemProviderError(
+                `No file with that descriptor open`,
+                FileSystemProviderErrorCode.Unavailable
+            );
         }
         const ranges = await memory.region.read(pos, length);
         let readSoFar = 0;
         for (const range of ranges) {
             switch (range.type) {
-                case MemoryRangeType.Unreadable:
+            case MemoryRangeType.Unreadable:
+                return readSoFar;
+            case MemoryRangeType.Error:
+                if (readSoFar > 0) {
                     return readSoFar;
-                case MemoryRangeType.Error:
-                    if (readSoFar > 0) {
-                        return readSoFar;
-                    }
-                    else {
-                        throw createFileSystemProviderError(range.error, FileSystemProviderErrorCode.Unknown);
-                    }
-                case MemoryRangeType.Valid: {
+                } else {
+                    throw createFileSystemProviderError(range.error, FileSystemProviderErrorCode.Unknown);
+                }
+            case MemoryRangeType.Valid:
+                {
                     const start = Math.max(0, pos - range.offset);
                     const toWrite = range.data.slice(start, Math.min(range.data.byteLength, start + (length - readSoFar)));
                     data.set(toWrite.buffer, offset + readSoFar);
                     readSoFar += toWrite.byteLength;
                     break;
                 }
-                default:
-                    assertNever();
+            default:
+                assertNever();
             }
         }
         return readSoFar;
@@ -149,13 +185,19 @@ class DebugMemoryFileSystemProvider extends Disposable {
     write(fd, pos, data, offset, length) {
         const memory = this.fdMemory.get(fd);
         if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+            throw createFileSystemProviderError(
+                `No file with that descriptor open`,
+                FileSystemProviderErrorCode.Unavailable
+            );
         }
         return memory.region.write(pos, VSBuffer.wrap(data).slice(offset, offset + length));
     }
     parseUri(uri) {
         if (uri.scheme !== DEBUG_MEMORY_SCHEME) {
-            throw createFileSystemProviderError(`Cannot open file with scheme ${uri.scheme}`, FileSystemProviderErrorCode.FileNotFound);
+            throw createFileSystemProviderError(
+                `Cannot open file with scheme ${uri.scheme}`,
+                FileSystemProviderErrorCode.FileNotFound
+            );
         }
         const session = this.debugService.getModel().getSession(uri.authority);
         if (!session) {
@@ -164,15 +206,18 @@ class DebugMemoryFileSystemProvider extends Disposable {
         let offset;
         const rangeMatch = rangeRe.exec(uri.query);
         if (rangeMatch) {
-            offset = { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) };
+            offset = {
+                fromOffset: Number(rangeMatch[1]),
+                toOffset: Number(rangeMatch[2])
+            };
         }
-        const [, memoryReference] = uri.path.split('/');
+        const [, memoryReference] = uri.path.split("/");
         return {
             session,
             offset,
             readOnly: !session.capabilities.supportsWriteMemoryRequest,
             sessionId: uri.authority,
-            memoryReference: decodeURIComponent(memoryReference),
+            memoryReference: decodeURIComponent(memoryReference)
         };
     }
 }
@@ -190,7 +235,10 @@ class MemoryRegionView extends Disposable {
             const fromOffset = clamp(e.fromOffset - range.fromOffset, 0, this.width);
             const toOffset = clamp(e.toOffset - range.fromOffset, 0, this.width);
             if (toOffset > fromOffset) {
-                this.invalidateEmitter.fire({ fromOffset, toOffset });
+                this.invalidateEmitter.fire({
+                    fromOffset,
+                    toOffset
+                });
             }
         }));
     }
@@ -198,7 +246,10 @@ class MemoryRegionView extends Disposable {
         if (fromOffset < 0) {
             throw ( new RangeError(`Invalid fromOffset: ${fromOffset}`));
         }
-        return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
+        return this.parent.read(
+            this.range.fromOffset + fromOffset,
+            this.range.fromOffset + Math.min(toOffset, this.width)
+        );
     }
     write(offset, data) {
         return this.parent.write(this.range.fromOffset + offset, data);

package/vscode/src/vs/workbench/contrib/debug/browser/debugProgress.js

@@ -12,21 +12,26 @@ let DebugProgressContribution = class DebugProgressContribution {
     constructor(debugService, progressService, viewsService) {
         this.toDispose = [];
         let progressListener;
-        const listenOnProgress = (session) => {
+        const listenOnProgress = session => {
             if (progressListener) {
                 progressListener.dispose();
                 progressListener = undefined;
             }
             if (session) {
-                progressListener = session.onDidProgressStart(async (progressStartEvent) => {
+                progressListener = session.onDidProgressStart(async progressStartEvent => {
                     const promise = ( new Promise(r => {
-                        const listener = Event.any(Event.filter(session.onDidProgressEnd, e => e.body.progressId === progressStartEvent.body.progressId), session.onDidEndAdapter)(() => {
+                        const listener = Event.any(Event.filter(
+                            session.onDidProgressEnd,
+                            e => e.body.progressId === progressStartEvent.body.progressId
+                        ), session.onDidEndAdapter)(() => {
                             listener.dispose();
                             r();
                         });
                     }));
                     if (viewsService.isViewContainerVisible(VIEWLET_ID)) {
-                        progressService.withProgress({ location: VIEWLET_ID }, () => promise);
+                        progressService.withProgress({
+                            location: VIEWLET_ID
+                        }, () => promise);
                     }
                     const source = debugService.getAdapterManager().getDebuggerLabel(session.configuration.type);
                     progressService.withProgress({
@@ -37,16 +42,16 @@ let DebugProgressContribution = class DebugProgressContribution {
                         delay: 500
                     }, progressStep => {
                         let total = 0;
-                        const reportProgress = (progress) => {
+                        const reportProgress = progress => {
                             let increment = undefined;
-                            if (typeof progress.percentage === 'number') {
+                            if (typeof progress.percentage === "number") {
                                 increment = progress.percentage - total;
                                 total += increment;
                             }
                             progressStep.report({
                                 message: progress.message,
                                 increment,
-                                total: typeof increment === 'number' ? 100 : undefined,
+                                total: typeof increment === "number" ? 100 : undefined
                             });
                         };
                         if (progressStartEvent.body.message) {
@@ -74,10 +79,6 @@ let DebugProgressContribution = class DebugProgressContribution {
         dispose(this.toDispose);
     }
 };
-DebugProgressContribution = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IProgressService)),
-    ( __param(2, IViewsService))
-], DebugProgressContribution));
+DebugProgressContribution = ( __decorate([( __param(0, IDebugService)), ( __param(1, IProgressService)), ( __param(2, IViewsService))], DebugProgressContribution));
 
 export { DebugProgressContribution };

package/vscode/src/vs/workbench/contrib/debug/browser/debugQuickAccess.js

@@ -16,7 +16,7 @@ let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends
     constructor(debugService, contextService, commandService, notificationService) {
         super(DEBUG_QUICK_ACCESS_PREFIX, {
             noResultsPick: {
-                label: ( localize(6866, "No matching launch configurations"))
+                label: ( localize(7177, "No matching launch configurations"))
             }
         });
         this.debugService = debugService;
@@ -29,7 +29,10 @@ let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends
         if (!this.debugService.getAdapterManager().hasEnabledDebuggers()) {
             return [];
         }
-        picks.push({ type: 'separator', label: 'launch.json' });
+        picks.push({
+            type: "separator",
+            label: "launch.json"
+        });
         const configManager = this.debugService.getConfigurationManager();
         const selectedConfiguration = configManager.selectedConfiguration;
         let lastGroup;
@@ -38,33 +41,43 @@ let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends
             if (highlights) {
                 const pick = {
                     label: config.name,
-                    description: this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ? config.launch.name : '',
-                    highlights: { label: highlights },
+                    description: this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ? config.launch.name : "",
+                    highlights: {
+                        label: highlights
+                    },
                     buttons: [{
-                            iconClass: ThemeIcon.asClassName(debugConfigure),
-                            tooltip: ( localize(6867, "Configure Launch Configuration"))
-                        }],
+                        iconClass: ThemeIcon.asClassName(debugConfigure),
+                        tooltip: ( localize(7178, "Configure Launch Configuration"))
+                    }],
                     trigger: () => {
-                        config.launch.openConfigFile({ preserveFocus: false });
+                        config.launch.openConfigFile({
+                            preserveFocus: false
+                        });
                         return TriggerAction.CLOSE_PICKER;
                     },
                     accept: async () => {
                         await configManager.selectConfiguration(config.launch, config.name);
                         try {
-                            await this.debugService.startDebugging(config.launch, undefined, { startedByUser: true });
-                        }
-                        catch (error) {
+                            await this.debugService.startDebugging(config.launch, undefined, {
+                                startedByUser: true
+                            });
+                        } catch (error) {
                             this.notificationService.error(error);
                         }
                     }
                 };
                 if (selectedConfiguration.name === config.name && selectedConfiguration.launch === config.launch) {
-                    const separator = { type: 'separator', label: ( localize(6868, 'Most Recent')) };
+                    const separator = {
+                        type: "separator",
+                        label: ( localize(7179, "Most Recent"))
+                    };
                     picks.unshift(separator, pick);
                     continue;
                 }
                 if (lastGroup !== config.presentation?.group) {
-                    picks.push({ type: 'separator' });
+                    picks.push({
+                        type: "separator"
+                    });
                     lastGroup = config.presentation?.group;
                 }
                 picks.push(pick);
@@ -73,31 +86,45 @@ let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends
         const dynamicProviders = await configManager.getDynamicProviders();
         if (dynamicProviders.length > 0) {
             picks.push({
-                type: 'separator', label: ( localize(6869, "contributed"))
+                type: "separator",
+                label: ( localize(7180, "contributed"))
             });
         }
-        configManager.getRecentDynamicConfigurations().forEach(({ name, type }) => {
+        configManager.getRecentDynamicConfigurations().forEach((
+            {
+                name,
+                type
+            }
+        ) => {
             const highlights = matchesFuzzy(filter, name, true);
             if (highlights) {
                 picks.push({
                     label: name,
-                    highlights: { label: highlights },
+                    highlights: {
+                        label: highlights
+                    },
                     buttons: [{
-                            iconClass: ThemeIcon.asClassName(debugRemoveConfig),
-                            tooltip: ( localize(6870, "Remove Launch Configuration"))
-                        }],
+                        iconClass: ThemeIcon.asClassName(debugRemoveConfig),
+                        tooltip: ( localize(7181, "Remove Launch Configuration"))
+                    }],
                     trigger: () => {
                         configManager.removeRecentDynamicConfigurations(name, type);
                         return TriggerAction.CLOSE_PICKER;
                     },
                     accept: async () => {
-                        await configManager.selectConfiguration(undefined, name, undefined, { type });
+                        await configManager.selectConfiguration(undefined, name, undefined, {
+                            type
+                        });
                         try {
-                            const { launch, getConfig } = configManager.selectedConfiguration;
+                            const {
+                                launch,
+                                getConfig
+                            } = configManager.selectedConfiguration;
                             const config = await getConfig();
-                            await this.debugService.startDebugging(launch, config, { startedByUser: true });
-                        }
-                        catch (error) {
+                            await this.debugService.startDebugging(launch, config, {
+                                startedByUser: true
+                            });
+                        } catch (error) {
                             this.notificationService.error(error);
                         }
                     }
@@ -107,39 +134,41 @@ let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends
         dynamicProviders.forEach(provider => {
             picks.push({
                 label: `$(folder) ${provider.label}...`,
-                ariaLabel: ( localize(6871, "{0} contributed configurations", provider.label)),
+                ariaLabel: ( localize(7182, "{0} contributed configurations", provider.label)),
                 accept: async () => {
                     const pick = await provider.pick();
                     if (pick) {
-                        await configManager.selectConfiguration(pick.launch, pick.config.name, pick.config, { type: provider.type });
-                        this.debugService.startDebugging(pick.launch, pick.config, { startedByUser: true });
+                        await configManager.selectConfiguration(pick.launch, pick.config.name, pick.config, {
+                            type: provider.type
+                        });
+                        this.debugService.startDebugging(pick.launch, pick.config, {
+                            startedByUser: true
+                        });
                     }
                 }
             });
         });
         const visibleLaunches = configManager.getLaunches().filter(launch => !launch.hidden);
         if (visibleLaunches.length > 0) {
-            picks.push({ type: 'separator', label: ( localize(6872, "configure")) });
+            picks.push({
+                type: "separator",
+                label: ( localize(7183, "configure"))
+            });
         }
         for (const launch of visibleLaunches) {
-            const label = this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ?
-                ( localize(6873, "Add Config ({0})...", launch.name)) :
-                ( localize(6874, "Add Configuration..."));
+            const label = this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ? ( localize(7184, "Add Config ({0})...", launch.name)) : ( localize(7185, "Add Configuration..."));
             picks.push({
                 label,
-                description: this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ? launch.name : '',
-                highlights: { label: matchesFuzzy(filter, label, true) ?? undefined },
+                description: this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE ? launch.name : "",
+                highlights: {
+                    label: matchesFuzzy(filter, label, true) ?? undefined
+                },
                 accept: () => this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( launch.uri.toString()))
             });
         }
         return picks;
     }
 };
-StartDebugQuickAccessProvider = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, INotificationService))
-], StartDebugQuickAccessProvider));
+StartDebugQuickAccessProvider = ( __decorate([( __param(0, IDebugService)), ( __param(1, IWorkspaceContextService)), ( __param(2, ICommandService)), ( __param(3, INotificationService))], StartDebugQuickAccessProvider));
 
 export { StartDebugQuickAccessProvider };