@theia/debug 1.70.0-next.81 → 1.71.0-next.0

package/src/browser/model/debug-source-breakpoint.tsx

@@ -15,85 +15,36 @@
 // *****************************************************************************
 
 import * as React from '@theia/core/shared/react';
-import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
-import { CommandService, nls, RecursivePartial } from '@theia/core';
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { nls, RecursivePartial } from '@theia/core';
 import URI from '@theia/core/lib/common/uri';
 import { EditorWidget, Range } from '@theia/editor/lib/browser';
-import { TREE_NODE_INFO_CLASS, WidgetOpenerOptions, codicon } from '@theia/core/lib/browser';
+import { TREE_NODE_INFO_CLASS, WidgetOpenerOptions, codicon, open } from '@theia/core/lib/browser';
 import { TreeElement } from '@theia/core/lib/browser/source-tree';
-import { SourceBreakpoint } from '../breakpoint/breakpoint-marker';
-import { DebugSource } from './debug-source';
-import { DebugBreakpoint, DebugBreakpointOptions, DebugBreakpointData, DebugBreakpointDecoration } from './debug-breakpoint';
+import { DEBUG_BREAKPOINT_SCHEME, SourceBreakpoint } from '../breakpoint/breakpoint-marker';
+import { DebugBreakpoint, DebugBreakpointOptions, DebugBreakpointDecoration } from './debug-breakpoint';
 import { DebugCommands } from '../debug-commands';
 
-export class DebugSourceBreakpointData extends DebugBreakpointData {
-    readonly origins: SourceBreakpoint[];
-}
-
 export class DebugSourceBreakpoint extends DebugBreakpoint<SourceBreakpoint> implements TreeElement {
 
-    protected readonly commandService: CommandService;
-    readonly origins: SourceBreakpoint[];
-
-    constructor(origin: SourceBreakpoint, options: DebugBreakpointOptions, commandService: CommandService) {
-        super(new URI(origin.uri), options);
-        this.origins = [origin];
-        this.commandService = commandService;
-    }
-
-    override update(data: Partial<DebugSourceBreakpointData>): void {
-        super.update(data);
+    static create(origin: SourceBreakpoint, options: DebugBreakpointOptions): DebugSourceBreakpoint {
+        return new this(origin, options);
     }
 
-    get origin(): SourceBreakpoint {
-        return this.origins[0];
+    constructor(readonly origin: SourceBreakpoint, options: DebugBreakpointOptions) {
+        super(new URI(origin.uri), options);
     }
 
     setEnabled(enabled: boolean): void {
-        const { uri, raw } = this;
-        let shouldUpdate = false;
-        const originLine = this.origin.raw.line;
-        const originColumn = this.origin.raw.column;
-        let breakpoints = raw && this.doRemove(this.origins.filter(origin => !(origin.raw.line === originLine && origin.raw.column === originColumn)));
-        // Check for breakpoints array with at least one entry
-        if (breakpoints && breakpoints.length) {
-            shouldUpdate = true;
-        } else {
-            breakpoints = this.breakpoints.getBreakpoints(uri);
-        }
-        for (const breakpoint of breakpoints) {
-            if (breakpoint.raw.line === this.origin.raw.line && breakpoint.raw.column === this.origin.raw.column && breakpoint.enabled !== enabled) {
-                breakpoint.enabled = enabled;
-                shouldUpdate = true;
-            }
-        }
-        if (shouldUpdate) {
-            this.breakpoints.setBreakpoints(this.uri, breakpoints);
-        }
-    }
-
-    updateOrigins(data: Partial<DebugProtocol.SourceBreakpoint>): void {
-        const breakpoints = this.breakpoints.getBreakpoints(this.uri);
-        let shouldUpdate = false;
-        const originPositions = new Set();
-        this.origins.forEach(origin => originPositions.add(origin.raw.line + ':' + origin.raw.column));
-        for (const breakpoint of breakpoints) {
-            if (originPositions.has(breakpoint.raw.line + ':' + breakpoint.raw.column)) {
-                Object.assign(breakpoint.raw, data);
-                shouldUpdate = true;
-            }
-        }
-        if (shouldUpdate) {
-            this.breakpoints.setBreakpoints(this.uri, breakpoints);
-        }
+        this.breakpoints.enableBreakpoint(this, enabled);
     }
 
     /** 1-based */
     get line(): number {
-        return this.raw && this.raw.line || this.origins[0].raw.line;
+        return this.raw && this.raw.line || this.origin.raw.line;
     }
     get column(): number | undefined {
-        return this.raw && this.raw.column || this.origins[0].raw.column;
+        return this.raw && this.raw.column || this.origin.raw.column;
     }
     get endLine(): number | undefined {
         return this.raw && this.raw.endLine;
@@ -112,8 +63,8 @@ export class DebugSourceBreakpoint extends DebugBreakpoint<SourceBreakpoint> imp
         return this.origin.raw.logMessage;
     }
 
-    get source(): DebugSource | undefined {
-        return this.raw && this.raw.source && this.session && this.session.getSource(this.raw.source);
+    get source(): DebugProtocol.Source | undefined {
+        return this.raw?.source;
     }
 
     async open(options: WidgetOpenerOptions = {
@@ -132,17 +83,11 @@ export class DebugSourceBreakpoint extends DebugBreakpoint<SourceBreakpoint> imp
                 character: typeof endColumn === 'number' ? endColumn - 1 : undefined
             };
         }
-        if (this.source) {
-            return await this.source.open({
-                ...options,
-                selection
-            });
-        } else {
-            return await this.editorManager.open(this.uri, {
-                ...options,
-                selection
-            });
-        }
+        return open(
+            this.openerService,
+            URI.fromComponents({ authority: this.id, scheme: DEBUG_BREAKPOINT_SCHEME, path: '', fragment: '', query: '' }),
+            { ...options, selection }
+        ) as Promise<EditorWidget>;
     }
 
     protected override setBreakpointEnabled = (event: React.ChangeEvent<HTMLInputElement>) => {
@@ -183,23 +128,22 @@ export class DebugSourceBreakpoint extends DebugBreakpoint<SourceBreakpoint> imp
 
     override doGetDecoration(messages: string[] = []): DebugBreakpointDecoration {
         if (this.logMessage || this.condition || this.hitCondition) {
-            const { session } = this;
             if (this.logMessage) {
-                if (session && !session.capabilities.supportsLogPoints) {
+                if (this.raw && !this.raw.supportsLogPoints) {
                     return this.getUnsupportedBreakpointDecoration(nls.localize('theia/debug/logpointsNotSupported',
                         'Logpoints not supported by this debug type'));
                 }
                 messages.push(nls.localizeByDefault('Log Message: {0}', this.logMessage));
             }
             if (this.condition) {
-                if (session && !session.capabilities.supportsConditionalBreakpoints) {
+                if (this.raw && !this.raw.supportsConditionalBreakpoints) {
                     return this.getUnsupportedBreakpointDecoration(nls.localize('theia/debug/conditionalBreakpointsNotSupported',
                         'Conditional breakpoints not supported by this debug type'));
                 }
                 messages.push(nls.localizeByDefault('Condition: {0}', this.condition));
             }
             if (this.hitCondition) {
-                if (session && !session.capabilities.supportsHitConditionalBreakpoints) {
+                if (this.raw && !this.raw.supportsHitConditionalBreakpoints) {
                     return this.getUnsupportedBreakpointDecoration(nls.localize('theia/debug/htiConditionalBreakpointsNotSupported',
                         'Hit conditional breakpoints not supported by this debug type'));
                 }
@@ -236,28 +180,6 @@ export class DebugSourceBreakpoint extends DebugBreakpoint<SourceBreakpoint> imp
     }
 
     remove(): void {
-        const breakpoints = this.doRemove(this.origins);
-        if (breakpoints) {
-            this.breakpoints.setBreakpoints(this.uri, breakpoints);
-        }
+        this.breakpoints.removeBreakpoint(this);
     }
-    protected doRemove(origins: SourceBreakpoint[]): SourceBreakpoint[] | undefined {
-        if (!origins.length) {
-            return undefined;
-        }
-        const { uri } = this;
-        const toRemove = new Set();
-        origins.forEach(origin => toRemove.add(origin.raw.line + ':' + origin.raw.column));
-        let shouldUpdate = false;
-        const breakpoints = this.breakpoints.findMarkers({
-            uri,
-            dataFilter: data => {
-                const result = !toRemove.has(data.raw.line + ':' + data.raw.column);
-                shouldUpdate = shouldUpdate || !result;
-                return result;
-            }
-        }).map(({ data }) => data);
-        return shouldUpdate && breakpoints || undefined;
-    }
-
 }

package/src/browser/view/debug-breakpoints-source.tsx

@@ -18,8 +18,6 @@ import { injectable, inject, postConstruct } from '@theia/core/shared/inversify'
 import { TreeSource, TreeElement } from '@theia/core/lib/browser/source-tree';
 import { DebugViewModel } from './debug-view-model';
 import { BreakpointManager } from '../breakpoint/breakpoint-manager';
-import { DebugExceptionBreakpoint } from './debug-exception-breakpoint';
-import { CommandService } from '@theia/core/lib/common';
 
 @injectable()
 export class DebugBreakpointsSource extends TreeSource {
@@ -30,9 +28,6 @@ export class DebugBreakpointsSource extends TreeSource {
     @inject(BreakpointManager)
     protected readonly breakpoints: BreakpointManager;
 
-    @inject(CommandService)
-    protected readonly commandService: CommandService;
-
     @postConstruct()
     protected init(): void {
         this.fireDidChange();
@@ -40,12 +35,10 @@ export class DebugBreakpointsSource extends TreeSource {
     }
 
     *getElements(): IterableIterator<TreeElement> {
-        for (const exceptionBreakpoint of this.breakpoints.getExceptionBreakpoints()) {
-            yield new DebugExceptionBreakpoint(exceptionBreakpoint, this.breakpoints, this.commandService);
-        }
-        yield* this.model.dataBreakpoints;
+        yield* this.model.exceptionBreakpoints;
         yield* this.model.functionBreakpoints;
         yield* this.model.instructionBreakpoints;
+        yield* this.model.dataBreakpoints;
         yield* this.model.breakpoints;
     }
 }

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

@@ -22,6 +22,7 @@ import { DebugBreakpointsSource } from './debug-breakpoints-source';
 import { BreakpointManager } from '../breakpoint/breakpoint-manager';
 import { DebugViewModel } from './debug-view-model';
 import { nls } from '@theia/core/lib/common/nls';
+import { DebugSession } from '../debug-session';
 
 @injectable()
 export class DebugBreakpointsWidget extends SourceTreeWidget {
@@ -43,6 +44,7 @@ export class DebugBreakpointsWidget extends SourceTreeWidget {
         child.bind(DebugBreakpointsWidget).toSelf();
         return child;
     }
+
     static createWidget(parent: interfaces.Container): DebugBreakpointsWidget {
         return DebugBreakpointsWidget.createContainer(parent).get(DebugBreakpointsWidget);
     }
@@ -56,6 +58,10 @@ export class DebugBreakpointsWidget extends SourceTreeWidget {
     @inject(DebugBreakpointsSource)
     protected readonly breakpointsSource: DebugBreakpointsSource;
 
+    get currentSession(): DebugSession | undefined {
+        return this.viewModel.currentSession;
+    }
+
     @postConstruct()
     protected override init(): void {
         super.init();

package/src/browser/view/debug-exception-breakpoint.tsx

@@ -18,41 +18,47 @@ import * as React from '@theia/core/shared/react';
 import { TreeElement } from '@theia/core/lib/browser/source-tree';
 import { BreakpointManager } from '../breakpoint/breakpoint-manager';
 import { ExceptionBreakpoint } from '../breakpoint/breakpoint-marker';
-import { SingleTextInputDialog, TREE_NODE_INFO_CLASS, codicon, TreeWidget } from '@theia/core/lib/browser';
-import { SelectableTreeNode } from '@theia/core/lib/browser/tree/tree-selection';
-import { nls, CommandService } from '@theia/core';
+import { SingleTextInputDialog } from '@theia/core/lib/browser/dialogs';
+import { TREE_NODE_INFO_CLASS, codicon, TreeWidget } from '@theia/core/lib/browser';
+import { nls } from '@theia/core';
+import { DebugBreakpoint, DebugBreakpointDecoration, DebugBreakpointOptions } from '../model/debug-breakpoint';
 import { DebugCommands } from '../debug-commands';
 
-export class DebugExceptionBreakpoint implements TreeElement {
+export class DebugExceptionBreakpoint extends DebugBreakpoint<ExceptionBreakpoint> implements TreeElement {
 
-    readonly id: string;
-    protected treeWidget?: TreeWidget;
+    protected readonly sessionEnablement = new Set<string>();
+    /** Determines which exception breakpoints to show when no session is active. */
+    protected persistentlyVisible = false;
+
+    static create(origin: ExceptionBreakpoint,
+        options: DebugBreakpointOptions): DebugExceptionBreakpoint {
+        return new this(origin, options);
+    }
 
     constructor(
-        readonly data: ExceptionBreakpoint,
-        readonly breakpoints: BreakpointManager,
-        protected readonly commandService: CommandService
+        readonly origin: ExceptionBreakpoint,
+        readonly options: DebugBreakpointOptions
     ) {
-        this.id = data.raw.filter + ':' + data.raw.label;
+        super(BreakpointManager.EXCEPTION_URI, options);
     }
 
-    render(host: TreeWidget): React.ReactNode {
+    override render(host: TreeWidget): React.ReactNode {
         this.treeWidget = host;
-        return <div title={this.data.raw.description || this.data.raw.label} className='theia-source-breakpoint'>
+        return <div title={this.origin.raw.description || this.origin.raw.label} className='theia-source-breakpoint'>
             <span className='theia-debug-breakpoint-icon' />
-            <input type='checkbox' checked={this.data.enabled} onChange={this.toggle} />
+            <input type='checkbox' checked={this.origin.enabled} onChange={this.toggle} />
             <span className='line-info'>
-                <span className='name'>{this.data.raw.label} </span>
-                {this.data.condition &&
-                    <span title={nls.localizeByDefault('Expression condition: {0}', this.data.condition)}
-                        className={'path ' + TREE_NODE_INFO_CLASS}>{this.data.condition} </span>}
+                <span className='name'>{this.origin.raw.label} </span>
+                {this.origin.condition &&
+                    <span title={nls.localizeByDefault('Expression condition: {0}', this.origin.condition)}
+                        className={'path ' + TREE_NODE_INFO_CLASS}>{this.origin.condition} </span>}
             </span>
             {this.renderActions()}
         </div>;
     }
 
     protected renderActions(): React.ReactNode {
-        if (this.data.raw.supportsCondition) {
+        if (this.origin.raw.supportsCondition) {
             return <div className='theia-debug-breakpoint-actions'>
                 <div className={codicon('edit', true)} title={nls.localizeByDefault('Edit Condition...')} onClick={this.onEdit} />
             </div>;
@@ -65,19 +71,45 @@ export class DebugExceptionBreakpoint implements TreeElement {
         this.commandService.executeCommand(DebugCommands.EDIT_BREAKPOINT_CONDITION.id);
     };
 
-    protected async selectInTree(): Promise<void> {
-        if (this.treeWidget?.model && SelectableTreeNode.is(this)) {
-            this.treeWidget.model.selectNode(this);
+    setSessionEnablement(sessionId: string, enabled: boolean): void {
+        if (enabled) {
+            this.sessionEnablement.add(sessionId);
+        } else {
+            this.sessionEnablement.delete(sessionId);
         }
     }
 
-    protected toggle = () => this.breakpoints.toggleExceptionBreakpoint(this.data.raw.filter);
+    isEnabledForSession(sessionId: string): boolean {
+        return this.sessionEnablement.has(sessionId);
+    }
+
+    setPersistentVisibility(visible: boolean): void {
+        this.persistentlyVisible = visible;
+    }
+
+    isPersistentlyVisible(): boolean {
+        return this.persistentlyVisible;
+    }
+
+    protected override doRender(): React.ReactNode {
+        return undefined;
+    }
+
+    protected toggle = (e: React.ChangeEvent<HTMLInputElement>) => this.setEnabled(e.currentTarget.checked);
+
+    override setEnabled(enabled: boolean): void {
+        this.breakpoints.enableBreakpoint(this, enabled);
+    }
+
+    override remove(): void {
+        this.breakpoints.enableBreakpoint(this, false);
+    }
 
     async editCondition(): Promise<void> {
         const inputDialog = new SingleTextInputDialog({
-            title: this.data.raw.label,
-            placeholder: this.data.raw.conditionDescription,
-            initialValue: this.data.condition
+            title: this.origin.raw.label,
+            placeholder: this.origin.raw.conditionDescription,
+            initialValue: this.origin.condition
         });
         let condition = await inputDialog.open();
         if (condition === undefined) {
@@ -86,8 +118,15 @@ export class DebugExceptionBreakpoint implements TreeElement {
         if (condition === '') {
             condition = undefined;
         }
-        if (condition !== this.data.condition) {
-            this.breakpoints.updateExceptionBreakpoint(this.data.raw.filter, { condition });
+        if (condition !== this.origin.condition) {
+            this.breakpoints.updateBreakpoint(this, { condition });
         }
     }
+
+    protected override getBreakpointDecoration(message?: string[] | undefined): DebugBreakpointDecoration {
+        return {
+            className: 'never-decorated',
+            message: message ?? []
+        };
+    }
 }

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

@@ -28,6 +28,8 @@ import { DebugWatchManager } from '../debug-watch-manager';
 import { DebugFunctionBreakpoint } from '../model/debug-function-breakpoint';
 import { DebugInstructionBreakpoint } from '../model/debug-instruction-breakpoint';
 import { DebugSessionOptionsBase } from '../debug-session-options';
+import { BreakpointManager } from '../breakpoint/breakpoint-manager';
+import { DebugExceptionBreakpoint } from './debug-exception-breakpoint';
 import { DebugDataBreakpoint } from '../model/debug-data-breakpoint';
 import { DebugVariable } from '../console/debug-console-items';
 
@@ -71,6 +73,9 @@ export class DebugViewModel implements Disposable {
     @inject(DebugSessionManager)
     protected readonly manager: DebugSessionManager;
 
+    @inject(BreakpointManager)
+    protected readonly breakpointManager: BreakpointManager;
+
     @inject(DebugWatchManager)
     protected readonly watch: DebugWatchManager;
 
@@ -100,9 +105,8 @@ export class DebugViewModel implements Disposable {
             // This ensures threads view updates for all sessions
             this.fireDidChange();
         }));
-        this.toDispose.push(this.manager.onDidChangeBreakpoints(({ session, uri }) => {
-            // Fire for all sessions since we now show breakpoints from all active sessions
-            this.fireDidChangeBreakpoints(uri);
+        this.toDispose.push(this.breakpointManager.onDidChangeBreakpoints(e => {
+            this.fireDidChangeBreakpoints(e.uri);
         }));
         this.toDispose.push(this.manager.onDidResolveLazyVariable(({ session, variable }) => {
             if (session === this.currentSession) {
@@ -118,8 +122,7 @@ export class DebugViewModel implements Disposable {
     }
 
     get currentSession(): DebugSession | undefined {
-        const { currentSession } = this.manager;
-        return currentSession;
+        return this.manager.currentSession;
     }
     set currentSession(currentSession: DebugSession | undefined) {
         this.manager.currentSession = currentSession;
@@ -138,20 +141,25 @@ export class DebugViewModel implements Disposable {
         return currentThread && currentThread.currentFrame;
     }
 
-    get breakpoints(): DebugSourceBreakpoint[] {
-        return this.manager.getBreakpoints();
+    get breakpoints(): readonly DebugSourceBreakpoint[] {
+        return this.breakpointManager.getBreakpoints();
+    }
+
+    get functionBreakpoints(): readonly DebugFunctionBreakpoint[] {
+        return this.breakpointManager.getFunctionBreakpoints();
     }
 
-    get functionBreakpoints(): DebugFunctionBreakpoint[] {
-        return this.manager.getFunctionBreakpoints();
+    get instructionBreakpoints(): readonly DebugInstructionBreakpoint[] {
+        return this.breakpointManager.getInstructionBreakpoints();
     }
 
-    get instructionBreakpoints(): DebugInstructionBreakpoint[] {
-        return this.manager.getInstructionBreakpoints();
+    get exceptionBreakpoints(): readonly DebugExceptionBreakpoint[] {
+        return this.breakpointManager.getExceptionBreakpoints()
+            .filter(candidate => this.currentSession ? candidate.isEnabledForSession(this.currentSession.id) : candidate.isPersistentlyVisible());
     }
 
-    get dataBreakpoints(): DebugDataBreakpoint[] {
-        return this.manager.getDataBreakpoints(this.currentSession);
+    get dataBreakpoints(): readonly DebugDataBreakpoint[] {
+        return this.breakpointManager.getDataBreakpoints();
     }
 
     async start(options: Partial<Pick<DebugSessionOptionsBase, 'startedByUser'>> = {}): Promise<void> {