@theia/debug 1.70.0-next.81 → 1.70.1

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

@@ -14,29 +14,35 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as deepEqual from 'fast-deep-equal';
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { Emitter } from '@theia/core/lib/common';
-import { StorageService } from '@theia/core/lib/browser';
-import { Marker } from '@theia/markers/lib/common/marker';
-import { MarkerManager } from '@theia/markers/lib/browser/marker-manager';
+import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { CommandService, Emitter, Event, MapUtils } from '@theia/core/lib/common';
+import { LabelProvider, OpenerService, StorageService } from '@theia/core/lib/browser';
 import URI from '@theia/core/lib/common/uri';
-import { SourceBreakpoint, BREAKPOINT_KIND, ExceptionBreakpoint, FunctionBreakpoint, BaseBreakpoint, InstructionBreakpoint, DataBreakpoint } from './breakpoint-marker';
+import { SourceBreakpoint, ExceptionBreakpoint, FunctionBreakpoint, BaseBreakpoint, InstructionBreakpoint, DataBreakpoint } from './breakpoint-marker';
+import { DebugSourceBreakpoint } from '../model/debug-source-breakpoint';
+import { DebugFunctionBreakpoint } from '../model/debug-function-breakpoint';
+import { DebugInstructionBreakpoint } from '../model/debug-instruction-breakpoint';
+import { DebugExceptionBreakpoint } from '../view/debug-exception-breakpoint';
+import { DebugDataBreakpoint } from '../model/debug-data-breakpoint';
+import { BPCapabilities, DebugBreakpoint, DebugBreakpointOptions } from '../model/debug-breakpoint';
 import { DebugProtocol } from '@vscode/debugprotocol';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { FileChangeType } from '@theia/filesystem/lib/common/files';
 
-export interface BreakpointsChangeEvent<T extends BaseBreakpoint> {
+export interface BreakpointsChangeEvent<T extends object> {
     uri: URI
     added: T[]
     removed: T[]
     changed: T[]
 }
-export type SourceBreakpointsChangeEvent = BreakpointsChangeEvent<SourceBreakpoint>;
-export type FunctionBreakpointsChangeEvent = BreakpointsChangeEvent<FunctionBreakpoint>;
-export type InstructionBreakpointsChangeEvent = BreakpointsChangeEvent<InstructionBreakpoint>;
-export type DataBreakpointsChangeEvent = BreakpointsChangeEvent<DataBreakpoint>;
+
+export type SourceBreakpointsChangeEvent = BreakpointsChangeEvent<DebugSourceBreakpoint>;
+export type FunctionBreakpointsChangeEvent = BreakpointsChangeEvent<DebugFunctionBreakpoint>;
+export type InstructionBreakpointsChangeEvent = BreakpointsChangeEvent<DebugInstructionBreakpoint>;
+export type DataBreakpointsChangeEvent = BreakpointsChangeEvent<DebugDataBreakpoint>;
 
 @injectable()
-export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
+export class BreakpointManager {
 
     static EXCEPTION_URI = new URI('debug:exception://');
 
@@ -46,13 +52,36 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
 
     static DATA_URI = new URI('debug:data://');
 
-    protected readonly owner = 'breakpoint';
+    // ── Source breakpoints, keyed by URI string ──
+
+    protected readonly sourceBreakpoints = new Map<string, DebugSourceBreakpoint[]>();
+
+    // ── Injected services ──
 
     @inject(StorageService)
     protected readonly storage: StorageService;
-
-    getKind(): string {
-        return BREAKPOINT_KIND;
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+    @inject(CommandService)
+    protected readonly commandService: CommandService;
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    // ── Events ──
+
+    protected readonly onDidChangeMarkersEmitter = new Emitter<URI>();
+    /**
+     * Fires when any breakpoint type changes (source, function, instruction, data, or exception).
+     * The URI identifies the affected resource or the synthetic URI for non-source breakpoint types
+     * (e.g. {@link BreakpointManager.FUNCTION_URI}).
+     */
+    get onDidChangeMarkers(): Event<URI> {
+        return this.onDidChangeMarkersEmitter.event;
+    }
+    protected fireOnDidChangeMarkers(uri: URI): void {
+        this.onDidChangeMarkersEmitter.fire(uri);
     }
 
     protected readonly onDidChangeBreakpointsEmitter = new Emitter<SourceBreakpointsChangeEvent>();
@@ -67,174 +96,482 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
     protected readonly onDidChangeDataBreakpointsEmitter = new Emitter<DataBreakpointsChangeEvent>();
     readonly onDidChangeDataBreakpoints = this.onDidChangeDataBreakpointsEmitter.event;
 
-    override setMarkers(uri: URI, owner: string, newMarkers: SourceBreakpoint[]): Marker<SourceBreakpoint>[] {
-        const result = this.findMarkers({ uri, owner });
-        const added: SourceBreakpoint[] = [];
-        const removed: SourceBreakpoint[] = [];
-        const changed: SourceBreakpoint[] = [];
-        const oldMarkers = new Map(result.map(({ data }) => [data.id, data]));
-        const ids = new Set<string>();
-        let didChangeMarkers = false;
-        for (const newMarker of newMarkers) {
-            ids.add(newMarker.id);
-            const oldMarker = oldMarkers.get(newMarker.id);
-            if (!oldMarker) {
-                added.push(newMarker);
+    // ── Cached options object ──
+
+    protected _breakpointOptions: DebugBreakpointOptions | undefined;
+
+    // ── Initialization ──
+
+    @postConstruct()
+    protected init(): void {
+        this.fileService.onDidFilesChange(event => {
+            if (event.gotDeleted()) {
+                for (const uriString of this.sourceBreakpoints.keys()) {
+                    const uri = new URI(uriString);
+                    if (event.contains(uri, FileChangeType.DELETED)) {
+                        this.sourceBreakpoints.delete(uriString);
+                        this.fireOnDidChangeMarkers(uri);
+                    }
+                }
+            }
+        });
+    }
+
+    // ── Source breakpoint storage ──
+
+    getBreakpoints(uri?: URI): readonly DebugSourceBreakpoint[] {
+        if (uri) {
+            return this.sourceBreakpoints.get(uri.toString()) ?? [];
+        }
+        const result: DebugSourceBreakpoint[] = [];
+        for (const bps of this.sourceBreakpoints.values()) {
+            result.push(...bps);
+        }
+        return result;
+    }
+
+    getUris(): IterableIterator<string> {
+        return this.sourceBreakpoints.keys();
+    }
+
+    hasBreakpoints(): boolean {
+        return this.sourceBreakpoints.size > 0 || this.functionBreakpoints.length > 0 || this.instructionBreakpoints.length > 0;
+    }
+
+    /**
+     * Replace the source breakpoints for a URI. Incoming `breakpoints` are
+     * plain `SourceBreakpoint` data; existing `DebugSourceBreakpoint` wrappers
+     * are preserved by ID so that session data survives position changes.
+     */
+    setBreakpoints(uri: URI, breakpoints: SourceBreakpoint[]): void {
+        const current = this.getBreakpoints(uri);
+        const currentById = new Map(current.map(bp => [bp.id, bp]));
+
+        const sorted = breakpoints
+            .slice()
+            .sort((a, b) => (a.raw.line - b.raw.line) || ((a.raw.column || 0) - (b.raw.column || 0)));
+
+        const seen = new Set<string>();
+        const newBps: DebugSourceBreakpoint[] = [];
+        for (const bp of sorted) {
+            const posKey = `${bp.raw.line}:${bp.raw.column ?? 0}`;
+            if (seen.has(posKey)) { continue; }
+            seen.add(posKey);
+
+            // Prefer matching by ID (preserves identity across position changes).
+            const existing = currentById.get(bp.id);
+            if (existing) {
+                existing.origin.raw = bp.raw;
+                existing.origin.enabled = bp.enabled;
+                newBps.push(existing);
             } else {
-                // We emit all existing markers as 'changed', but we only fire an event if something really did change.
-                // We also fire an event if oldMarker === newMarker, as we cannot actually detect a change in this case
-                // (https://github.com/eclipse-theia/theia/issues/12546).
-                didChangeMarkers ||= !!added.length || oldMarker === newMarker || !deepEqual(oldMarker, newMarker);
-                changed.push(newMarker);
+                newBps.push(this.toDebugSourceBreakpoint(bp));
             }
         }
-        for (const [id, data] of oldMarkers.entries()) {
-            if (!ids.has(id)) {
-                removed.push(data);
+
+        this.applySourceBreakpoints(uri, newBps, current);
+    }
+
+    addBreakpoint(breakpoint: SourceBreakpoint): DebugSourceBreakpoint {
+        const uri = new URI(breakpoint.uri);
+        const current = this.getBreakpoints(uri);
+
+        // Check for positional duplicate.
+        const duplicate = current.find(
+            c => c.line === breakpoint.raw.line && c.column === breakpoint.raw.column
+        );
+        if (duplicate) { return duplicate; }
+
+        const bp = this.toDebugSourceBreakpoint(breakpoint);
+        const newBps = [...current, bp];
+        this.applySourceBreakpoints(uri, newBps, current);
+        return bp;
+    }
+
+    removeBreakpoint(breakpoint: DebugSourceBreakpoint): void {
+        const current = this.getBreakpoints(breakpoint.uri);
+        const index = current.indexOf(breakpoint);
+        if (index === -1) { return; }
+        const retained = [...current.slice(0, index), ...current.slice(index + 1)];
+        this.applySourceBreakpoints(breakpoint.uri, retained, current);
+    }
+
+    /**
+     * Diff `oldBps` → `newBps`, store, fire markers and typed events.
+     * Both arrays must be for the same URI.
+     */
+    protected applySourceBreakpoints(uri: URI, newBps: readonly DebugSourceBreakpoint[], oldBps: readonly DebugSourceBreakpoint[]): void {
+        const oldById = new Map(oldBps.map(bp => [bp.id, bp]));
+        const added: DebugSourceBreakpoint[] = [];
+        const changed: DebugSourceBreakpoint[] = [];
+        let didChange = false;
+        for (const bp of newBps) {
+            const old = oldById.get(bp.id);
+            if (!old) {
+                added.push(bp);
+                didChange = true;
+            } else {
+                changed.push(bp);
+                // Identity match: the wrapper was mutated in place, or the same
+                // object was passed back (editor model position update).
+                // Either way we must re-fire to keep decorations in sync.
+                didChange = true;
+                oldById.delete(bp.id);
             }
         }
-        if (added.length || removed.length || didChangeMarkers) {
-            super.setMarkers(uri, owner, newMarkers);
-            this.onDidChangeBreakpointsEmitter.fire({ uri, added, removed, changed });
+        const removed = Array.from(oldById.values());
+        didChange ||= removed.length > 0;
+
+        if (!didChange) { return; }
+
+        if (newBps.length > 0) {
+            this.sourceBreakpoints.set(uri.toString(), [...newBps]);
+        } else {
+            this.sourceBreakpoints.delete(uri.toString());
         }
-        return result;
+        this.fireOnDidChangeMarkers(uri);
+        this.onDidChangeBreakpointsEmitter.fire({ uri, added, removed, changed });
     }
 
-    getLineBreakpoints(uri: URI, line: number): SourceBreakpoint[] {
-        return this.findMarkers({
-            uri,
-            dataFilter: breakpoint => breakpoint.raw.line === line
-        }).map(({ data }) => data);
+    removeBreakpoints(): void {
+        for (const uriString of [...this.sourceBreakpoints.keys()]) {
+            const uri = new URI(uriString);
+            const old = this.sourceBreakpoints.get(uriString) ?? [];
+            this.sourceBreakpoints.delete(uriString);
+            this.fireOnDidChangeMarkers(uri);
+            if (old.length) {
+                this.onDidChangeBreakpointsEmitter.fire({ uri, added: [], removed: old, changed: [] });
+            }
+        }
+        this.setFunctionBreakpoints([]);
+        this.setInstructionBreakpoints([]);
+        this.setDataBreakpoints([]);
     }
 
-    getInlineBreakpoint(uri: URI, line: number, column: number): SourceBreakpoint | undefined {
-        const marker = this.findMarkers({
-            uri,
-            dataFilter: breakpoint => breakpoint.raw.line === line && breakpoint.raw.column === column
-        })[0];
-        return marker && marker.data;
+    // ── Query helpers ──
+
+    getLineBreakpoints(uri: URI, line: number): DebugSourceBreakpoint[] {
+        return this.getBreakpoints(uri).filter(bp => bp.line === line);
     }
 
-    getBreakpoints(uri?: URI): SourceBreakpoint[] {
-        return this.findMarkers({ uri }).map(marker => marker.data);
+    getInlineBreakpoint(uri: URI, line: number, column: number): DebugSourceBreakpoint | undefined {
+        return this.getBreakpoints(uri).find(bp => bp.line === line && bp.column === column);
     }
 
-    setBreakpoints(uri: URI, breakpoints: SourceBreakpoint[]): void {
-        this.setMarkers(uri, this.owner, breakpoints.sort((a, b) => (a.raw.line - b.raw.line) || ((a.raw.column || 0) - (b.raw.column || 0))));
+    getBreakpointById(id: string): DebugBreakpoint | undefined {
+        for (const bp of this.allBreakpoints()) {
+            if (bp.id === id) { return bp; }
+        }
     }
 
-    addBreakpoint(breakpoint: SourceBreakpoint): boolean {
-        const uri = new URI(breakpoint.uri);
-        const breakpoints = this.getBreakpoints(uri);
-        const newBreakpoints = breakpoints.filter(({ raw }) => !(raw.line === breakpoint.raw.line && raw.column === breakpoint.raw.column));
-        if (breakpoints.length === newBreakpoints.length) {
-            newBreakpoints.push(breakpoint);
-            this.setBreakpoints(uri, newBreakpoints);
-            return true;
+    * allBreakpoints(): IterableIterator<DebugBreakpoint> {
+        for (const bps of this.sourceBreakpoints.values()) {
+            yield* bps;
+        }
+        yield* this.functionBreakpoints;
+        yield* this.instructionBreakpoints;
+        yield* this.exceptionBreakpoints;
+        yield* this.dataBreakpoints;
+    }
+
+    // ── Session data ──
+
+    updateSessionData(sessionId: string, sessionCapabilities: DebugProtocol.Capabilities, bps?: Map<string, DebugProtocol.Breakpoint>): void {
+        const bpCapabilities = this.toBpCapabilities(sessionCapabilities);
+        const updatedUris = new Map<string, DebugBreakpoint[]>();
+        for (const bp of this.allBreakpoints()) {
+            if (!bps) {
+                if (bp.update(sessionId, undefined)) {
+                    MapUtils.addOrInsertWith(updatedUris, bp.uri.toString(), bp);
+                }
+            } else {
+                const dataForBp = bps.get(bp.id);
+                if (!dataForBp) { continue; }
+                bp.update(sessionId, { ...bpCapabilities, ...dataForBp });
+                MapUtils.addOrInsertWith(updatedUris, bp.uri.toString(), bp);
+            }
+        }
+        for (const changed of updatedUris.values()) {
+            this.fireTypedBreakpointEvent(changed[0].uri, [], changed, []);
+        }
+    }
+
+    protected toBpCapabilities(capabilities: DebugProtocol.Capabilities): BPCapabilities {
+        return {
+            supportsConditionalBreakpoints: !!capabilities.supportsConditionalBreakpoints,
+            supportsHitConditionalBreakpoints: !!capabilities.supportsHitConditionalBreakpoints,
+            supportsLogPoints: !!capabilities.supportsLogPoints,
+            supportsFunctionBreakpoints: !!capabilities.supportsFunctionBreakpoints,
+            supportsDataBreakpoints: !!capabilities.supportsDataBreakpoints,
+            supportsInstructionBreakpoints: !!capabilities.supportsInstructionBreakpoints,
+        };
+    }
+
+    // ── Breakpoint construction ──
+
+    protected toDebugSourceBreakpoint(source: SourceBreakpoint): DebugSourceBreakpoint {
+        return DebugSourceBreakpoint.create(source, this.getBreakpointOptions());
+    }
+
+    getBreakpointOptions(): DebugBreakpointOptions {
+        if (!this._breakpointOptions) {
+            this._breakpointOptions = {
+                labelProvider: this.labelProvider,
+                openerService: this.openerService,
+                commandService: this.commandService,
+                breakpoints: this
+            };
+        }
+        return this._breakpointOptions;
+    }
+
+    // ── Enable / disable ──
+
+    protected _breakpointsEnabled = true;
+
+    get breakpointsEnabled(): boolean {
+        return this._breakpointsEnabled;
+    }
+
+    set breakpointsEnabled(breakpointsEnabled: boolean) {
+        if (this._breakpointsEnabled !== breakpointsEnabled) {
+            this._breakpointsEnabled = breakpointsEnabled;
+            for (const uri of this.getUris()) {
+                this.fireOnDidChangeMarkers(new URI(uri));
+            }
+            this.fireOnDidChangeMarkers(BreakpointManager.FUNCTION_URI);
+            this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
+            this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+            this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
         }
-        return false;
     }
 
     enableAllBreakpoints(enabled: boolean): void {
         for (const uriString of this.getUris()) {
             let didChange = false;
             const uri = new URI(uriString);
-            const markers = this.findMarkers({ uri });
-            for (const marker of markers) {
-                if (marker.data.enabled !== enabled) {
-                    marker.data.enabled = enabled;
-                    didChange = true;
-                }
+            const bps = this.getBreakpoints(uri);
+            for (const bp of bps) {
+                didChange ||= this.doEnableBreakpoint(bp, enabled);
             }
             if (didChange) {
                 this.fireOnDidChangeMarkers(uri);
+                this.onDidChangeBreakpointsEmitter.fire({ uri, added: [], removed: [], changed: [...bps] });
             }
         }
         let didChangeFunction = false;
-        for (const breakpoint of (this.getFunctionBreakpoints() as BaseBreakpoint[]).concat(this.getInstructionBreakpoints())) {
-            if (breakpoint.enabled !== enabled) {
-                breakpoint.enabled = enabled;
+        for (const breakpoint of this.functionBreakpoints) {
+            if (breakpoint.origin.enabled !== enabled) {
+                breakpoint.origin.enabled = enabled;
                 didChangeFunction = true;
-
             }
         }
         if (didChangeFunction) {
             this.fireOnDidChangeMarkers(BreakpointManager.FUNCTION_URI);
+            this.onDidChangeFunctionBreakpointsEmitter.fire({
+                uri: BreakpointManager.FUNCTION_URI, added: [], removed: [], changed: [...this.functionBreakpoints]
+            });
+        }
+        let didChangeInstruction = false;
+        for (const breakpoint of this.instructionBreakpoints) {
+            if (breakpoint.origin.enabled !== enabled) {
+                breakpoint.origin.enabled = enabled;
+                didChangeInstruction = true;
+            }
+        }
+        if (didChangeInstruction) {
+            this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
+            this.onDidChangeInstructionBreakpointsEmitter.fire({
+                uri: BreakpointManager.INSTRUCTION_URI, added: [], removed: [], changed: [...this.instructionBreakpoints]
+            });
+        }
+        let didChangeData = false;
+        for (const breakpoint of this.dataBreakpoints) {
+            if (breakpoint.origin.enabled !== enabled) {
+                breakpoint.origin.enabled = enabled;
+                didChangeData = true;
+            }
+        }
+        if (didChangeData) {
+            this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+            this.onDidChangeDataBreakpointsEmitter.fire({
+                uri: BreakpointManager.DATA_URI, added: [], removed: [], changed: [...this.dataBreakpoints]
+            });
         }
     }
 
-    protected _breakpointsEnabled = true;
-    get breakpointsEnabled(): boolean {
-        return this._breakpointsEnabled;
+    enableBreakpoint<T extends DebugBreakpoint>(breakpoint: T, enabled: boolean): void {
+        const didChange = this.doEnableBreakpoint(breakpoint, enabled);
+        if (didChange) {
+            this.fireBreakpointChanged(breakpoint);
+        }
     }
-    set breakpointsEnabled(breakpointsEnabled: boolean) {
-        if (this._breakpointsEnabled !== breakpointsEnabled) {
-            this._breakpointsEnabled = breakpointsEnabled;
-            for (const uri of this.getUris()) {
-                this.fireOnDidChangeMarkers(new URI(uri));
-            }
-            this.fireOnDidChangeMarkers(BreakpointManager.FUNCTION_URI);
+
+    protected doEnableBreakpoint(breakpoint: DebugBreakpoint, enabled: boolean): boolean {
+        if (breakpoint.origin.enabled !== enabled) {
+            breakpoint.origin.enabled = enabled;
+            return true;
         }
+        return false;
     }
 
-    protected readonly exceptionBreakpoints = new Map<string, ExceptionBreakpoint>();
+    // ── Generic update / fire ──
 
-    getExceptionBreakpoint(filter: string): ExceptionBreakpoint | undefined {
-        return this.exceptionBreakpoints.get(filter);
+    updateBreakpoint<U extends BaseBreakpoint, T extends DebugBreakpoint<U>>(bp: T, update: Partial<U['raw']>): void {
+        bp.origin.raw = { ...bp.origin.raw, ...update };
+        this.fireBreakpointChanged(bp);
     }
 
-    getExceptionBreakpoints(): IterableIterator<ExceptionBreakpoint> {
-        return this.exceptionBreakpoints.values();
+    fireBreakpointChanged(breakpoint: DebugBreakpoint): void {
+        this.fireOnDidChangeMarkers(breakpoint.uri);
+        this.fireTypedBreakpointEvent(breakpoint.uri, [], [breakpoint], []);
     }
 
-    setExceptionBreakpoints(exceptionBreakpoints: ExceptionBreakpoint[]): void {
-        const toRemove = new Set(this.exceptionBreakpoints.keys());
-        for (const exceptionBreakpoint of exceptionBreakpoints) {
-            const filter = exceptionBreakpoint.raw.filter;
-            toRemove.delete(filter);
-            this.exceptionBreakpoints.set(filter, exceptionBreakpoint);
+    protected fireTypedBreakpointEvent(uri: URI, added: DebugBreakpoint[], changed: DebugBreakpoint[], removed: DebugBreakpoint[]): void {
+        // All breakpoints in a single call are the same type (grouped by URI).
+        const sample = added[0] ?? changed[0] ?? removed[0];
+        if (!sample) { return; }
+        if (sample instanceof DebugSourceBreakpoint) {
+            this.onDidChangeBreakpointsEmitter.fire({ uri, added, changed, removed } as SourceBreakpointsChangeEvent);
+        } else if (sample instanceof DebugFunctionBreakpoint) {
+            this.onDidChangeFunctionBreakpointsEmitter.fire({ uri, added, changed, removed } as FunctionBreakpointsChangeEvent);
+        } else if (sample instanceof DebugInstructionBreakpoint) {
+            this.onDidChangeInstructionBreakpointsEmitter.fire({ uri, added, changed, removed } as InstructionBreakpointsChangeEvent);
+        } else if (sample instanceof DebugDataBreakpoint) {
+            this.onDidChangeDataBreakpointsEmitter.fire({ uri, added, changed, removed } as DataBreakpointsChangeEvent);
         }
-        for (const filter of toRemove) {
-            this.exceptionBreakpoints.delete(filter);
+    }
+
+    // ── Bulk remove by ID (plugin API) ──
+
+    removeBreakpointsById(ids: string[]): void {
+        const toRemove = new Set(ids);
+
+        // Source breakpoints
+        for (const [uriString, bps] of this.sourceBreakpoints.entries()) {
+            const retained = bps.filter(bp => !toRemove.has(bp.id));
+            if (retained.length !== bps.length) {
+                const removed = bps.filter(bp => toRemove.has(bp.id));
+                const uri = new URI(uriString);
+                if (retained.length > 0) {
+                    this.sourceBreakpoints.set(uriString, retained);
+                } else {
+                    this.sourceBreakpoints.delete(uriString);
+                }
+                this.fireOnDidChangeMarkers(uri);
+                this.onDidChangeBreakpointsEmitter.fire({ uri, removed, added: [], changed: [] });
+            }
         }
-        if (toRemove.size || exceptionBreakpoints.length) {
-            this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
+
+        // Function breakpoints
+        const functionRemoved: DebugFunctionBreakpoint[] = [];
+        this.functionBreakpoints = this.functionBreakpoints.filter(bp => {
+            if (toRemove.has(bp.id)) {
+                functionRemoved.push(bp);
+                return false;
+            }
+            return true;
+        });
+        if (functionRemoved.length) {
+            this.fireOnDidChangeMarkers(BreakpointManager.FUNCTION_URI);
+            this.onDidChangeFunctionBreakpointsEmitter.fire({ uri: BreakpointManager.FUNCTION_URI, removed: functionRemoved, added: [], changed: [] });
+        }
+
+        // Instruction breakpoints
+        const instructionRemoved: DebugInstructionBreakpoint[] = [];
+        this.instructionBreakpoints = this.instructionBreakpoints.filter(bp => {
+            if (toRemove.has(bp.id)) {
+                instructionRemoved.push(bp);
+                return false;
+            }
+            return true;
+        });
+        if (instructionRemoved.length) {
+            this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
+            this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, removed: instructionRemoved, added: [], changed: [] });
+        }
+
+        // Data breakpoints
+        const dataRemoved: DebugDataBreakpoint[] = [];
+        this.dataBreakpoints = this.dataBreakpoints.filter(bp => {
+            if (toRemove.has(bp.id)) {
+                dataRemoved.push(bp);
+                return false;
+            }
+            return true;
+        });
+        if (dataRemoved.length) {
+            this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+            this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, removed: dataRemoved, added: [], changed: [] });
         }
     }
 
-    toggleExceptionBreakpoint(filter: string): void {
-        const breakpoint = this.getExceptionBreakpoint(filter);
-        if (breakpoint) {
-            breakpoint.enabled = !breakpoint.enabled;
-            this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
+    // ── Exception breakpoints ──
+
+    protected exceptionBreakpoints = new Array<DebugExceptionBreakpoint>();
+
+    getExceptionBreakpoint(filter: DebugProtocol.ExceptionBreakpointsFilter): DebugExceptionBreakpoint | undefined {
+        return this.exceptionBreakpoints.find(candidate => ExceptionBreakpoint.matches(candidate.origin.raw, filter));
+    }
+
+    getExceptionBreakpoints(): readonly DebugExceptionBreakpoint[] {
+        return this.exceptionBreakpoints;
+    }
+
+    addExceptionBreakpoints(filters: DebugProtocol.ExceptionBreakpointsFilter[], sessionId: string): void {
+        for (const filter of filters) {
+            let bp = this.exceptionBreakpoints.find(candidate => ExceptionBreakpoint.matches(candidate.origin.raw, filter));
+            if (!bp) {
+                bp = DebugExceptionBreakpoint.create(ExceptionBreakpoint.create(filter), this.getBreakpointOptions());
+                this.exceptionBreakpoints.push(bp);
+            }
+            bp.setSessionEnablement(sessionId, true);
+            this.doUpdateExceptionBreakpointVisibility(sessionId);
         }
+        this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
     }
 
-    updateExceptionBreakpoint(filter: string, options: Partial<Pick<ExceptionBreakpoint, 'condition' | 'enabled'>>): void {
-        const breakpoint = this.getExceptionBreakpoint(filter);
-        if (breakpoint) {
-            Object.assign(breakpoint, options);
-            this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
+    updateExceptionBreakpointVisibility(sessionId: string): void {
+        this.doUpdateExceptionBreakpointVisibility(sessionId);
+        this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
+    }
+
+    clearExceptionSessionEnablement(sessionId: string): void {
+        for (const bp of this.exceptionBreakpoints) {
+            bp.setSessionEnablement(sessionId, false);
+        }
+        this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
+    }
+
+    protected doUpdateExceptionBreakpointVisibility(sessionId: string): void {
+        for (const bp of this.exceptionBreakpoints) {
+            bp.setPersistentVisibility(bp.isEnabledForSession(sessionId));
         }
     }
 
-    protected functionBreakpoints: FunctionBreakpoint[] = [];
+    // ── Function breakpoints ──
 
-    getFunctionBreakpoints(): FunctionBreakpoint[] {
+    protected functionBreakpoints: DebugFunctionBreakpoint[] = [];
+
+    getFunctionBreakpoints(): readonly DebugFunctionBreakpoint[] {
         return this.functionBreakpoints;
     }
 
     setFunctionBreakpoints(functionBreakpoints: FunctionBreakpoint[]): void {
-        const oldBreakpoints = new Map(this.functionBreakpoints.map(b => [b.id, b] as [string, FunctionBreakpoint]));
+        const oldBreakpoints = new Map(this.functionBreakpoints.map(b => [b.id, b]));
 
-        this.functionBreakpoints = functionBreakpoints;
+        this.functionBreakpoints = functionBreakpoints.map(bp => {
+            const existing = oldBreakpoints.get(bp.id);
+            if (existing) { return existing; }
+            return DebugFunctionBreakpoint.create(bp, this.getBreakpointOptions());
+        });
         this.fireOnDidChangeMarkers(BreakpointManager.FUNCTION_URI);
 
-        const added: FunctionBreakpoint[] = [];
-        const removed: FunctionBreakpoint[] = [];
-        const changed: FunctionBreakpoint[] = [];
+        const added: DebugFunctionBreakpoint[] = [];
+        const removed: DebugFunctionBreakpoint[] = [];
+        const changed: DebugFunctionBreakpoint[] = [];
         const ids = new Set<string>();
-        for (const newBreakpoint of functionBreakpoints) {
+        for (const newBreakpoint of this.functionBreakpoints) {
             ids.add(newBreakpoint.id);
             if (oldBreakpoints.has(newBreakpoint.id)) {
                 changed.push(newBreakpoint);
@@ -250,50 +587,102 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
         this.onDidChangeFunctionBreakpointsEmitter.fire({ uri: BreakpointManager.FUNCTION_URI, added, removed, changed });
     }
 
-    protected instructionBreakpoints: InstructionBreakpoint[] = [];
+    addFunctionBreakpoint(bp: FunctionBreakpoint): void {
+        const duplicate = this.functionBreakpoints.find(c => c.origin.raw.name === bp.raw.name);
+        if (duplicate) { return; }
+        const newBp = DebugFunctionBreakpoint.create(bp, this.getBreakpointOptions());
+        this.functionBreakpoints = [...this.functionBreakpoints, newBp];
+        this.fireOnDidChangeMarkers(newBp.uri);
+        this.onDidChangeFunctionBreakpointsEmitter.fire({ uri: newBp.uri, added: [newBp], changed: [], removed: [] });
+    }
+
+    updateFunctionBreakpoint(bp: DebugFunctionBreakpoint, update: Partial<DebugProtocol.FunctionBreakpoint>): void {
+        if (!this.functionBreakpoints.includes(bp)) { return; }
+        const removed: DebugFunctionBreakpoint[] = [];
+        if ('name' in update && !update.name) {
+            throw new Error('Name field of function breakpoint must be populated.');
+        } else if ('name' in update) {
+            this.functionBreakpoints = this.functionBreakpoints.filter(candidate => {
+                if (candidate !== bp && candidate.origin.raw.name === update.name) {
+                    removed.push(candidate);
+                    return false;
+                }
+                return true;
+            });
+        }
+        bp.origin.raw = { ...bp.origin.raw, ...update };
+        this.fireOnDidChangeMarkers(bp.uri);
+        this.onDidChangeFunctionBreakpointsEmitter.fire({ uri: bp.uri, changed: [bp], removed, added: [] });
+    }
 
-    getInstructionBreakpoints(): ReadonlyArray<InstructionBreakpoint> {
-        return Object.freeze(this.instructionBreakpoints.slice());
+    removeFunctionBreakpoint(breakpoint: DebugFunctionBreakpoint): void {
+        const index = this.functionBreakpoints.indexOf(breakpoint);
+        if (index === -1) { return; }
+        const removed = this.functionBreakpoints.splice(index, 1);
+        this.fireOnDidChangeMarkers(breakpoint.uri);
+        this.onDidChangeFunctionBreakpointsEmitter.fire({ uri: breakpoint.uri, removed, added: [], changed: [] });
     }
 
-    hasBreakpoints(): boolean {
-        return Boolean(this.getUris().next().value || this.functionBreakpoints.length || this.instructionBreakpoints.length);
+    // ── Instruction breakpoints ──
+
+    protected instructionBreakpoints: DebugInstructionBreakpoint[] = [];
+
+    getInstructionBreakpoints(): ReadonlyArray<DebugInstructionBreakpoint> {
+        return this.instructionBreakpoints;
     }
 
     protected setInstructionBreakpoints(newBreakpoints: InstructionBreakpoint[]): void {
-        const { added, removed, changed } = diff(this.instructionBreakpoints, newBreakpoints, bp => bp.id);
-        this.instructionBreakpoints = newBreakpoints.slice();
+        const oldBreakpoints = new Map(this.instructionBreakpoints.map(bp => [bp.id, bp]));
+        const currentBreakpoints = newBreakpoints.map(bp => {
+            const existing = oldBreakpoints.get(bp.id);
+            if (existing) { return existing; }
+            return DebugInstructionBreakpoint.create(bp, this.getBreakpointOptions());
+        });
+        const added: DebugInstructionBreakpoint[] = [];
+        const changed: DebugInstructionBreakpoint[] = [];
+        for (const breakpoint of currentBreakpoints) {
+            const old = oldBreakpoints.get(breakpoint.id);
+            if (old) {
+                changed.push(old);
+            } else {
+                added.push(breakpoint);
+            }
+            oldBreakpoints.delete(breakpoint.id);
+        }
+        const removed = Array.from(oldBreakpoints.values());
+        this.instructionBreakpoints = currentBreakpoints;
         this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
         this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, added, removed, changed });
     }
 
     addInstructionBreakpoint(address: string, offset: number, condition?: string, hitCondition?: string): void {
-        this.setInstructionBreakpoints(this.instructionBreakpoints.concat(InstructionBreakpoint.create({
+        const duplicate = this.instructionBreakpoints.find(
+            c => c.origin.raw.instructionReference === address && (c.origin.raw.offset ?? 0) === (offset ?? 0)
+        );
+        if (duplicate) { return; }
+        const newBp = DebugInstructionBreakpoint.create(InstructionBreakpoint.create({
             instructionReference: address,
             offset,
             condition,
             hitCondition,
-        })));
+        }), this.getBreakpointOptions());
+        this.instructionBreakpoints = [...this.instructionBreakpoints, newBp];
+        this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
+        this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, added: [newBp], removed: [], changed: [] });
     }
 
-    updateInstructionBreakpoint(id: string, options: Partial<Pick<InstructionBreakpoint, 'condition' | 'hitCondition' | 'enabled'>>): void {
-        const breakpoint = this.instructionBreakpoints.find(candidate => id === candidate.id);
-        if (breakpoint) {
-            Object.assign(breakpoint, options);
-            this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
-            this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, changed: [breakpoint], added: [], removed: [] });
-        }
+    removeInstructionBreakpoint(breakpoint: DebugInstructionBreakpoint): void {
+        const index = this.instructionBreakpoints.indexOf(breakpoint);
+        if (index === -1) { return; }
+        const removed = this.instructionBreakpoints.splice(index, 1);
+        this.fireOnDidChangeMarkers(breakpoint.uri);
+        this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: breakpoint.uri, removed, added: [], changed: [] });
     }
 
-    removeInstructionBreakpoint(address?: string): void {
-        if (!address) {
-            this.clearInstructionBreakpoints();
-        }
-        const breakpointIndex = this.instructionBreakpoints.findIndex(breakpoint => breakpoint.instructionReference === address);
-        if (breakpointIndex !== -1) {
-            const removed = this.instructionBreakpoints.splice(breakpointIndex, 1);
-            this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
-            this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, added: [], changed: [], removed });
+    removeInstructionBreakpointAt(address: string): void {
+        const match = this.instructionBreakpoints.find(candidate => candidate.origin.raw.instructionReference === address);
+        if (match) {
+            this.removeInstructionBreakpoint(match);
         }
     }
 
@@ -301,46 +690,66 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
         this.setInstructionBreakpoints([]);
     }
 
-    protected dataBreakpoints: DataBreakpoint[] = [];
+    // ── Data breakpoints ──
 
-    getDataBreakpoints(): readonly DataBreakpoint[] {
-        return Object.freeze(this.dataBreakpoints.slice());
+    protected dataBreakpoints: DebugDataBreakpoint[] = [];
+
+    getDataBreakpoints(): readonly DebugDataBreakpoint[] {
+        return this.dataBreakpoints;
     }
 
     setDataBreakpoints(breakpoints: DataBreakpoint[]): void {
-        const { added, removed, changed } = diff(this.dataBreakpoints, breakpoints, ({ id }) => id);
-        this.dataBreakpoints = breakpoints.slice();
+        const oldBreakpoints = new Map(this.dataBreakpoints.map(bp => [bp.id, bp]));
+        const newBreakpoints = breakpoints.map(bp => {
+            const existing = oldBreakpoints.get(bp.id);
+            if (existing) { return existing; }
+            return DebugDataBreakpoint.create(bp, this.getBreakpointOptions());
+        });
+        const added: DebugDataBreakpoint[] = [];
+        const changed: DebugDataBreakpoint[] = [];
+        for (const bp of newBreakpoints) {
+            if (oldBreakpoints.has(bp.id)) {
+                changed.push(bp);
+            } else {
+                added.push(bp);
+            }
+            oldBreakpoints.delete(bp.id);
+        }
+        const removed = Array.from(oldBreakpoints.values());
+        this.dataBreakpoints = newBreakpoints;
         this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
         this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added, removed, changed });
     }
 
     addDataBreakpoint(breakpoint: DataBreakpoint): void {
-        this.setDataBreakpoints(this.dataBreakpoints.concat(breakpoint));
+        const duplicate = this.dataBreakpoints.find(c => c.origin.raw.dataId === breakpoint.raw.dataId);
+        if (duplicate) { return; }
+        const newBp = DebugDataBreakpoint.create(breakpoint, this.getBreakpointOptions());
+        this.dataBreakpoints = [...this.dataBreakpoints, newBp];
+        this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+        this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added: [newBp], removed: [], changed: [] });
     }
 
-    updateDataBreakpoint(id: string, options: { enabled?: boolean; raw?: Partial<Omit<DebugProtocol.DataBreakpoint, 'dataId'>> }): void {
-        const breakpoint = this.dataBreakpoints.find(bp => bp.id === id);
-        if (!breakpoint) { return; }
-        Object.assign(breakpoint.raw, options);
-        breakpoint.enabled = options.enabled ?? breakpoint.enabled;
-        this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
-        this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added: [], removed: [], changed: [breakpoint] });
+    updateDataBreakpoint(bp: DebugDataBreakpoint, options: { enabled?: boolean; raw?: Partial<Omit<DebugProtocol.DataBreakpoint, 'dataId'>> }): void {
+        if (!this.dataBreakpoints.includes(bp)) { return; }
+        if (options.raw) {
+            Object.assign(bp.origin.raw, options.raw);
+        }
+        if (options.enabled !== undefined) {
+            bp.origin.enabled = options.enabled;
+        }
+        this.fireBreakpointChanged(bp);
     }
 
-    removeDataBreakpoint(id: string): void {
-        const index = this.dataBreakpoints.findIndex(bp => bp.id === id);
+    removeDataBreakpoint(bp: DebugDataBreakpoint): void {
+        const index = this.dataBreakpoints.indexOf(bp);
         if (index < 0) { return; }
-        const removed = this.dataBreakpoints.splice(index);
+        const removed = this.dataBreakpoints.splice(index, 1);
         this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
         this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added: [], removed, changed: [] });
     }
 
-    removeBreakpoints(): void {
-        this.cleanAllMarkers();
-        this.setFunctionBreakpoints([]);
-        this.setInstructionBreakpoints([]);
-        this.setDataBreakpoints([]);
-    }
+    // ── Persistence ──
 
     async load(): Promise<void> {
         const data = await this.storage.getData<BreakpointManager.Data>('breakpoints', {
@@ -356,11 +765,15 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
             this.setFunctionBreakpoints(data.functionBreakpoints);
         }
         if (data.exceptionBreakpoints) {
-            this.setExceptionBreakpoints(data.exceptionBreakpoints);
+            this.exceptionBreakpoints = data.exceptionBreakpoints.map(bp => DebugExceptionBreakpoint.create(bp, this.getBreakpointOptions()));
+            this.fireOnDidChangeMarkers(BreakpointManager.EXCEPTION_URI);
         }
         if (data.instructionBreakpoints) {
             this.setInstructionBreakpoints(data.instructionBreakpoints);
         }
+        if (data.dataBreakpoints) {
+            this.setDataBreakpoints(data.dataBreakpoints);
+        }
     }
 
     save(): void {
@@ -368,28 +781,27 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
             breakpointsEnabled: this._breakpointsEnabled,
             breakpoints: {}
         };
-        const uris = this.getUris();
-        for (const uri of uris) {
-            data.breakpoints[uri] = this.findMarkers({ uri: new URI(uri) }).map(marker => marker.data);
+        for (const uri of this.getUris()) {
+            data.breakpoints[uri] = (this.sourceBreakpoints.get(uri) ?? []).map(bp => bp.origin);
         }
         if (this.functionBreakpoints.length) {
-            data.functionBreakpoints = this.functionBreakpoints;
+            data.functionBreakpoints = this.functionBreakpoints.map(({ origin }) => origin);
         }
-        if (this.exceptionBreakpoints.size) {
-            data.exceptionBreakpoints = [...this.exceptionBreakpoints.values()];
+        if (this.exceptionBreakpoints.length) {
+            data.exceptionBreakpoints = this.exceptionBreakpoints.filter(candidate => candidate.isPersistentlyVisible()).map(({ origin }) => origin);
         }
         if (this.instructionBreakpoints.length) {
-            data.instructionBreakpoints = this.instructionBreakpoints;
+            data.instructionBreakpoints = this.instructionBreakpoints.map(({ origin }) => origin);
         }
-        const dataBreakpointsToStore = this.dataBreakpoints.filter(candidate => candidate.info.canPersist);
+        const dataBreakpointsToStore = this.dataBreakpoints.filter(candidate => candidate.origin.info.canPersist);
         if (dataBreakpointsToStore.length) {
-            data.dataBreakpoints = dataBreakpointsToStore;
+            data.dataBreakpoints = dataBreakpointsToStore.map(({ origin }) => origin);
         }
 
         this.storage.setData('breakpoints', data);
     }
-
 }
+
 export namespace BreakpointManager {
     export interface Data {
         breakpointsEnabled: boolean;
@@ -402,21 +814,3 @@ export namespace BreakpointManager {
         dataBreakpoints?: DataBreakpoint[];
     }
 }
-
-export function diff<T>(prevs: T[], nexts: T[], toKey: (member: T) => string): { added: T[], removed: T[], changed: T[] } {
-    const old = new Map(prevs.map(item => [toKey(item), item]));
-    const current = new Map(nexts.map(item => [toKey(item), item]));
-    const added = [];
-    const changed = [];
-    for (const [id, next] of current.entries()) {
-        const prev = old.get(id);
-        if (prev) {
-            changed.push(prev);
-        } else {
-            added.push(next);
-        }
-        old.delete(id);
-    }
-    const removed = Array.from(old.values());
-    return { added, removed, changed };
-}