@theia/debug 1.70.0-next.81 → 1.70.0

package/src/browser/breakpoint/breakpoint-marker.ts

@@ -15,15 +15,15 @@
 // *****************************************************************************
 
 import { UUID } from '@theia/core/shared/@lumino/coreutils';
-import { Marker } from '@theia/markers/lib/common/marker';
 import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
 import { isObject, isString, URI } from '@theia/core/lib/common';
 
-export const BREAKPOINT_KIND = 'breakpoint';
+export const DEBUG_BREAKPOINT_SCHEME = 'debug-breakpoint';
 
 export interface BaseBreakpoint {
     id: string;
     enabled: boolean;
+    raw: object;
 }
 
 export interface SourceBreakpoint extends BaseBreakpoint {
@@ -44,16 +44,7 @@ export namespace SourceBreakpoint {
     }
 }
 
-export interface BreakpointMarker extends Marker<SourceBreakpoint> {
-    kind: 'breakpoint'
-}
-export namespace BreakpointMarker {
-    export function is(node: Marker<object>): node is BreakpointMarker {
-        return 'kind' in node && node.kind === BREAKPOINT_KIND;
-    }
-}
-
-export interface ExceptionBreakpoint {
+export interface ExceptionBreakpoint extends BaseBreakpoint {
     enabled: boolean;
     condition?: string;
     raw: DebugProtocol.ExceptionBreakpointsFilter;
@@ -61,7 +52,8 @@ export interface ExceptionBreakpoint {
 export namespace ExceptionBreakpoint {
     export function create(data: DebugProtocol.ExceptionBreakpointsFilter, origin?: ExceptionBreakpoint): ExceptionBreakpoint {
         return {
-            enabled: origin ? origin.enabled : false,
+            id: origin?.id ?? UUID.uuid4(),
+            enabled: origin?.enabled ?? !!data.default,
             condition: origin ? origin.condition : undefined,
             raw: {
                 ...(origin && origin.raw),
@@ -69,11 +61,23 @@ export namespace ExceptionBreakpoint {
             }
         };
     }
+
+    /** Copied from https://github.com/microsoft/vscode/blob/8934b59d4aa696b6f51ac9bf2eeae8bbac5dac03/src/vs/workbench/contrib/debug/common/debugModel.ts#L1368-L1374 */
+    export function matches(left: DebugProtocol.ExceptionBreakpointsFilter, right: DebugProtocol.ExceptionBreakpointsFilter): boolean {
+        return (
+            left.filter === right.filter &&
+            left.label === right.label &&
+            !!left.supportsCondition === !!right.supportsCondition &&
+            left.conditionDescription === right.conditionDescription &&
+            left.description === right.description
+        );
+    }
 }
 
 export interface FunctionBreakpoint extends BaseBreakpoint {
     raw: DebugProtocol.FunctionBreakpoint;
 }
+
 export namespace FunctionBreakpoint {
     export function create(data: DebugProtocol.FunctionBreakpoint, origin?: FunctionBreakpoint): FunctionBreakpoint {
         return {
@@ -87,12 +91,14 @@ export namespace FunctionBreakpoint {
     }
 }
 
-export interface InstructionBreakpoint extends BaseBreakpoint, DebugProtocol.InstructionBreakpoint { }
+export interface InstructionBreakpoint extends BaseBreakpoint {
+    raw: DebugProtocol.InstructionBreakpoint;
+}
 
 export namespace InstructionBreakpoint {
     export function create(raw: DebugProtocol.InstructionBreakpoint, existing?: InstructionBreakpoint): InstructionBreakpoint {
         return {
-            ...raw,
+            raw,
             id: existing?.id ?? UUID.uuid4(),
             enabled: existing?.enabled ?? true,
         };

package/src/browser/breakpoint/debug-data-breakpoint-actions.ts

@@ -95,7 +95,7 @@ export class AddOrEditDataBreakpointAddress implements CommandHandler {
 
         const src: DataBreakpointSource = { type: DataBreakpointSourceType.Address, ...range };
         if (existingBreakpoint) {
-            this.breakpointManager.removeDataBreakpoint(existingBreakpoint.id);
+            this.breakpointManager.removeDataBreakpoint(existingBreakpoint);
         }
 
         this.breakpointManager.addDataBreakpoint(DataBreakpoint.create({ dataId: info.dataId, accessType }, { ...info, canPersist: true }, src));

package/src/browser/debug-frontend-application-contribution.ts

@@ -25,7 +25,7 @@ import { waitForEvent } from '@theia/core/lib/common/promise-util';
 import { EDITOR_CONTEXT_MENU, EDITOR_LINENUMBER_CONTEXT_MENU, EditorManager } from '@theia/editor/lib/browser';
 import { DebugSessionManager } from './debug-session-manager';
 import { DebugWidget } from './view/debug-widget';
-import { FunctionBreakpoint, SourceBreakpoint } from './breakpoint/breakpoint-marker';
+import { SourceBreakpoint } from './breakpoint/breakpoint-marker';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
 import { DebugConfigurationManager } from './debug-configuration-manager';
 import { DebugState, DebugSession } from './debug-session';
@@ -499,11 +499,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isEnabled: () => !!this.editors.model && !this.editors.anyBreakpoint()
         });
         registry.registerCommand(DebugCommands.ADD_FUNCTION_BREAKPOINT, {
-            execute: async () => {
-                const { labelProvider, breakpointManager, editorManager } = this;
-                const options = { labelProvider, breakpoints: breakpointManager, editorManager };
-                await new DebugFunctionBreakpoint(FunctionBreakpoint.create({ name: '' }), options).open();
-            },
+            execute: async () => DebugFunctionBreakpoint.editOrCreate(this.breakpointManager),
             isEnabled: widget => !(widget instanceof Widget) || widget instanceof DebugBreakpointsWidget,
             isVisible: widget => !(widget instanceof Widget) || widget instanceof DebugBreakpointsWidget
         });
@@ -557,8 +553,8 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
                     await selectedExceptionBreakpoint.editCondition();
                 }
             },
-            isEnabled: () => !!this.selectedExceptionBreakpoint?.data.raw.supportsCondition,
-            isVisible: () => !!this.selectedExceptionBreakpoint?.data.raw.supportsCondition
+            isEnabled: () => this.selectedBreakpoints.length === 1 && !!this.selectedExceptionBreakpoint?.origin.raw.supportsCondition,
+            isVisible: () => this.selectedBreakpoints.length === 1 && !!this.selectedExceptionBreakpoint?.origin.raw.supportsCondition
         });
         registry.registerCommand(DebugCommands.REMOVE_BREAKPOINT, {
             execute: () => {
@@ -1057,16 +1053,15 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             return;
         }
         const breakpoint = SourceBreakpoint.create(uri, { line, column });
-        let shouldRemoveBreakpoint = this.breakpointManager.addBreakpoint(breakpoint);
+        const breakpointsBefore = this.breakpointManager.getBreakpoints(uri);
+        const breakpointToRemove = this.breakpointManager.addBreakpoint(breakpoint);
+        const breakpointsAfter = this.breakpointManager.getBreakpoints(uri);
+        let shouldRemoveBreakpoint = breakpointsBefore.length !== breakpointsAfter.length;
         const removeBreakpoint = () => {
-            const breakpoints = this.breakpointManager.getBreakpoints(uri);
-            const newBreakpoints = breakpoints.filter(bp => bp.id !== breakpoint.id);
-            if (breakpoints.length !== newBreakpoints.length) {
-                this.breakpointManager.setBreakpoints(uri, newBreakpoints);
-            }
+            breakpointToRemove.remove();
         };
         try {
-            const sessionBreakpoint = await this.verifyBreakpoint(breakpoint, thread.session);
+            const sessionBreakpoint = await this.verifyBreakpoint(breakpointToRemove, thread.session);
             if (!checkThread()) {
                 return;
             }
@@ -1105,21 +1100,21 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         }
     }
 
-    protected async verifyBreakpoint(breakpoint: SourceBreakpoint, session: DebugSession, timeout = 2000): Promise<DebugBreakpoint | undefined> {
-        let sessionBreakpoint = session.getBreakpoint(breakpoint.id);
-        if (!sessionBreakpoint || !sessionBreakpoint.installed || !sessionBreakpoint.verified) {
+    protected async verifyBreakpoint(breakpoint: DebugSourceBreakpoint, session: DebugSession, timeout = 2000): Promise<DebugBreakpoint> {
+        if (!breakpoint.getDebugProtocolBreakpoint(session.id)?.verified) {
             try {
-                await waitForEvent(Event.filter(session.onDidChangeBreakpoints, () => {
-                    sessionBreakpoint = session.getBreakpoint(breakpoint.id);
-                    return !!sessionBreakpoint && sessionBreakpoint.installed && sessionBreakpoint.verified;
-                }), timeout); // wait up to `timeout` ms for the breakpoint to become installed and verified
+                await waitForEvent(Event.filter(
+                    this.breakpointManager.onDidChangeBreakpoints,
+                    () => breakpoint.getDebugProtocolBreakpoint(session.id)?.verified),
+                    timeout // wait up to `timeout` ms for the breakpoint to become installed and verified
+                );
             } catch (e) {
                 if (!(e instanceof CancellationError)) { // ignore the `CancellationError` on timeout
                     throw e;
                 }
             }
         }
-        return sessionBreakpoint;
+        return breakpoint;
     }
 
     get threads(): DebugThreadsWidget | undefined {

package/src/browser/debug-frontend-module.ts

@@ -22,7 +22,8 @@ import { DebugWidget } from './view/debug-widget';
 import { DebugPath, DebugService } from '../common/debug-service';
 import {
     WidgetFactory, WebSocketConnectionProvider, FrontendApplicationContribution,
-    bindViewContribution
+    bindViewContribution,
+    OpenHandler
 } from '@theia/core/lib/browser';
 import { DebugSessionManager } from './debug-session-manager';
 import { DebugResourceResolver } from './debug-resource';
@@ -66,6 +67,7 @@ import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/brow
 import { DebugSessionConfigurationLabelProvider } from './debug-session-configuration-label-provider';
 import { AddOrEditDataBreakpointAddress } from './breakpoint/debug-data-breakpoint-actions';
 import { WorkspaceRestrictionContribution, WorkspaceRestriction } from '@theia/workspace/lib/browser/workspace-trust-service';
+import { DebugBreakpointOpener } from './model/debug-breakpoint-opener';
 
 export default new ContainerModule((bind: interfaces.Bind) => {
     bindRootContributionProvider(bind, DebugContribution);
@@ -138,6 +140,8 @@ export default new ContainerModule((bind: interfaces.Bind) => {
 
     bind(DebugSessionConfigurationLabelProvider).toSelf().inSingletonScope();
     bind(AddOrEditDataBreakpointAddress).toSelf().inSingletonScope();
+    bind(DebugBreakpointOpener).toSelf().inSingletonScope();
+    bind(OpenHandler).toService(DebugBreakpointOpener);
 
     bind(WorkspaceRestrictionContribution).toConstantValue({
         getRestrictions(): WorkspaceRestriction[] {

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

@@ -14,35 +14,30 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandService, DisposableCollection, Emitter, Event, MessageService, nls, ProgressService, WaitUntilEvent } from '@theia/core';
-import { LabelProvider, ApplicationShell, ConfirmDialog } from '@theia/core/lib/browser';
-import { WindowService } from '@theia/core/lib/browser/window/window-service';
-import { WorkspaceTrustService } from '@theia/workspace/lib/browser';
+import { DisposableCollection, Emitter, Event, MessageService, nls, ProgressService, WaitUntilEvent } from '@theia/core';
+import { ApplicationShell, ConfirmDialog } from '@theia/core/lib/browser';
 import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
+import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import URI from '@theia/core/lib/common/uri';
-import { EditorManager } from '@theia/editor/lib/browser';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as monaco from '@theia/monaco-editor-core';
 import { QuickOpenTask } from '@theia/task/lib/browser/quick-open-task';
-import { TaskService, TaskEndedInfo, TaskEndedTypes } from '@theia/task/lib/browser/task-service';
+import { TaskEndedInfo, TaskEndedTypes, TaskService } from '@theia/task/lib/browser/task-service';
+import { TaskIdentifier } from '@theia/task/lib/common';
 import { VariableResolverService } from '@theia/variable-resolver/lib/browser';
-import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { WorkspaceTrustService } from '@theia/workspace/lib/browser';
 import { DebugConfiguration } from '../common/debug-common';
 import { DebugPreferences } from '../common/debug-preferences';
 import { DebugError, DebugService } from '../common/debug-service';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
+import { DebugVariable } from './console/debug-console-items';
 import { DebugConfigurationManager } from './debug-configuration-manager';
 import { DebugSession, DebugState, debugStateContextValue } from './debug-session';
+import { DebugSessionConfigurationLabelProvider } from './debug-session-configuration-label-provider';
 import { DebugSessionContributionRegistry, DebugSessionFactory } from './debug-session-contribution';
 import { DebugCompoundRoot, DebugCompoundSessionOptions, DebugConfigurationSessionOptions, DebugSessionOptions, InternalDebugSessionOptions } from './debug-session-options';
 import { DebugStackFrame } from './model/debug-stack-frame';
 import { DebugThread } from './model/debug-thread';
-import { TaskIdentifier } from '@theia/task/lib/common';
-import { DebugSourceBreakpoint } from './model/debug-source-breakpoint';
-import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
-import * as monaco from '@theia/monaco-editor-core';
-import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint';
-import { DebugSessionConfigurationLabelProvider } from './debug-session-configuration-label-provider';
-import { DebugDataBreakpoint } from './model/debug-data-breakpoint';
-import { DebugVariable } from './console/debug-console-items';
 
 export interface WillStartDebugSession extends WaitUntilEvent {
 }
@@ -106,12 +101,6 @@ export class DebugSessionManager {
     protected readonly onDidFocusThreadEmitter = new Emitter<DebugThread | undefined>();
     readonly onDidFocusThread = this.onDidFocusThreadEmitter.event;
 
-    protected readonly onDidChangeBreakpointsEmitter = new Emitter<DidChangeBreakpointsEvent>();
-    readonly onDidChangeBreakpoints = this.onDidChangeBreakpointsEmitter.event;
-    protected fireDidChangeBreakpoints(event: DidChangeBreakpointsEvent): void {
-        this.onDidChangeBreakpointsEmitter.fire(event);
-    }
-
     protected readonly onDidChangeEmitter = new Emitter<DebugSession | undefined>();
     readonly onDidChange: Event<DebugSession | undefined> = this.onDidChangeEmitter.event;
     protected fireDidChange(current: DebugSession | undefined): void {
@@ -130,15 +119,6 @@ export class DebugSessionManager {
     @inject(DebugService)
     protected readonly debug: DebugService;
 
-    @inject(LabelProvider)
-    protected readonly labelProvider: LabelProvider;
-
-    @inject(EditorManager)
-    protected readonly editorManager: EditorManager;
-
-    @inject(CommandService)
-    protected commandService: CommandService;
-
     @inject(BreakpointManager)
     protected readonly breakpoints: BreakpointManager;
 
@@ -190,15 +170,6 @@ export class DebugSessionManager {
         this.debugTypeKey = this.contextKeyService.createKey<string>('debugType', undefined);
         this.inDebugModeKey = this.contextKeyService.createKey<boolean>('inDebugMode', this.inDebugMode);
         this.debugStateKey = this.contextKeyService.createKey<string>('debugState', debugStateContextValue(this.state));
-        this.breakpoints.onDidChangeMarkers(uri => this.fireDidChangeBreakpoints({ uri }));
-        this.labelProvider.onDidChange(event => {
-            for (const uriString of this.breakpoints.getUris()) {
-                const uri = new URI(uriString);
-                if (event.affects(uri)) {
-                    this.fireDidChangeBreakpoints({ uri });
-                }
-            }
-        });
     }
 
     get inDebugMode(): boolean {
@@ -463,7 +434,6 @@ export class DebugSessionManager {
             // The selection logic in widgets will handle not jumping to non-stopped threads
             this.fireDidChange(session);
         });
-        session.onDidChangeBreakpoints(uri => this.fireDidChangeBreakpoints({ session, uri }));
         session.on('terminated', async event => {
             const restart = event.body && event.body.restart;
             if (restart) {
@@ -499,17 +469,16 @@ export class DebugSessionManager {
     }
 
     protected cleanup(session: DebugSession): void {
-        // Data breakpoints belonging to this session that can't persist and aren't verified by some other session should be removed.
+        // Data breakpoints that can't persist should be removed when a session ends.
         const currentDataBreakpoints = this.breakpoints.getDataBreakpoints();
-        const toRemove = currentDataBreakpoints.filter(candidate => !candidate.info.canPersist && this.sessions.every(otherSession => otherSession !== session
-            && otherSession.getDataBreakpoints().every(otherSessionBp => otherSessionBp.id !== candidate.id || !otherSessionBp.verified)))
-            .map(bp => bp.id);
-        const toRetain = this.breakpoints.getDataBreakpoints().filter(candidate => !toRemove.includes(candidate.id));
+        const toRetain = currentDataBreakpoints.filter(candidate => candidate.origin.info.canPersist);
         if (currentDataBreakpoints.length !== toRetain.length) {
-            this.breakpoints.setDataBreakpoints(toRetain);
+            this.breakpoints.setDataBreakpoints(toRetain.map(bp => bp.origin));
         }
         if (this.remove(session.id)) {
             this.onDidDestroyDebugSessionEmitter.fire(session);
+            this.breakpoints.updateSessionData(session.id, session.capabilities);
+            this.breakpoints.clearExceptionSessionEnablement(session.id);
         }
     }
 
@@ -599,7 +568,6 @@ export class DebugSessionManager {
             const { currentThread } = current;
             this.onDidFocusThreadEmitter.fire(currentThread);
         }
-        this.updateBreakpoints(previous, current);
         this.open();
         this.fireDidChange(current);
     }
@@ -616,22 +584,6 @@ export class DebugSessionManager {
             }
         }
     }
-    protected updateBreakpoints(previous: DebugSession | undefined, current: DebugSession | undefined): void {
-        const affectedUri = new Set();
-        for (const session of [previous, current]) {
-            if (session) {
-                for (const uriString of session.breakpointUris) {
-                    if (!affectedUri.has(uriString)) {
-                        affectedUri.add(uriString);
-                        this.fireDidChangeBreakpoints({
-                            session: current,
-                            uri: new URI(uriString)
-                        });
-                    }
-                }
-            }
-        }
-    }
     protected updateCurrentSession(session: DebugSession | undefined): void {
         this.currentSession = session || this.sessions[0];
     }
@@ -655,90 +607,6 @@ export class DebugSessionManager {
         return currentThread && currentThread.topFrame;
     }
 
-    getFunctionBreakpoints(session?: DebugSession): DebugFunctionBreakpoint[] {
-        if (session && session.state > DebugState.Initializing) {
-            return session.getFunctionBreakpoints();
-        }
-        const { labelProvider, breakpoints, editorManager } = this;
-        return this.breakpoints.getFunctionBreakpoints().map(origin => new DebugFunctionBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
-    }
-
-    getInstructionBreakpoints(session?: DebugSession): DebugInstructionBreakpoint[] {
-        if (session && session.state > DebugState.Initializing) {
-            return session.getInstructionBreakpoints();
-        }
-        const { labelProvider, breakpoints, editorManager } = this;
-        return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
-    }
-
-    getDataBreakpoints(session = this.currentSession): DebugDataBreakpoint[] {
-        if (session && session.state > DebugState.Initializing) {
-            return session.getDataBreakpoints();
-        }
-        const { labelProvider, breakpoints, editorManager } = this;
-        return this.breakpoints.getDataBreakpoints().map(origin => new DebugDataBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
-    }
-
-    getBreakpoints(session?: DebugSession): DebugSourceBreakpoint[];
-    getBreakpoints(uri: URI, session?: DebugSession): DebugSourceBreakpoint[];
-    getBreakpoints(arg?: URI | DebugSession, arg2?: DebugSession): DebugSourceBreakpoint[] {
-        const uri = arg instanceof URI ? arg : undefined;
-        const session = arg instanceof DebugSession ? arg : arg2 instanceof DebugSession ? arg2 : undefined;
-        if (session && session.state > DebugState.Initializing) {
-            return session.getSourceBreakpoints(uri);
-        }
-
-        const activeSessions = this.sessions.filter(s => s.state > DebugState.Initializing);
-
-        // Start with all breakpoints from markers (not installed = shows as filled circle)
-        const { labelProvider, breakpoints, editorManager } = this;
-        const breakpointMap = new Map<string, DebugSourceBreakpoint>();
-        const markers = this.breakpoints.findMarkers({ uri });
-
-        for (const { data } of markers) {
-            const bp = new DebugSourceBreakpoint(data, { labelProvider, breakpoints, editorManager }, this.commandService);
-            breakpointMap.set(bp.id, bp);
-        }
-
-        // Overlay with VERIFIED breakpoints from active sessions only
-        // We only replace a marker-based breakpoint if the session has VERIFIED it
-        // This ensures breakpoints show as filled (not installed) rather than hollow (installed but unverified)
-        for (const activeSession of activeSessions) {
-            const sessionBps = activeSession.getSourceBreakpoints(uri);
-
-            for (const bp of sessionBps) {
-                if (bp.verified) {
-                    // Session has verified this breakpoint - use the session's version
-                    breakpointMap.set(bp.id, bp);
-                }
-                // If not verified, keep the marker-based one (shows as not installed = filled circle)
-            }
-        }
-
-        return Array.from(breakpointMap.values());
-    }
-
-    getLineBreakpoints(uri: URI, line: number): DebugSourceBreakpoint[] {
-        const session = this.currentSession;
-        if (session && session.state > DebugState.Initializing) {
-            return session.getSourceBreakpoints(uri).filter(breakpoint => breakpoint.line === line);
-        }
-        const { labelProvider, breakpoints, editorManager } = this;
-        return this.breakpoints.getLineBreakpoints(uri, line).map(origin =>
-            new DebugSourceBreakpoint(origin, { labelProvider, breakpoints, editorManager }, this.commandService)
-        );
-    }
-
-    getInlineBreakpoint(uri: URI, line: number, column: number): DebugSourceBreakpoint | undefined {
-        const session = this.currentSession;
-        if (session && session.state > DebugState.Initializing) {
-            return session.getSourceBreakpoints(uri).filter(breakpoint => breakpoint.line === line && breakpoint.column === column)[0];
-        }
-        const origin = this.breakpoints.getInlineBreakpoint(uri, line, column);
-        const { labelProvider, breakpoints, editorManager } = this;
-        return origin && new DebugSourceBreakpoint(origin, { labelProvider, breakpoints, editorManager }, this.commandService);
-    }
-
     /**
      * Runs the given tasks.
      * @param taskName the task name to run, see [TaskNameResolver](#TaskNameResolver)