@theia/debug 1.77.0-next.25 → 1.77.0-next.29

package/src/browser/console/debug-console-session.ts

@@ -20,10 +20,12 @@ import { ConsoleSession, ConsoleItem } from '@theia/console/lib/browser/console-
 import { AnsiConsoleItem } from '@theia/console/lib/browser/ansi-console-item';
 import { DebugSession } from '../debug-session';
 import URI from '@theia/core/lib/common/uri';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 import { ExpressionContainer, ExpressionItem } from './debug-console-items';
 import { Severity } from '@theia/core/lib/common/severity';
 import { inject, injectable, postConstruct, named } from '@theia/core/shared/inversify';
 import { DebugSessionManager } from '../debug-session-manager';
+import { DebugPreferences } from '../../common/debug-preferences';
 import * as monaco from '@theia/monaco-editor-core';
 import { LanguageSelector } from '@theia/monaco-editor-core/esm/vs/editor/common/languageSelector';
 import { Disposable, ILogger } from '@theia/core';
@@ -42,24 +44,61 @@ export class DebugConsoleSession extends ConsoleSession {
     @inject(ILogger) @named('debug:DebugConsoleSession')
     protected readonly logger: ILogger;
 
+    @inject(DebugPreferences)
+    protected readonly preferences: DebugPreferences;
+
+    /**
+     * The console has an identity of its own, independent of the sessions that run in it: it outlives the session it
+     * was created for and is reused by a later one.
+     */
+    override id = generateUuid();
+
     protected items: ConsoleItem[] = [];
 
     protected _terminated = false;
 
-    protected _debugSession: DebugSession;
+    protected _debugSession: DebugSession | undefined;
+
+    protected _label = '';
+
+    protected _configurationName: string | undefined;
+
+    protected _workspaceFolderUri: string | undefined;
 
     // content buffer for [append](#append) method
     protected uncompletedItemContent: string | undefined;
 
     protected readonly completionKinds = new Map<DebugProtocol.CompletionItemType | undefined, monaco.languages.CompletionItemKind>();
 
-    get debugSession(): DebugSession {
+    /**
+     * The debug session this console currently belongs to, or `undefined` once that session has terminated.
+     *
+     * The reference is dropped on termination so that the console does not keep the whole session graph alive
+     * while it preserves the output of that session.
+     */
+    get debugSession(): DebugSession | undefined {
         return this._debugSession;
     }
 
-    set debugSession(value: DebugSession) {
-        this._debugSession = value;
-        this.id = value.id;
+    /**
+     * The label of the session this console belongs to, retained after that session has terminated.
+     */
+    get label(): string {
+        return this._label;
+    }
+
+    /**
+     * The name of the configuration this console was started for, used to match a restarted session to its console.
+     */
+    get configurationName(): string | undefined {
+        return this._configurationName;
+    }
+
+    /**
+     * The workspace folder of the configuration this console was started for, if any.
+     */
+    get workspaceFolderUri(): string | undefined {
+        return this._workspaceFolderUri;
     }
 
     get terminated(): boolean {
@@ -69,10 +108,41 @@ export class DebugConsoleSession extends ConsoleSession {
     markTerminated(): void {
         if (!this._terminated) {
             this._terminated = true;
+            // Release the session: from here on the console only holds the output it has already collected.
+            this._debugSession = undefined;
             this.fireDidChange();
         }
     }
 
+    /**
+     * Whether the given session can take over this console: its session must have terminated and been started from the
+     * same configuration, which in a multi-root workspace includes the folder the configuration comes from.
+     */
+    isReusableBy(session: DebugSession): boolean {
+        return this._terminated
+            && this._configurationName === session.configuration.name
+            && this._workspaceFolderUri === session.options.workspaceFolderUri;
+    }
+
+    /**
+     * Runs the given session in this console, whether it is the session the console was created for or a later one
+     * reusing it. Counterpart of {@link markTerminated}.
+     *
+     * The output of any previous session is dropped: it belongs to that run, and keeping it would merge two runs into
+     * one view with no boundary between them. The filter and severity stay, since they are the view the user has set
+     * up for this configuration.
+     */
+    startFor(session: DebugSession): void {
+        this.items = [];
+        this.uncompletedItemContent = undefined;
+        this._debugSession = session;
+        this._label = session.label;
+        this._configurationName = session.configuration.name;
+        this._workspaceFolderUri = session.options.workspaceFolderUri;
+        this._terminated = false;
+        this.fireDidChange();
+    }
+
     @postConstruct()
     init(): void {
         this.completionKinds.set('method', monaco.languages.CompletionItemKind.Method);
@@ -175,16 +245,17 @@ export class DebugConsoleSession extends ConsoleSession {
     }
 
     protected findCurrentSession(): DebugSession | undefined {
+        const debugSession = this._debugSession;
         const currentSession = this.sessionManager.currentSession;
-        if (!currentSession) {
+        if (!debugSession || !currentSession) {
             return undefined;
         }
-        if (currentSession.id === this.debugSession.id) {
+        if (currentSession.id === debugSession.id) {
             // perfect match
-            return this.debugSession;
+            return debugSession;
         }
         const parentSession = currentSession.findConsoleParent();
-        if (parentSession?.id === this.debugSession.id) {
+        if (parentSession?.id === debugSession.id) {
             // child of our session
             return currentSession;
         }
@@ -215,7 +286,7 @@ export class DebugConsoleSession extends ConsoleSession {
 
     async execute(value: string): Promise<void> {
         const expression = new ExpressionItem(value, () => this.findCurrentSession());
-        this.items.push(expression);
+        this.appendItems([expression]);
         await expression.evaluate();
         this.fireDidChange();
     }
@@ -238,15 +309,28 @@ export class DebugConsoleSession extends ConsoleSession {
             this.uncompletedItemContent = value;
         }
 
-        this.items.push(new AnsiConsoleItem(this.uncompletedItemContent, Severity.Info));
+        this.appendItems([new AnsiConsoleItem(this.uncompletedItemContent, Severity.Info)]);
         this.fireDidChange();
     }
 
     appendLine(value: string): void {
-        this.items.push(new AnsiConsoleItem(value, Severity.Info));
+        this.appendItems([new AnsiConsoleItem(value, Severity.Info)]);
         this.fireDidChange();
     }
 
+    /**
+     * Appends items, dropping the oldest ones so that the console stays within `debug.console.maximumLines`.
+     */
+    protected appendItems(items: ConsoleItem[]): void {
+        for (const item of items) {
+            this.items.push(item);
+        }
+        const maximumLines = this.preferences['debug.console.maximumLines'];
+        if (maximumLines > 0 && this.items.length > maximumLines) {
+            this.items.splice(0, this.items.length - maximumLines);
+        }
+    }
+
     async logOutput(session: DebugSession, event: DebugProtocol.OutputEvent): Promise<void> {
         const body = event.body;
         const { category, variablesReference } = body;
@@ -256,14 +340,13 @@ export class DebugConsoleSession extends ConsoleSession {
         }
         const severity = category === 'stderr' ? Severity.Error : event.body.category === 'console' ? Severity.Warning : Severity.Info;
         if (variablesReference) {
-            const items = await new ExpressionContainer({ session: () => session, variablesReference }).getElements();
-            for (const item of items) {
-                this.items.push(Object.assign(item, { severity }));
-            }
+            // Resolve the session by id rather than capturing it, so that the items do not keep it alive once it is gone.
+            const { id } = session;
+            const sessionProvider = () => this.sessionManager.getSession(id);
+            const items = await new ExpressionContainer({ session: sessionProvider, variablesReference }).getElements();
+            this.appendItems(Array.from(items, item => Object.assign(item, { severity })));
         } else if (typeof body.output === 'string') {
-            for (const line of body.output.split('\n')) {
-                this.items.push(new AnsiConsoleItem(line, severity));
-            }
+            this.appendItems(body.output.split('\n').map(line => new AnsiConsoleItem(line, severity)));
         }
         this.fireDidChange();
     }

package/src/browser/debug-session-connection.ts

@@ -151,6 +151,15 @@ export class DebugSessionConnection implements Disposable {
         return this.toDispose.disposed;
     }
 
+    /**
+     * Whether the underlying channel has been closed, so that no further request can be sent.
+     *
+     * This becomes `true` as soon as the channel closes, which is before the connection itself is disposed.
+     */
+    get closed(): boolean {
+        return this.isClosed;
+    }
+
     protected checkDisposed(): void {
         if (this.disposed) {
             throw new Error('the debug session connection is disposed, id: ' + this.sessionId);

package/src/browser/debug-session-manager.ts

@@ -568,9 +568,12 @@ export class DebugSessionManager {
             this.disposeOnCurrentSessionChanged.push(current.onDidResolveLazyVariable(variable => this.onDidResolveLazyVariableEmitter.fire({ session: current, variable })));
             this.disposeOnCurrentSessionChanged.push(current.onDidFocusStackFrame(frame => this.onDidFocusStackFrameEmitter.fire(frame)));
             this.disposeOnCurrentSessionChanged.push(current.onDidFocusThread(thread => this.onDidFocusThreadEmitter.fire(thread)));
-            const { currentThread } = current;
-            this.onDidFocusThreadEmitter.fire(currentThread);
         }
+        // Announce what is focused now, also when nothing is: the forwarding above is torn down with the previous
+        // session, so without this the last thread and frame of a session that has ended stay the focused ones.
+        const { currentThread, currentFrame } = this;
+        this.onDidFocusThreadEmitter.fire(currentThread);
+        this.onDidFocusStackFrameEmitter.fire(currentFrame);
         this.open();
         this.fireDidChange(current);
     }

package/src/browser/debug-session.tsx

@@ -733,6 +733,12 @@ export class DebugSession implements CompositeTreeElement {
         const { uri, sourceModified } = options;
         await this.deferredOnDidConfigureCapabilities.promise;
         for (const affectedUri of this.getAffectedUris(uri)) {
+            if (this.connection.closed) {
+                // The session ended while the breakpoints were being sent, which happens because ending one session
+                // updates the breakpoints of all of them. There is nothing left to send them to, and reporting them
+                // as unverified would outlive the session they failed for.
+                return;
+            }
             if (affectedUri.toString() === BreakpointManager.EXCEPTION_URI.toString()) {
                 await this.sendExceptionBreakpoints();
             } else if (affectedUri.toString() === BreakpointManager.FUNCTION_URI.toString()) {

package/src/browser/view/debug-variables-widget.ts

@@ -118,6 +118,12 @@ export class DebugVariablesWidget extends SourceTreeWidget {
 
     protected handleDidDestroyDebugSession(session: DebugSession): void {
         this.statePerSession.delete(session.id);
+        if (this.stackFrame?.session.id === session.id) {
+            // Release the frame, which holds its session: this widget outlives every session, and no stack frame is
+            // focused when the session it belongs to is gone. `onDidFocusStackFrame` does not announce that, as the
+            // session manager stops forwarding the event as soon as the session is no longer the current one.
+            this.stackFrame = undefined;
+        }
     }
 
     protected override handleContextMenuEvent(node: TreeNode | undefined, event: MouseEvent<HTMLElement>): void {

package/src/common/debug-preferences.ts

@@ -35,6 +35,12 @@ export const debugPreferencesSchema: PreferenceSchema = {
             default: 'openOnFirstSessionStart',
             description: nls.localizeByDefault('Controls when the internal Debug Console should open.')
         },
+        'debug.console.maximumLines': {
+            type: 'number',
+            default: 10000,
+            minimum: 1,
+            description: nls.localizeByDefault('Controls the maximum number of lines in the Debug Console.')
+        },
         'debug.inlineValues': {
             type: 'boolean',
             default: false,
@@ -92,6 +98,7 @@ export class DebugConfiguration {
     'debug.trace': boolean;
     'debug.openDebug': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart' | 'openOnDebugBreak';
     'debug.internalConsoleOptions': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
+    'debug.console.maximumLines': number;
     'debug.inlineValues': boolean;
     'debug.showInStatusBar': 'never' | 'always' | 'onFirstSessionStart';
     'debug.confirmOnExit': 'never' | 'always';