@theia/debug 1.70.0-next.71 → 1.70.0

package/src/browser/debug-session.tsx

@@ -19,7 +19,18 @@
 import * as React from '@theia/core/shared/react';
 import { LabelProvider } from '@theia/core/lib/browser';
 import { DebugProtocol } from '@vscode/debugprotocol';
-import { Emitter, Event, DisposableCollection, Disposable, MessageClient, MessageType, Mutable, ContributionProvider, CommandService } from '@theia/core/lib/common';
+import {
+    Emitter,
+    Event,
+    DisposableCollection,
+    Disposable,
+    MessageClient,
+    MessageType,
+    Mutable,
+    ContributionProvider,
+    CommandService,
+    CancellationError
+} from '@theia/core/lib/common';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
 import { EditorManager } from '@theia/editor/lib/browser';
 import { CompositeTreeElement } from '@theia/core/lib/browser/source-tree';
@@ -28,25 +39,22 @@ import { DebugThread, StoppedDetails, DebugThreadData } from './model/debug-thre
 import { DebugScope, DebugVariable } from './console/debug-console-items';
 import { DebugStackFrame } from './model/debug-stack-frame';
 import { DebugSource } from './model/debug-source';
-import { DebugBreakpoint, DebugBreakpointOptions } from './model/debug-breakpoint';
-import { DebugSourceBreakpoint } from './model/debug-source-breakpoint';
+import { DebugBreakpoint } from './model/debug-breakpoint';
 import debounce = require('p-debounce');
 import URI from '@theia/core/lib/common/uri';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
 import { DebugConfigurationSessionOptions, InternalDebugSessionOptions, TestRunReference } from './debug-session-options';
 import { DebugConfiguration, DebugConsoleMode } from '../common/debug-common';
-import { SourceBreakpoint, ExceptionBreakpoint } from './breakpoint/breakpoint-marker';
+import { SourceBreakpoint } from './breakpoint/breakpoint-marker';
 import { TerminalWidgetOptions, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
-import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { DebugContribution } from './debug-contribution';
 import { Deferred, waitForEvent } from '@theia/core/lib/common/promise-util';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
-import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint';
 import { nls } from '@theia/core';
 import { TestService, TestServices } from '@theia/test/lib/browser/test-service';
 import { DebugSessionManager } from './debug-session-manager';
-import { DebugDataBreakpoint } from './model/debug-data-breakpoint';
+
 import { DebugPreferences } from '../common/debug-preferences';
 
 export enum DebugState {
@@ -98,12 +106,6 @@ export class DebugSession implements CompositeTreeElement {
         return this.onDidFocusThreadEmitter.event;
     }
 
-    protected readonly onDidChangeBreakpointsEmitter = new Emitter<URI>();
-    readonly onDidChangeBreakpoints: Event<URI> = this.onDidChangeBreakpointsEmitter.event;
-    protected fireDidChangeBreakpoints(uri: URI): void {
-        this.onDidChangeBreakpointsEmitter.fire(uri);
-    }
-
     protected readonly onDidResolveLazyVariableEmitter = new Emitter<DebugVariable>();
     readonly onDidResolveLazyVariable: Event<DebugVariable> = this.onDidResolveLazyVariableEmitter.event;
 
@@ -112,6 +114,9 @@ export class DebugSession implements CompositeTreeElement {
 
     protected isStopping: boolean = false;
 
+    /** Maximum time to wait for the shell integration prompt before proceeding. */
+    protected readonly PROMPT_READY_TIMEOUT_MS = 3000;
+
     constructor(
         readonly id: string,
         readonly options: DebugConfigurationSessionOptions,
@@ -165,10 +170,8 @@ export class DebugSession implements CompositeTreeElement {
             this.onDidChangeEmitter,
             this.onDidFocusStackFrameEmitter,
             this.onDidFocusThreadEmitter,
-            this.onDidChangeBreakpointsEmitter,
             this.onDidResolveLazyVariableEmitter,
             Disposable.create(() => {
-                this.clearBreakpoints();
                 this.doUpdateThreads([]);
             }),
             this.connection,
@@ -228,7 +231,7 @@ export class DebugSession implements CompositeTreeElement {
                 sourceReference: Number(uri.query)
             };
         }
-        const name = uri.displayName;
+        const name = this.labelProvider.getName(uri);
         let path;
         const underlying = await this.fileService.toUnderlyingResource(uri);
         if (underlying.scheme === 'file') {
@@ -396,12 +399,7 @@ export class DebugSession implements CompositeTreeElement {
     protected async configure(): Promise<void> {
         await this.didReceiveCapabilities.promise;
         if (this.capabilities.exceptionBreakpointFilters) {
-            const exceptionBreakpoints = [];
-            for (const filter of this.capabilities.exceptionBreakpointFilters) {
-                const origin = this.breakpoints.getExceptionBreakpoint(filter.filter);
-                exceptionBreakpoints.push(ExceptionBreakpoint.create(filter, origin));
-            }
-            this.breakpoints.setExceptionBreakpoints(exceptionBreakpoints);
+            this.breakpoints.addExceptionBreakpoints(this.capabilities.exceptionBreakpointFilters, this.id);
         }
         // mark as initialized, so updated breakpoints are shown in editor
         this.initialized = true;
@@ -520,8 +518,21 @@ export class DebugSession implements CompositeTreeElement {
         }
 
         if (!terminal) {
-            terminal = await this.terminalServer.newTerminal(options);
+            terminal = await this.terminalServer.newTerminal({ ...options, kind: 'debug' });
             await terminal.start();
+            try {
+                if (terminal.commandHistoryState) {
+                    // delay opening of the terminal until the terminal prompt appears to prevent duplicate commands in the terminal buffer
+                    await waitForEvent(terminal.commandHistoryState.onTerminalPromptShown, this.PROMPT_READY_TIMEOUT_MS);
+                }
+            } catch (error) {
+                if (error instanceof CancellationError) {
+                    console.warn('Shell integration did not emit a prompt within the timeout; proceeding anyway.');
+                } else {
+                    console.error('Unexpected error while waiting for terminal prompt:', error);
+                    throw error;
+                }
+            }
         }
         this.terminalServer.open(terminal);
         return terminal;
@@ -611,71 +622,6 @@ export class DebugSession implements CompositeTreeElement {
         this.deferredOnDidConfigureCapabilities.resolve();
     }
 
-    protected readonly _breakpoints = new Map<string, DebugBreakpoint[]>();
-    get breakpointUris(): IterableIterator<string> {
-        return this._breakpoints.keys();
-    }
-
-    getSourceBreakpoints(uri?: URI): DebugSourceBreakpoint[] {
-        const breakpoints = [];
-        for (const breakpoint of this.getBreakpoints(uri)) {
-            if (breakpoint instanceof DebugSourceBreakpoint) {
-                breakpoints.push(breakpoint);
-            }
-        }
-        return breakpoints;
-    }
-
-    getFunctionBreakpoints(): DebugFunctionBreakpoint[] {
-        return this.getBreakpoints(BreakpointManager.FUNCTION_URI).filter((breakpoint): breakpoint is DebugFunctionBreakpoint => breakpoint instanceof DebugFunctionBreakpoint);
-    }
-
-    getInstructionBreakpoints(): DebugInstructionBreakpoint[] {
-        if (this.capabilities.supportsInstructionBreakpoints) {
-            return this.getBreakpoints(BreakpointManager.INSTRUCTION_URI)
-                .filter((breakpoint): breakpoint is DebugInstructionBreakpoint => breakpoint instanceof DebugInstructionBreakpoint);
-        }
-        return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, this.asDebugBreakpointOptions()));
-    }
-
-    getDataBreakpoints(): DebugDataBreakpoint[] {
-        if (this.capabilities.supportsDataBreakpoints) {
-            return this.getBreakpoints(BreakpointManager.DATA_URI)
-                .filter((breakpoint): breakpoint is DebugDataBreakpoint => breakpoint instanceof DebugDataBreakpoint);
-        }
-        return this.breakpoints.getDataBreakpoints().map(origin => new DebugDataBreakpoint(origin, this.asDebugBreakpointOptions()));
-    }
-
-    getBreakpoints(uri?: URI): DebugBreakpoint[] {
-        if (uri) {
-            return this._breakpoints.get(uri.toString()) || [];
-        }
-        const result = [];
-        for (const breakpoints of this._breakpoints.values()) {
-            result.push(...breakpoints);
-        }
-        return result;
-    }
-
-    getBreakpoint(id: string): DebugBreakpoint | undefined {
-        for (const breakpoints of this._breakpoints.values()) {
-            const breakpoint = breakpoints.find(b => b.id === id);
-            if (breakpoint) {
-                return breakpoint;
-            }
-
-        }
-        return undefined;
-    }
-
-    protected clearBreakpoints(): void {
-        const uris = [...this._breakpoints.keys()];
-        this._breakpoints.clear();
-        for (const uri of uris) {
-            this.fireDidChangeBreakpoints(new URI(uri));
-        }
-    }
-
     protected updatingBreakpoints = false;
 
     protected updateBreakpoint(body: DebugProtocol.BreakpointEvent['body']): void {
@@ -686,54 +632,33 @@ export class DebugSession implements CompositeTreeElement {
                 if (raw.source && typeof raw.line === 'number') {
                     const uri = DebugSource.toUri(raw.source);
                     const origin = SourceBreakpoint.create(uri, { line: raw.line, column: raw.column });
-                    if (this.breakpoints.addBreakpoint(origin)) {
-                        const breakpoints = this.getSourceBreakpoints(uri);
-                        const breakpoint = new DebugSourceBreakpoint(origin, this.asDebugBreakpointOptions(), this.commandService);
-                        breakpoint.update({ raw });
-                        breakpoints.push(breakpoint);
-                        this.setSourceBreakpoints(uri, breakpoints);
-                    }
+                    const breakpoint = this.breakpoints.addBreakpoint(origin);
+                    this.breakpoints.updateSessionData(this.id, this.capabilities, new Map<string, DebugProtocol.Breakpoint>([[breakpoint.id, raw]]));
                 }
             }
             if (body.reason === 'removed' && typeof raw.id === 'number') {
-                const toRemove = this.findBreakpoint(b => b.idFromAdapter === raw.id);
+                const toRemove = this.findBreakpoint(b => b.getIdForSession(this.id) === raw.id);
                 if (toRemove) {
                     toRemove.remove();
-                    const breakpoints = this.getBreakpoints(toRemove.uri);
-                    const index = breakpoints.indexOf(toRemove);
-                    if (index !== -1) {
-                        breakpoints.splice(index, 1);
-                        this.setBreakpoints(toRemove.uri, breakpoints);
-                    }
                 }
             }
             if (body.reason === 'changed' && typeof raw.id === 'number') {
-                const toUpdate = this.findBreakpoint(b => b.idFromAdapter === raw.id);
+                const toUpdate = this.findBreakpoint(b => b.getIdForSession(this.id) === raw.id);
                 if (toUpdate) {
-                    toUpdate.update({ raw });
-                    if (toUpdate instanceof DebugSourceBreakpoint) {
-                        const sourceBreakpoints = this.getSourceBreakpoints(toUpdate.uri);
-                        // in order to dedup again if a debugger converted line breakpoint to inline breakpoint
-                        // i.e. assigned a column to a line breakpoint
-                        this.setSourceBreakpoints(toUpdate.uri, sourceBreakpoints);
-                    } else {
-                        this.fireDidChangeBreakpoints(toUpdate.uri);
-                    }
+                    this.breakpoints.updateSessionData(this.id, this.capabilities, new Map([[toUpdate.id, raw]]));
                 }
             }
         } finally {
             this.updatingBreakpoints = false;
         }
     }
+
     protected findBreakpoint(match: (breakpoint: DebugBreakpoint) => boolean): DebugBreakpoint | undefined {
-        for (const [, breakpoints] of this._breakpoints) {
-            for (const breakpoint of breakpoints) {
-                if (match(breakpoint)) {
-                    return breakpoint;
-                }
+        for (const bp of this.breakpoints.allBreakpoints()) {
+            if (match(bp)) {
+                return bp;
             }
         }
-        return undefined;
     }
 
     protected async updateBreakpoints(options: {
@@ -763,71 +688,61 @@ export class DebugSession implements CompositeTreeElement {
     protected async sendExceptionBreakpoints(): Promise<void> {
         const filters: string[] = [];
         const filterOptions: DebugProtocol.ExceptionFilterOptions[] | undefined = this.capabilities.supportsExceptionFilterOptions ? [] : undefined;
-        for (const breakpoint of this.breakpoints.getExceptionBreakpoints()) {
-            if (breakpoint.enabled) {
-                if (filterOptions) {
-                    filterOptions.push({
-                        filterId: breakpoint.raw.filter,
-                        condition: breakpoint.condition
-                    });
-                } else {
-                    filters.push(breakpoint.raw.filter);
-                }
+        const toSend = this.breakpoints.getExceptionBreakpoints().filter(candidate => candidate.origin.enabled);
+        const updates = new Map<string, DebugProtocol.Breakpoint>();
+        for (const breakpoint of toSend) {
+            if (filterOptions) {
+                filterOptions.push({
+                    filterId: breakpoint.origin.raw.filter,
+                    condition: breakpoint.origin.condition
+                });
+            } else {
+                filters.push(breakpoint.origin.raw.filter);
             }
         }
-        await this.sendRequest('setExceptionBreakpoints', { filters, filterOptions });
+        try {
+            const res = await this.sendRequest('setExceptionBreakpoints', { filters, filterOptions });
+            res.body?.breakpoints?.forEach((bp, index) => toSend[index] && updates.set(toSend[index].id, bp));
+        } catch (err) {
+            console.error('Failed to set exception breakpoints:', err);
+            const message = (err as Error)?.message ? `${err.message}` : 'Failed to set exception breakpoints.';
+            toSend.forEach(bp => updates.set(bp.id, { verified: false, message }));
+        }
+        this.breakpoints.updateSessionData(this.id, this.capabilities, updates);
     }
 
     protected async sendFunctionBreakpoints(affectedUri: URI): Promise<void> {
-        const all = this.breakpoints.getFunctionBreakpoints().map(origin =>
-            new DebugFunctionBreakpoint(origin, this.asDebugBreakpointOptions())
-        );
+        if (!this.capabilities.supportsFunctionBreakpoints) { return; }
+        const all = this.breakpoints.getFunctionBreakpoints();
         const enabled = all.filter(b => b.enabled);
-        if (this.capabilities.supportsFunctionBreakpoints) {
-            try {
-                const response = await this.sendRequest('setFunctionBreakpoints', {
-                    breakpoints: enabled.map(b => b.origin.raw)
-                });
-                // Apparently, `body` and `breakpoints` can be missing.
-                // https://github.com/eclipse-theia/theia/issues/11885
-                // https://github.com/microsoft/vscode/blob/80004351ccf0884b58359f7c8c801c91bb827d83/src/vs/workbench/contrib/debug/browser/debugSession.ts#L448-L449
-                if (response && response.body) {
-                    response.body.breakpoints.forEach((raw, index) => {
-                        // node debug adapter returns more breakpoints sometimes
-                        if (enabled[index]) {
-                            enabled[index].update({ raw });
-                        }
-                    });
-                }
-            } catch (error) {
-                // could be error or promise rejection of DebugProtocol.SetFunctionBreakpoints
-                if (error instanceof Error) {
-                    console.error(`Error setting breakpoints: ${error.message}`);
-                } else {
-                    // handle adapters that send failed DebugProtocol.SetFunctionBreakpoints for invalid breakpoints
-                    const genericMessage: string = 'Function breakpoint not valid for current debug session';
-                    const message: string = error.message ? `${error.message}` : genericMessage;
-                    console.warn(`Could not handle function breakpoints: ${message}, disabling...`);
-                    enabled.forEach(b => b.update({
-                        raw: {
-                            verified: false,
-                            message
-                        }
-                    }));
+        const updates = new Map<string, DebugProtocol.Breakpoint>();
+        try {
+            const response = await this.sendRequest('setFunctionBreakpoints', {
+                breakpoints: enabled.map(b => b.origin.raw)
+            });
+            // Apparently, `body` and `breakpoints` can be missing.
+            // https://github.com/eclipse-theia/theia/issues/11885
+            // https://github.com/microsoft/vscode/blob/80004351ccf0884b58359f7c8c801c91bb827d83/src/vs/workbench/contrib/debug/browser/debugSession.ts#L448-L449
+            response?.body?.breakpoints.forEach((raw, index) => {
+                // node debug adapter returns more breakpoints sometimes
+                if (enabled[index]) {
+                    updates.set(enabled[index].id, raw);
                 }
-            }
+            });
+        } catch (error) {
+            const genericMessage: string = 'Function breakpoint not valid for current debug session';
+            const message: string = error.message ? `${error.message}` : genericMessage;
+            console.warn(`Could not handle function breakpoints: ${message}, disabling...`);
+            enabled.forEach(b => updates.set(b.id, { verified: false, message }));
         }
-        this.setBreakpoints(affectedUri, all);
+        this.breakpoints.updateSessionData(this.id, this.capabilities, updates);
     }
 
     protected async sendSourceBreakpoints(affectedUri: URI, sourceModified?: boolean): Promise<void> {
         const source = await this.toSource(affectedUri);
-        const known = this._breakpoints.get(affectedUri.toString());
-        const all = this.breakpoints.findMarkers({ uri: affectedUri }).map(({ data }) =>
-            known?.find((candidate): candidate is DebugSourceBreakpoint => candidate instanceof DebugSourceBreakpoint && candidate.origin.id === data.id) ??
-            new DebugSourceBreakpoint(data, this.asDebugBreakpointOptions(), this.commandService)
-        );
+        const all = this.breakpoints.getBreakpoints(affectedUri);
         const enabled = all.filter(b => b.enabled);
+        const updates = new Map<string, DebugProtocol.Breakpoint>();
         try {
             const breakpoints = enabled.map(({ origin }) => origin.raw);
             const response = await this.sendRequest('setBreakpoints', {
@@ -839,7 +754,7 @@ export class DebugSession implements CompositeTreeElement {
             response.body.breakpoints.forEach((raw, index) => {
                 // node debug adapter returns more breakpoints sometimes
                 if (enabled[index]) {
-                    enabled[index].update({ raw });
+                    updates.set(enabled[index].id, raw);
                 }
             });
         } catch (error) {
@@ -851,77 +766,44 @@ export class DebugSession implements CompositeTreeElement {
                 const genericMessage: string = 'Breakpoint not valid for current debug session';
                 const message: string = error.message ? `${error.message}` : genericMessage;
                 console.warn(`Could not handle breakpoints for ${affectedUri}: ${message}, disabling...`);
-                enabled.forEach(b => b.update({
-                    raw: {
-                        verified: false,
-                        message
-                    }
-                }));
+                enabled.forEach(b => updates.set(b.id, { verified: false, message }));
             }
         }
-        this.setSourceBreakpoints(affectedUri, all);
+        this.breakpoints.updateSessionData(this.id, this.capabilities, updates);
     }
 
     protected async sendInstructionBreakpoints(): Promise<void> {
         if (!this.capabilities.supportsInstructionBreakpoints) {
             return;
         }
-        const all = this.breakpoints.getInstructionBreakpoints().map(breakpoint => new DebugInstructionBreakpoint(breakpoint, this.asDebugBreakpointOptions()));
+        const all = this.breakpoints.getInstructionBreakpoints();
         const enabled = all.filter(breakpoint => breakpoint.enabled);
+        const updates = new Map<string, DebugProtocol.Breakpoint>();
         try {
             const response = await this.sendRequest('setInstructionBreakpoints', {
-                breakpoints: enabled.map(renderable => renderable.origin),
+                breakpoints: enabled.map(renderable => renderable.origin.raw),
             });
-            response.body.breakpoints.forEach((raw, index) => enabled[index]?.update({ raw }));
+            response.body.breakpoints.forEach((raw, index) => enabled[index] && updates.set(enabled[index].id, raw));
         } catch {
-            enabled.forEach(breakpoint => breakpoint.update({ raw: { verified: false } }));
+            enabled.forEach(breakpoint => updates.set(breakpoint.id, { verified: false }));
         }
-        this.setBreakpoints(BreakpointManager.INSTRUCTION_URI, all);
+        this.breakpoints.updateSessionData(this.id, this.capabilities, updates);
     }
 
     protected async sendDataBreakpoints(): Promise<void> {
         if (!this.capabilities.supportsDataBreakpoints) { return; }
-        const known = this._breakpoints.get(BreakpointManager.DATA_URI.toString());
-        const all = this.breakpoints.getDataBreakpoints().map<DebugDataBreakpoint>(bp =>
-            known?.find((candidate): candidate is DebugDataBreakpoint => candidate instanceof DebugDataBreakpoint && candidate.id === bp.id)
-            ?? new DebugDataBreakpoint(bp, this.asDebugBreakpointOptions())
-        );
+        const all = this.breakpoints.getDataBreakpoints();
         const enabled = all.filter(bp => bp.enabled);
+        const updates = new Map<string, DebugProtocol.Breakpoint>();
         try {
             const response = await this.sendRequest('setDataBreakpoints', {
                 breakpoints: enabled.map(({ origin }) => origin.raw)
             });
-            response.body.breakpoints.forEach((raw, index) => enabled[index].update({ raw }));
+            response.body.breakpoints.forEach((raw, index) => enabled[index] && updates.set(enabled[index].id, raw));
         } catch {
-            enabled.forEach(breakpoint => breakpoint.update({ raw: { verified: false } }));
+            enabled.forEach(breakpoint => updates.set(breakpoint.id, { verified: false }));
         }
-        this.setBreakpoints(BreakpointManager.DATA_URI, all);
-    }
-
-    protected setBreakpoints(uri: URI, breakpoints: DebugBreakpoint[]): void {
-        this._breakpoints.set(uri.toString(), breakpoints);
-        this.fireDidChangeBreakpoints(uri);
-    }
-
-    protected setSourceBreakpoints(uri: URI, breakpoints: DebugSourceBreakpoint[]): void {
-        const distinct = this.dedupSourceBreakpoints(breakpoints);
-        this.setBreakpoints(uri, distinct);
-    }
-
-    protected dedupSourceBreakpoints(all: DebugSourceBreakpoint[]): DebugSourceBreakpoint[] {
-        const positions = new Map<string, DebugSourceBreakpoint>();
-        for (const breakpoint of all) {
-            let primary = positions.get(breakpoint.renderPosition()) || breakpoint;
-            if (primary !== breakpoint) {
-                let secondary = breakpoint;
-                if (secondary.raw && secondary.raw.line === secondary.origin.raw.line && secondary.raw.column === secondary.origin.raw.column) {
-                    [primary, secondary] = [breakpoint, primary];
-                }
-                primary.origins.push(...secondary.origins);
-            }
-            positions.set(primary.renderPosition(), primary);
-        }
-        return [...positions.values()];
+        this.breakpoints.updateSessionData(this.id, this.capabilities, updates);
     }
 
     protected *getAffectedUris(uri?: URI): IterableIterator<URI> {
@@ -937,11 +819,6 @@ export class DebugSession implements CompositeTreeElement {
         }
     }
 
-    protected asDebugBreakpointOptions(): DebugBreakpointOptions {
-        const { labelProvider, breakpoints, editorManager } = this;
-        return { labelProvider, breakpoints, editorManager, session: this };
-    }
-
     get label(): string {
         const suffixes = [];
         if (InternalDebugSessionOptions.is(this.options) && this.options.id) {

package/src/browser/disassembly-view/disassembly-view-breakpoint-renderer.ts

@@ -69,7 +69,7 @@ export class BreakpointRenderer implements ITableRenderer<DisassembledInstructio
                     // click show hint while waiting for BP to resolve.
                     icon.classList.add(this._breakpointHintIcon);
                     if (currentElement.element.isBreakpointSet) {
-                        this._debugService.removeInstructionBreakpoint(currentElement.element.instruction.address);
+                        this._debugService.removeInstructionBreakpointAt(currentElement.element.instruction.address);
 
                     } else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
                         this._debugService.addInstructionBreakpoint(currentElement.element.instruction.address, 0);

package/src/browser/disassembly-view/disassembly-view-widget.ts

@@ -168,40 +168,34 @@ export class DisassemblyViewWidget extends BaseWidget {
                 // draw viewable BP
                 let changed = false;
                 bpEvent.added?.forEach(bp => {
-                    if (InstructionBreakpoint.is(bp)) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
-                        if (index >= 0) {
-                            this._disassembledInstructions!.row(index).isBreakpointSet = true;
-                            this._disassembledInstructions!.row(index).isBreakpointEnabled = bp.enabled;
-                            changed = true;
-                        }
+                    const index = this.getIndexFromAddress(bp.origin.raw.instructionReference);
+                    if (index >= 0) {
+                        this._disassembledInstructions!.row(index).isBreakpointSet = true;
+                        this._disassembledInstructions!.row(index).isBreakpointEnabled = bp.enabled;
+                        changed = true;
                     }
                 });
 
                 bpEvent.removed?.forEach(bp => {
-                    if (InstructionBreakpoint.is(bp)) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
-                        if (index >= 0) {
-                            this._disassembledInstructions!.row(index).isBreakpointSet = false;
-                            changed = true;
-                        }
+                    const index = this.getIndexFromAddress(bp.origin.raw.instructionReference);
+                    if (index >= 0) {
+                        this._disassembledInstructions!.row(index).isBreakpointSet = false;
+                        changed = true;
                     }
                 });
 
                 bpEvent.changed?.forEach(bp => {
-                    if (InstructionBreakpoint.is(bp)) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
-                        if (index >= 0) {
-                            if (this._disassembledInstructions!.row(index).isBreakpointEnabled !== bp.enabled) {
-                                this._disassembledInstructions!.row(index).isBreakpointEnabled = bp.enabled;
-                                changed = true;
-                            }
+                    const index = this.getIndexFromAddress(bp.origin.raw.instructionReference);
+                    if (index >= 0) {
+                        if (this._disassembledInstructions!.row(index).isBreakpointEnabled !== bp.enabled) {
+                            this._disassembledInstructions!.row(index).isBreakpointEnabled = bp.enabled;
+                            changed = true;
                         }
                     }
                 });
 
                 // get an updated list so that items beyond the current range would render when reached.
-                this._instructionBpList = this.breakpointManager.getInstructionBreakpoints();
+                this._instructionBpList = this.breakpointManager.getInstructionBreakpoints().map(({ origin }) => origin);
 
                 if (changed) {
                     this._onDidChangeStackFrame.fire();
@@ -344,7 +338,7 @@ export class DisassemblyViewWidget extends BaseWidget {
             let lastLocation: DebugProtocol.Source | undefined;
             let lastLine: IRange | undefined;
             for (let i = 0; i < resultEntries.length; i++) {
-                const found = this._instructionBpList.find(p => p.instructionReference === resultEntries[i].address);
+                const found = this._instructionBpList.find(p => p.raw.instructionReference === resultEntries[i].address);
                 const instruction = resultEntries[i];
 
                 // Forward fill the missing location as detailed in the DAP spec.
@@ -424,7 +418,7 @@ export class DisassemblyViewWidget extends BaseWidget {
         if (this._disassembledInstructions) {
             this._loadingLock = true; // stop scrolling during the load.
             this._disassembledInstructions.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
-            this._instructionBpList = this.breakpointManager.getInstructionBreakpoints();
+            this._instructionBpList = this.breakpointManager.getInstructionBreakpoints().map(({ origin }) => origin);
             this.loadDisassembledInstructions(targetAddress, -DisassemblyViewWidget.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyViewWidget.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
                 // on load, set the target instruction in the middle of the page.
                 if (this._disassembledInstructions!.length > 0) {