@theia/debug 1.67.0-next.59 → 1.67.0-next.86

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

@@ -25,6 +25,9 @@ import { SelectableTreeNode, TreeNode, TreeSelection } from '@theia/core/lib/bro
 import { DebugVariable } from '../console/debug-console-items';
 import { BreakpointManager } from '../breakpoint/breakpoint-manager';
 import { DataBreakpoint, DataBreakpointSource, DataBreakpointSourceType } from '../breakpoint/breakpoint-marker';
+import { DebugSessionManager } from '../debug-session-manager';
+import { DebugSession } from '../debug-session';
+import { DebugStackFrame } from '../model/debug-stack-frame';
 
 @injectable()
 export class DebugVariablesWidget extends SourceTreeWidget {
@@ -64,6 +67,12 @@ export class DebugVariablesWidget extends SourceTreeWidget {
     @inject(BreakpointManager)
     protected readonly breakpointManager: BreakpointManager;
 
+    @inject(DebugSessionManager)
+    protected readonly sessionManager: DebugSessionManager;
+
+    protected stackFrame: DebugStackFrame | undefined;
+    protected readonly statePerSession = new Map<string, DebugVariablesWidgetSessionState>();
+
     @postConstruct()
     protected override init(): void {
         super.init();
@@ -71,6 +80,44 @@ export class DebugVariablesWidget extends SourceTreeWidget {
         this.title.label = nls.localizeByDefault('Variables');
         this.toDispose.push(this.variables);
         this.source = this.variables;
+        this.toDispose.push(this.sessionManager.onDidFocusStackFrame(stackFrame => this.handleDidFocusStackFrame(stackFrame)));
+        this.toDispose.push(this.sessionManager.onDidDestroyDebugSession(session => this.handleDidDestroyDebugSession(session)));
+    }
+
+    protected handleDidFocusStackFrame(stackFrame: DebugStackFrame | undefined): void {
+        if (this.stackFrame !== stackFrame) {
+            if (this.stackFrame) {
+                const sessionState = this.getOrCreateSessionState(this.stackFrame.session);
+                sessionState.setStateForStackFrame(this.stackFrame, this.superStoreState());
+            }
+            if (stackFrame) {
+                const sessionState = this.statePerSession.get(stackFrame.session.id);
+                if (sessionState) {
+                    const state = sessionState.getStateForStackFrame(stackFrame);
+                    if (state) {
+                        this.superRestoreState(state);
+                    }
+                }
+            }
+            this.stackFrame = stackFrame;
+        }
+    }
+
+    protected getOrCreateSessionState(session: DebugSession): DebugVariablesWidgetSessionState {
+        let sessionState = this.statePerSession.get(session.id);
+        if (!sessionState) {
+            sessionState = this.newSessionState();
+            this.statePerSession.set(session.id, sessionState);
+        }
+        return sessionState;
+    }
+
+    protected newSessionState(): DebugVariablesWidgetSessionState {
+        return new DebugVariablesWidgetSessionState();
+    }
+
+    protected handleDidDestroyDebugSession(session: DebugSession): void {
+        this.statePerSession.delete(session.id);
     }
 
     protected override handleContextMenuEvent(node: TreeNode | undefined, event: MouseEvent<HTMLElement>): void {
@@ -156,3 +203,15 @@ export class DebugVariablesWidget extends SourceTreeWidget {
         );
     }
 }
+
+export class DebugVariablesWidgetSessionState {
+    protected readonly statePerStackFrame = new Map<string, object>();
+
+    setStateForStackFrame(stackFrame: DebugStackFrame, state: object): void {
+        this.statePerStackFrame.set(stackFrame.id, state);
+    }
+
+    getStateForStackFrame(stackFrame: DebugStackFrame): object | undefined {
+        return this.statePerStackFrame.get(stackFrame.id);
+    }
+}

package/src/browser/view/debug-view-model.ts

@@ -29,6 +29,7 @@ import { DebugFunctionBreakpoint } from '../model/debug-function-breakpoint';
 import { DebugInstructionBreakpoint } from '../model/debug-instruction-breakpoint';
 import { DebugSessionOptionsBase } from '../debug-session-options';
 import { DebugDataBreakpoint } from '../model/debug-data-breakpoint';
+import { DebugVariable } from '../console/debug-console-items';
 
 @injectable()
 export class DebugViewModel implements Disposable {
@@ -46,6 +47,12 @@ export class DebugViewModel implements Disposable {
         this.onDidChangeBreakpointsEmitter.fire(uri);
     }
 
+    protected readonly onDidResolveLazyVariableEmitter = new Emitter<DebugVariable>();
+    readonly onDidResolveLazyVariable: Event<DebugVariable> = this.onDidResolveLazyVariableEmitter.event;
+    protected fireDidResolveLazyVariable(variable: DebugVariable): void {
+        this.onDidResolveLazyVariableEmitter.fire(variable);
+    }
+
     protected readonly _watchExpressions = new Map<number, DebugWatchExpression>();
 
     protected readonly onDidChangeWatchExpressionsEmitter = new Emitter<void>();
@@ -57,6 +64,7 @@ export class DebugViewModel implements Disposable {
     protected readonly toDispose = new DisposableCollection(
         this.onDidChangeEmitter,
         this.onDidChangeBreakpointsEmitter,
+        this.onDidResolveLazyVariableEmitter,
         this.onDidChangeWatchExpressionsEmitter,
     );
 
@@ -97,6 +105,11 @@ export class DebugViewModel implements Disposable {
                 this.fireDidChangeBreakpoints(uri);
             }
         }));
+        this.toDispose.push(this.manager.onDidResolveLazyVariable(({ session, variable }) => {
+            if (session === this.currentSession) {
+                this.fireDidResolveLazyVariable(variable);
+            }
+        }));
         this.updateWatchExpressions();
         this.toDispose.push(this.watch.onDidChange(() => this.updateWatchExpressions()));
     }

package/src/browser/view/debug-watch-expression.tsx

@@ -23,7 +23,7 @@ import { nls } from '@theia/core';
 
 export class DebugWatchExpression extends ExpressionItem {
 
-    readonly id: number;
+    override readonly id: number;
     protected isError: boolean;
     protected isNotAvailable: boolean;
 
@@ -34,12 +34,12 @@ export class DebugWatchExpression extends ExpressionItem {
         remove: () => void,
         onDidChange: () => void
     }) {
-        super(options.expression, options.session);
-        this.id = options.id;
+        super(options.expression, options.session, options.id);
     }
 
     override async evaluate(): Promise<void> {
         await super.evaluate('watch');
+        this.options.onDidChange();
     }
 
     protected override setResult(body?: DebugProtocol.EvaluateResponse['body'], error?: string): void {
@@ -56,14 +56,13 @@ export class DebugWatchExpression extends ExpressionItem {
             super.setResult(body, error);
             this.isError = !!error;
         }
-        this.options.onDidChange();
     }
 
     override render(): React.ReactNode {
         const valueClass = this.valueClass();
         return <div className='theia-debug-console-variable theia-debug-watch-expression'>
             <div className={TREE_NODE_SEGMENT_GROW_CLASS}>
-                <span title={this.type || this._expression} className='name'>{this._expression}: </span>
+                <span title={this.type || this._expression} className='name'>{this._expression}:</span>
                 <span title={this._value} ref={this.setValueRef} className={valueClass}>{this._value}</span>
             </div>
             <div className={codicon('close', true)} title={nls.localizeByDefault('Remove Expression')} onClick={this.options.remove} />
@@ -77,7 +76,7 @@ export class DebugWatchExpression extends ExpressionItem {
         if (this.isNotAvailable) {
             return 'watch-not-available';
         }
-        return '';
+        return 'value';
     }
 
     async open(): Promise<void> {

package/src/browser/view/debug-watch-source.ts

@@ -30,6 +30,7 @@ export class DebugWatchSource extends TreeSource {
     protected init(): void {
         this.refresh();
         this.toDispose.push(this.model.onDidChangeWatchExpressions(() => this.refresh()));
+        this.toDispose.push(this.model.onDidResolveLazyVariable(() => this.refresh()));
     }
 
     protected readonly refresh = debounce(() => this.fireDidChange(), 100);

package/src/common/debug-preferences.ts

@@ -64,7 +64,17 @@ export const debugPreferencesSchema: PreferenceSchema = {
             description: nls.localizeByDefault('Show Source Code in Disassembly View.'),
             type: 'boolean',
             default: true,
-        }
+        },
+        'debug.autoExpandLazyVariables': {
+            type: 'string',
+            enum: ['on', 'off'],
+            default: 'off',
+            enumDescriptions: [
+                nls.localizeByDefault('Always automatically expand lazy variables.'),
+                nls.localizeByDefault('Never automatically expand lazy variables.')
+            ],
+            description: nls.localizeByDefault('Controls whether variables that are lazily resolved, such as getters, are automatically resolved and expanded by the debugger.')
+        },
     }
 };
 
@@ -76,6 +86,7 @@ export class DebugConfiguration {
     'debug.showInStatusBar': 'never' | 'always' | 'onFirstSessionStart';
     'debug.confirmOnExit': 'never' | 'always';
     'debug.disassemblyView.showSourceCode': boolean;
+    'debug.autoExpandLazyVariables': 'on' | 'off';
 }
 
 export const DebugPreferenceContribution = Symbol('DebugPreferenceContribution');