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

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

@@ -10,6 +10,7 @@ import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { deepClone, equals } from 'vscode/vscode/vs/base/common/objects';
 import Severity from 'vscode/vscode/vs/base/common/severity';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
 import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
@@ -25,16 +26,18 @@ import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { IViewsService, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { AdapterManager } from './debugAdapterManager.js';
 import { DEBUG_CONFIGURE_COMMAND_ID, DEBUG_CONFIGURE_LABEL } from './debugCommands.js';
 import { ConfigurationManager } from './debugConfigurationManager.js';
 import { DebugMemoryFileSystemProvider } from './debugMemory.js';
 import { DebugSession } from './debugSession.js';
 import { DebugTaskRunner } from './debugTaskRunner.js';
-import { CALLSTACK_VIEW_ID, DEBUG_MEMORY_SCHEME, CONTEXT_DEBUG_TYPE, CONTEXT_DEBUG_STATE, CONTEXT_HAS_DEBUGGED, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_UX, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_DISASSEMBLY_VIEW_FOCUS, getStateLabel, debuggerDisabledMessage, VIEWLET_ID, REPL_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { CALLSTACK_VIEW_ID, DEBUG_MEMORY_SCHEME, CONTEXT_DEBUG_TYPE, CONTEXT_DEBUG_STATE, CONTEXT_HAS_DEBUGGED, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_UX, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_DISASSEMBLY_VIEW_FOCUS, getStateLabel, debuggerDisabledMessage, VIEWLET_ID, REPL_VIEW_ID, DEBUG_SCHEME } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { DebugCompoundRoot } from '../common/debugCompoundRoot.js';
 import { DebugModel, Breakpoint, FunctionBreakpoint, DataBreakpoint, InstructionBreakpoint } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { Source } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugSource';
 import { DebugStorage } from '../common/debugStorage.js';
 import { DebugTelemetry } from '../common/debugTelemetry.js';
 import { saveAllBeforeDebugStart, getExtensionHostDebugSession } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
@@ -71,6 +74,7 @@ let DebugService = class DebugService {
         this.quickInputService = quickInputService;
         this.workspaceTrustRequestService = workspaceTrustRequestService;
         this.uriIdentityService = uriIdentityService;
+        this.restartingSessions = ( new Set());
         this.disposables = ( new DisposableStore());
         this.initializing = false;
         this.sessionCancellationTokens = ( new Map());
@@ -417,7 +421,7 @@ let DebugService = class DebugService {
                 if (taskResult === 0 ) {
                     return false;
                 }
-                const cfg = await this.configurationManager.resolveDebugConfigurationWithSubstitutedVariables(launch && launch.workspace ? launch.workspace.uri : undefined, type, resolvedConfig, initCancellationToken.token);
+                const cfg = await this.configurationManager.resolveDebugConfigurationWithSubstitutedVariables(launch && launch.workspace ? launch.workspace.uri : undefined, resolvedConfig.type, resolvedConfig, initCancellationToken.token);
                 if (!cfg) {
                     if (launch && type && cfg === null && !initCancellationToken.token.isCancellationRequested) {
                         await launch.openConfigFile({ preserveFocus: true, type }, initCancellationToken.token);
@@ -571,12 +575,14 @@ let DebugService = class DebugService {
         }
     }
     registerSessionListeners(session) {
-        const sessionRunningScheduler = ( new RunOnceScheduler(() => {
+        const listenerDisposables = ( new DisposableStore());
+        this.disposables.add(listenerDisposables);
+        const sessionRunningScheduler = listenerDisposables.add(( new RunOnceScheduler(() => {
             if (session.state === 3  && this.viewModel.focusedSession === session) {
                 this.viewModel.setFocus(undefined, this.viewModel.focusedThread, session, false);
             }
-        }, 200));
-        this.disposables.add(session.onDidChangeState(() => {
+        }, 200)));
+        listenerDisposables.add(session.onDidChangeState(() => {
             if (session.state === 3  && this.viewModel.focusedSession === session) {
                 sessionRunningScheduler.schedule();
             }
@@ -584,7 +590,12 @@ let DebugService = class DebugService {
                 this.onStateChange();
             }
         }));
-        this.disposables.add(session.onDidEndAdapter(async (adapterExitEvent) => {
+        listenerDisposables.add(this.onDidEndSession(e => {
+            if (e.session === session && !e.restart) {
+                this.disposables.delete(listenerDisposables);
+            }
+        }));
+        listenerDisposables.add(session.onDidEndAdapter(async (adapterExitEvent) => {
             if (adapterExitEvent) {
                 if (adapterExitEvent.error) {
                     this.notificationService.error(( localizeWithPath(
@@ -611,7 +622,13 @@ let DebugService = class DebugService {
             }
             this.endInitializingState();
             this.cancelTokens(session.getId());
-            this._onDidEndSession.fire(session);
+            if (this.configurationService.getValue('debug').closeReadonlyTabsOnEnd) {
+                const editorsToClose = this.editorService.getEditors(1 ).filter(({ editor }) => {
+                    return editor.resource?.scheme === DEBUG_SCHEME && session.getId() === Source.getEncodedDebugData(editor.resource).sessionId;
+                });
+                this.editorService.closeEditors(editorsToClose);
+            }
+            this._onDidEndSession.fire({ session, restart: ( this.restartingSessions.has(session)) });
             const focusedSession = this.viewModel.focusedSession;
             if (focusedSession && focusedSession.getId() === session.getId()) {
                 const { session, thread, stackFrame } = getStackFrameThreadAndSessionToFocus(this.model, undefined, undefined, undefined, focusedSession);
@@ -690,39 +707,61 @@ let DebugService = class DebugService {
             session.setConfiguration({ resolved, unresolved });
         }
         session.configuration.__restart = restartData;
+        const doRestart = async (fn) => {
+            this.restartingSessions.add(session);
+            let didRestart = false;
+            try {
+                didRestart = (await fn()) !== false;
+            }
+            catch (e) {
+                didRestart = false;
+                throw e;
+            }
+            finally {
+                this.restartingSessions.delete(session);
+                if (!didRestart) {
+                    this._onDidEndSession.fire({ session, restart: false });
+                }
+            }
+        };
         if (session.capabilities.supportsRestartRequest) {
             const taskResult = await runTasks();
             if (taskResult === 1 ) {
-                await session.restart();
+                await doRestart(async () => {
+                    await session.restart();
+                    return true;
+                });
             }
             return;
         }
         const shouldFocus = !!this.viewModel.focusedSession && session.getId() === this.viewModel.focusedSession.getId();
-        if (isAutoRestart) {
-            await session.disconnect(true);
-        }
-        else {
-            await session.terminate(true);
-        }
-        return ( new Promise((c, e) => {
-            setTimeout(async () => {
-                const taskResult = await runTasks();
-                if (taskResult !== 1 ) {
-                    return;
-                }
-                if (!resolved) {
-                    return c(undefined);
-                }
-                try {
-                    await this.launchOrAttachToSession(session, shouldFocus);
-                    this._onDidNewSession.fire(session);
-                    c(undefined);
-                }
-                catch (error) {
-                    e(error);
-                }
-            }, 300);
-        }));
+        return doRestart(async () => {
+            if (isAutoRestart) {
+                await session.disconnect(true);
+            }
+            else {
+                await session.terminate(true);
+            }
+            return ( new Promise((c, e) => {
+                setTimeout(async () => {
+                    const taskResult = await runTasks();
+                    if (taskResult !== 1 ) {
+                        return c(false);
+                    }
+                    if (!resolved) {
+                        return c(false);
+                    }
+                    try {
+                        await this.launchOrAttachToSession(session, shouldFocus);
+                        this._onDidNewSession.fire(session);
+                        c(true);
+                    }
+                    catch (error) {
+                        e(error);
+                    }
+                }, 300);
+            }));
+        });
     }
     async stopSession(session, disconnect = false, suspend = false) {
         if (session) {
@@ -843,6 +882,7 @@ let DebugService = class DebugService {
             this.model.setEnablement(breakpoint, enable);
             this.debugStorage.storeBreakpoints(this.model);
             if (breakpoint instanceof Breakpoint) {
+                await this.makeTriggeredBreakpointsMatchEnablement(enable, breakpoint);
                 await this.sendBreakpoints(breakpoint.originalUri);
             }
             else if (breakpoint instanceof FunctionBreakpoint) {
@@ -893,7 +933,8 @@ let DebugService = class DebugService {
         }
     }
     async removeBreakpoints(id) {
-        const toRemove = this.model.getBreakpoints().filter(bp => !id || bp.getId() === id);
+        const breakpoints = this.model.getBreakpoints();
+        const toRemove = breakpoints.filter(bp => !id || bp.getId() === id);
         toRemove.forEach(bp => status(( localizeWithPath(
             'vs/workbench/contrib/debug/browser/debugService',
             'breakpointRemoved',
@@ -901,10 +942,11 @@ let DebugService = class DebugService {
             bp.lineNumber,
             bp.uri.fsPath
         ))));
-        const urisToClear = ( distinct(toRemove, bp => ( bp.originalUri.toString())).map(bp => bp.originalUri));
+        const urisToClear = ( new Set(( toRemove.map(bp => ( bp.originalUri.toString())))));
         this.model.removeBreakpoints(toRemove);
+        this.unlinkTriggeredBreakpoints(breakpoints, toRemove).forEach(uri => urisToClear.add(( uri.toString())));
         this.debugStorage.storeBreakpoints(this.model);
-        await Promise.all(( urisToClear.map(uri => this.sendBreakpoints(uri))));
+        await Promise.all(( [...urisToClear].map(uri => this.sendBreakpoints(( URI.parse(uri))))));
     }
     setBreakpointsActivated(activated) {
         this.model.setBreakpointsActivated(activated);
@@ -983,11 +1025,37 @@ let DebugService = class DebugService {
             await this.sendExceptionBreakpoints(session);
         }
     }
+    unlinkTriggeredBreakpoints(allBreakpoints, removedBreakpoints) {
+        const affectedUris = [];
+        for (const removed of removedBreakpoints) {
+            for (const existing of allBreakpoints) {
+                if (!removedBreakpoints.includes(existing) && existing.triggeredBy === removed.getId()) {
+                    this.model.updateBreakpoints(( new Map([[existing.getId(), { triggeredBy: undefined }]])));
+                    affectedUris.push(existing.originalUri);
+                }
+            }
+        }
+        return affectedUris;
+    }
+    async makeTriggeredBreakpointsMatchEnablement(enable, breakpoint) {
+        if (enable) {
+            if (breakpoint.triggeredBy) {
+                const trigger = this.model.getBreakpoints().find(bp => breakpoint.triggeredBy === bp.getId());
+                if (trigger && !trigger.enabled) {
+                    await this.enableOrDisableBreakpoints(enable, trigger);
+                }
+            }
+        }
+        await Promise.all(( this.model.getBreakpoints()
+            .filter(bp => bp.triggeredBy === breakpoint.getId() && bp.enabled !== enable)
+            .map(bp => this.enableOrDisableBreakpoints(enable, bp))));
+    }
     async sendBreakpoints(modelUri, sourceModified = false, session) {
         const breakpointsToSend = this.model.getBreakpoints({ originalUri: modelUri, enabledOnly: true });
         await sendToOneOrAllSessions(this.model, session, async (s) => {
             if (!s.configuration.noDebug) {
-                await s.sendBreakpoints(modelUri, breakpointsToSend, sourceModified);
+                const sessionBps = breakpointsToSend.filter(bp => !bp.triggeredBy || bp.getSessionDidTrigger(s.getId()));
+                await s.sendBreakpoints(modelUri, sessionBps, sourceModified);
             }
         });
     }

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

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { status } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
 import { distinct } from 'vscode/vscode/vs/base/common/arrays';
-import { RunOnceScheduler, Queue } from 'vscode/vscode/vs/base/common/async';
+import { RunOnceScheduler, raceTimeout, Queue } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { canceled } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
@@ -11,6 +11,7 @@ import { mixin } from 'vscode/vscode/vs/base/common/objects';
 import { language } from 'vscode/vscode/vs/base/common/platform';
 import { basenameOrAuthority } from 'vscode/vscode/vs/base/common/resources';
 import Severity from 'vscode/vscode/vs/base/common/severity';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
@@ -26,7 +27,7 @@ import { IDebugService, VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/de
 import { MemoryRegion, ExpressionContainer, Thread } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { Source } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugSource';
 import { filterExceptionsFromTelemetry } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
-import { ReplModel } from '../common/replModel.js';
+import { ReplModel } from 'vscode/vscode/vs/workbench/contrib/debug/common/replModel';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
@@ -34,6 +35,7 @@ import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/p
 import { getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
+const TRIGGERED_BREAKPOINT_MAX_DELAY = 1500;
 let DebugSession = class DebugSession {
     constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService) {
         this.id = id;
@@ -59,7 +61,9 @@ let DebugSession = class DebugSession {
         this.threadIds = [];
         this.cancellationMap = ( new Map());
         this.rawListeners = ( new DisposableStore());
+        this.globalDisposables = ( new DisposableStore());
         this.stoppedDetails = [];
+        this.statusQueue = this.rawListeners.add(( new ThreadStatusScheduler()));
         this._onDidChangeState = ( new Emitter());
         this._onDidEndAdapter = ( new Emitter());
         this._onDidLoadedSource = ( new Emitter());
@@ -78,7 +82,7 @@ let DebugSession = class DebugSession {
         else {
             this.repl = this.parentSession.repl;
         }
-        const toDispose = ( new DisposableStore());
+        const toDispose = this.globalDisposables;
         const replListener = toDispose.add(( new MutableDisposable()));
         replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
         if (lifecycleService) {
@@ -499,6 +503,7 @@ let DebugSession = class DebugSession {
         return this.raw.evaluate({ expression, frameId, context });
     }
     async restartFrame(frameId, threadId) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
         }
@@ -511,6 +516,7 @@ let DebugSession = class DebugSession {
         }
     }
     async next(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
         }
@@ -518,6 +524,7 @@ let DebugSession = class DebugSession {
         await this.raw.next({ threadId, granularity });
     }
     async stepIn(threadId, targetId, granularity) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
         }
@@ -525,6 +532,7 @@ let DebugSession = class DebugSession {
         await this.raw.stepIn({ threadId, targetId, granularity });
     }
     async stepOut(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
         }
@@ -532,6 +540,7 @@ let DebugSession = class DebugSession {
         await this.raw.stepOut({ threadId, granularity });
     }
     async stepBack(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
         }
@@ -539,12 +548,14 @@ let DebugSession = class DebugSession {
         await this.raw.stepBack({ threadId, granularity });
     }
     async continue(threadId) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
         }
         await this.raw.continue({ threadId });
     }
     async reverseContinue(threadId) {
+        await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
         }
@@ -776,6 +787,12 @@ let DebugSession = class DebugSession {
             }
         }
     }
+    waitForTriggeredBreakpoints() {
+        if (!this._waitToResume) {
+            return;
+        }
+        return raceTimeout(this._waitToResume, TRIGGERED_BREAKPOINT_MAX_DELAY);
+    }
     async fetchThreads(stoppedDetails) {
         if (this.raw) {
             const response = await this.raw.threads();
@@ -828,57 +845,8 @@ let DebugSession = class DebugSession {
                 await this.fetchThreads();
             }
         }));
-        const statusQueue = this.rawListeners.add(( new ThreadStatusScheduler()));
-        this.rawListeners.add(this.raw.onDidStop(async (event) => {
-            this.passFocusScheduler.cancel();
-            this.stoppedDetails.push(event.body);
-            statusQueue.run(this.fetchThreads(event.body).then(() => event.body.threadId === undefined ? this.threadIds : [event.body.threadId]), async (threadId, token) => {
-                const hasLotsOfThreads = event.body.threadId === undefined && this.threadIds.length > 10;
-                const focusedThread = this.debugService.getViewModel().focusedThread;
-                const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
-                if (focusedThreadDoesNotExist) {
-                    this.debugService.focusStackFrame(undefined, undefined);
-                }
-                const thread = typeof threadId === 'number' ? this.getThread(threadId) : undefined;
-                if (thread) {
-                    const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
-                    const focus = async () => {
-                        if (focusedThreadDoesNotExist || (!event.body.preserveFocusHint && thread.getCallStack().length)) {
-                            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                            if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
-                                const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
-                                await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
-                            }
-                            if (thread.stoppedDetails && !token.isCancellationRequested) {
-                                if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
-                                    await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
-                                }
-                                if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
-                                    const activeWindow = getActiveWindow();
-                                    if (!activeWindow.document.hasFocus()) {
-                                        await this.hostService.focus(mainWindow, { force: true  });
-                                    }
-                                }
-                            }
-                        }
-                    };
-                    await promises.topCallStack;
-                    if (token.isCancellationRequested) {
-                        return;
-                    }
-                    focus();
-                    await promises.wholeCallStack;
-                    if (token.isCancellationRequested) {
-                        return;
-                    }
-                    const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                    if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
-                        focus();
-                    }
-                }
-                this._onDidChangeState.fire();
-            });
-        }));
+        const statusQueue = this.statusQueue;
+        this.rawListeners.add(this.raw.onDidStop(event => this.handleStop(event.body)));
         this.rawListeners.add(this.raw.onDidThread(event => {
             statusQueue.cancel([event.body.threadId]);
             if (event.body.reason === 'started') {
@@ -1067,10 +1035,13 @@ let DebugSession = class DebugSession {
             this._onDidInvalidMemory.fire(event);
         }));
         this.rawListeners.add(this.raw.onDidInvalidated(async (event) => {
-            if (!(event.body.areas && event.body.areas.length === 1 && (event.body.areas[0] === 'variables' || event.body.areas[0] === 'watch'))) {
+            const areas = event.body.areas || ['all'];
+            if (areas.includes('threads') || areas.includes('stacks') || areas.includes('all')) {
                 this.cancelAllRequests();
                 this.model.clearThreads(this.getId(), true);
-                await this.fetchThreads(this.getStoppedDetails());
+                const details = this.stoppedDetails;
+                this.stoppedDetails.length = 1;
+                await Promise.all(( details.map(d => this.handleStop(d))));
             }
             const viewModel = this.debugService.getViewModel();
             if (viewModel.focusedSession === this) {
@@ -1079,6 +1050,101 @@ let DebugSession = class DebugSession {
         }));
         this.rawListeners.add(this.raw.onDidExitAdapter(event => this.onDidExitAdapter(event)));
     }
+    async handleStop(event) {
+        this.passFocusScheduler.cancel();
+        this.stoppedDetails.push(event);
+        if (event.hitBreakpointIds) {
+            this._waitToResume = this.enableDependentBreakpoints(event.hitBreakpointIds);
+        }
+        this.statusQueue.run(this.fetchThreads(event).then(() => event.threadId === undefined ? this.threadIds : [event.threadId]), async (threadId, token) => {
+            const hasLotsOfThreads = event.threadId === undefined && this.threadIds.length > 10;
+            const focusedThread = this.debugService.getViewModel().focusedThread;
+            const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
+            if (focusedThreadDoesNotExist) {
+                this.debugService.focusStackFrame(undefined, undefined);
+            }
+            const thread = typeof threadId === 'number' ? this.getThread(threadId) : undefined;
+            if (thread) {
+                const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
+                const focus = async () => {
+                    if (focusedThreadDoesNotExist || (!event.preserveFocusHint && thread.getCallStack().length)) {
+                        const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                        if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
+                            const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
+                            await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
+                        }
+                        if (thread.stoppedDetails && !token.isCancellationRequested) {
+                            if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
+                                await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
+                            }
+                            if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
+                                const activeWindow = getActiveWindow();
+                                if (!activeWindow.document.hasFocus()) {
+                                    await this.hostService.focus(mainWindow, { force: true  });
+                                }
+                            }
+                        }
+                    }
+                };
+                await promises.topCallStack;
+                if (!event.hitBreakpointIds) {
+                    this._waitToResume = this.enableDependentBreakpoints(thread);
+                }
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                focus();
+                await promises.wholeCallStack;
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
+                    focus();
+                }
+            }
+            this._onDidChangeState.fire();
+        });
+    }
+    async enableDependentBreakpoints(hitBreakpointIdsOrThread) {
+        let breakpoints;
+        if (Array.isArray(hitBreakpointIdsOrThread)) {
+            breakpoints = this.model.getBreakpoints().filter(bp => hitBreakpointIdsOrThread.includes(bp.getIdFromAdapter(this.id)));
+        }
+        else {
+            const frame = hitBreakpointIdsOrThread.getTopStackFrame();
+            if (frame === undefined) {
+                return;
+            }
+            if (hitBreakpointIdsOrThread.stoppedDetails && hitBreakpointIdsOrThread.stoppedDetails.reason !== 'breakpoint') {
+                return;
+            }
+            breakpoints = this.getBreakpointsAtPosition(frame.source.uri, frame.range.startLineNumber, frame.range.endLineNumber, frame.range.startColumn, frame.range.endColumn);
+        }
+        const urisToResend = ( new Set());
+        this.model.getBreakpoints({ triggeredOnly: true, enabledOnly: true }).forEach(bp => {
+            breakpoints.forEach(cbp => {
+                if (bp.enabled && bp.triggeredBy === cbp.getId()) {
+                    bp.setSessionDidTrigger(this.getId());
+                    urisToResend.add(( bp.uri.toString()));
+                }
+            });
+        });
+        const results = [];
+        urisToResend.forEach((uri) => results.push(this.debugService.sendBreakpoints(( URI.parse(uri)), undefined, this)));
+        return Promise.all(results);
+    }
+    getBreakpointsAtPosition(uri, startLineNumber, endLineNumber, startColumn, endColumn) {
+        return this.model.getBreakpoints({ uri: uri }).filter(bp => {
+            if (bp.lineNumber < startLineNumber || bp.lineNumber > endLineNumber) {
+                return false;
+            }
+            if (bp.column && (bp.column < startColumn || bp.column > endColumn)) {
+                return false;
+            }
+            return true;
+        });
+    }
     onDidExitAdapter(event) {
         this.initialized = true;
         this.model.setBreakpointSessionData(this.getId(), this.capabilities, undefined);
@@ -1102,6 +1168,7 @@ let DebugSession = class DebugSession {
     dispose() {
         this.cancelAllRequests();
         this.rawListeners.dispose();
+        this.globalDisposables.dispose();
     }
     getSourceForUri(uri) {
         return this.sources.get(( this.uriIdentityService.asCanonicalUri(uri).toString()));

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

@@ -3,7 +3,7 @@ import { matchesFuzzy } from 'vscode/vscode/vs/base/common/filters';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IDebugService, REPL_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 
 async function showDebugSessionMenu(accessor, selectAndStartID) {

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

@@ -6,7 +6,7 @@ import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/ta
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { MarkerSeverity, IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { createErrorWithActions } from 'vscode/vscode/vs/base/common/errorMessage';
 import { Action } from 'vscode/vscode/vs/base/common/actions';
@@ -232,25 +232,26 @@ let DebugTaskRunner = class DebugTaskRunner {
             ))]));
         }
         let taskStarted = false;
-        const taskKey = task.getMapKey();
+        const getTaskKey = (t) => t.getKey() ?? t.getMapKey();
+        const taskKey = getTaskKey(task);
         const inactivePromise = ( new Promise((c) => once(e => {
             return (e.kind === "inactive"
                 || (e.kind === "processEnded"  && e.exitCode === undefined))
-                && e.__task?.getMapKey() === taskKey;
+                && getTaskKey(e.__task) === taskKey;
         }, this.taskService.onDidStateChange)(e => {
             taskStarted = true;
             c(e.kind === "processEnded"  ? { exitCode: e.exitCode } : null);
         })));
         const promise = this.taskService.getActiveTasks().then(async (tasks) => {
-            if (tasks.find(t => t.getMapKey() === taskKey)) {
+            if (tasks.find(t => getTaskKey(t) === taskKey)) {
                 const busyTasks = await this.taskService.getBusyTasks();
-                if (busyTasks.find(t => t.getMapKey() === taskKey)) {
+                if (busyTasks.find(t => getTaskKey(t) === taskKey)) {
                     taskStarted = true;
                     return inactivePromise;
                 }
                 return Promise.resolve(null);
             }
-            once(e => (((e.kind === "active") ) || ((e.kind === "dependsOnStarted") )) && e.__task?.getMapKey() === taskKey, this.taskService.onDidStateChange)(() => {
+            once(e => (((e.kind === "active") ) || ((e.kind === "dependsOnStarted") )) && getTaskKey(e.__task) === taskKey, this.taskService.onDidStateChange)(() => {
                 taskStarted = true;
             });
             const taskPromise = this.taskService.run(task);
@@ -261,7 +262,7 @@ let DebugTaskRunner = class DebugTaskRunner {
         });
         return ( new Promise((c, e) => {
             const waitForInput = ( new Promise(
-                resolve => once(e => ((e.kind === "acquiredInput") ) && e.__task?.getMapKey() === taskKey, this.taskService.onDidStateChange)(() => {
+                resolve => once(e => ((e.kind === "acquiredInput") ) && getTaskKey(e.__task) === taskKey, this.taskService.onDidStateChange)(() => {
                     resolve();
                 })
             ));