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

package/src/browser/debug-session.tsx

@@ -46,6 +46,7 @@ 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';
 
 export enum DebugState {
     Inactive,
@@ -624,6 +625,14 @@ export class DebugSession implements CompositeTreeElement {
         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()) || [];
@@ -730,6 +739,8 @@ export class DebugSession implements CompositeTreeElement {
                 await this.sendFunctionBreakpoints(affectedUri);
             } else if (affectedUri.toString() === BreakpointManager.INSTRUCTION_URI.toString()) {
                 await this.sendInstructionBreakpoints();
+            } else if (affectedUri.isEqual(BreakpointManager.DATA_URI)) {
+                await this.sendDataBreakpoints();
             } else {
                 await this.sendSourceBreakpoints(affectedUri, sourceModified);
             }
@@ -855,6 +866,25 @@ export class DebugSession implements CompositeTreeElement {
         this.setBreakpoints(BreakpointManager.INSTRUCTION_URI, all);
     }
 
+    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 enabled = all.filter(bp => bp.enabled);
+        try {
+            const response = await this.sendRequest('setDataBreakpoints', {
+                breakpoints: enabled.map(({ origin }) => origin.raw)
+            });
+            response.body.breakpoints.forEach((raw, index) => enabled[index].update({ raw }));
+        } catch {
+            enabled.forEach(breakpoint => breakpoint.update({ raw: { verified: false } }));
+        }
+        this.setBreakpoints(BreakpointManager.DATA_URI, all);
+    }
+
     protected setBreakpoints(uri: URI, breakpoints: DebugBreakpoint[]): void {
         this._breakpoints.set(uri.toString(), breakpoints);
         this.fireDidChangeBreakpoints(uri);
@@ -890,6 +920,7 @@ export class DebugSession implements CompositeTreeElement {
             }
             yield BreakpointManager.FUNCTION_URI;
             yield BreakpointManager.EXCEPTION_URI;
+            yield BreakpointManager.DATA_URI;
         }
     }
 

package/src/browser/editor/debug-expression-provider.ts

@@ -19,21 +19,66 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { injectable } from '@theia/core/shared/inversify';
+import { ArrayUtils } from '@theia/core';
 import * as monaco from '@theia/monaco-editor-core';
+import { CancellationToken } from '@theia/monaco-editor-core/esm/vs/base/common/cancellation';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { DebugEditor } from './debug-editor';
 
 /**
  * TODO: introduce a new request to LSP to look up an expression range: https://github.com/Microsoft/language-server-protocol/issues/462
  */
 @injectable()
 export class DebugExpressionProvider {
+
+    async getEvaluatableExpression(
+        editor: DebugEditor,
+        selection: monaco.IRange
+    ): Promise<{ matchingExpression: string; range: monaco.IRange } | undefined> {
+
+        const pluginExpressionProvider = StandaloneServices.get(ILanguageFeaturesService).evaluatableExpressionProvider;
+        const textEditorModel = editor.document.textEditorModel;
+
+        if (pluginExpressionProvider && pluginExpressionProvider.has(textEditorModel)) {
+            const registeredProviders = pluginExpressionProvider.ordered(textEditorModel);
+            const position = new monaco.Position(selection.startLineNumber, selection.startColumn);
+
+            const promises = registeredProviders.map(support =>
+                Promise.resolve(support.provideEvaluatableExpression(textEditorModel, position, CancellationToken.None))
+            );
+
+            const results = await Promise.all(promises).then(ArrayUtils.coalesce);
+            if (results.length > 0) {
+                const range = results[0].range;
+                const matchingExpression = results[0].expression || textEditorModel.getValueInRange(range);
+                return { matchingExpression, range };
+            }
+        } else { // use fallback if no provider was registered
+            const model = editor.getControl().getModel();
+            if (model) {
+                const lineContent = model.getLineContent(selection.startLineNumber);
+                const { start, end } = this.getExactExpressionStartAndEnd(lineContent, selection.startColumn, selection.endColumn);
+                const matchingExpression = lineContent.substring(start - 1, end - 1);
+                const range = new monaco.Range(
+                    selection.startLineNumber,
+                    start,
+                    selection.startLineNumber,
+                    end
+                );
+                return { matchingExpression, range };
+            }
+        }
+    }
+
     get(model: monaco.editor.IModel, selection: monaco.IRange): string {
         const lineContent = model.getLineContent(selection.startLineNumber);
         const { start, end } = this.getExactExpressionStartAndEnd(lineContent, selection.startColumn, selection.endColumn);
-        return lineContent.substring(start - 1, end);
+        return lineContent.substring(start - 1, end - 1);
     }
     protected getExactExpressionStartAndEnd(lineContent: string, looseStart: number, looseEnd: number): { start: number, end: number } {
         let matchingExpression: string | undefined = undefined;
-        let startOffset = 0;
+        let startOffset = 1;
 
         // Some example supported expressions: myVar.prop, a.b.c.d, myVar?.prop, myVar->prop, MyClass::StaticProp, *myVar
         // Match any character except a set of characters which often break interesting sub-expressions
@@ -72,7 +117,7 @@ export class DebugExpressionProvider {
         }
 
         return matchingExpression ?
-            { start: startOffset, end: startOffset + matchingExpression.length - 1 } :
-            { start: 0, end: 0 };
+            { start: startOffset, end: startOffset + matchingExpression.length } :
+            { start: 1, end: 1 };
     }
 }

package/src/browser/editor/debug-hover-widget.ts

@@ -16,7 +16,7 @@
 
 import debounce = require('@theia/core/shared/lodash.debounce');
 
-import { ArrayUtils, MenuPath } from '@theia/core';
+import { MenuPath } from '@theia/core';
 import { Key } from '@theia/core/lib/browser';
 import { SourceTreeWidget } from '@theia/core/lib/browser/source-tree';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
@@ -25,10 +25,7 @@ import { Widget } from '@theia/core/shared/@lumino/widgets';
 import { Container, inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
 import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
 import * as monaco from '@theia/monaco-editor-core';
-import { CancellationTokenSource } from '@theia/monaco-editor-core/esm/vs/base/common/cancellation';
 import { IEditorHoverOptions } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
-import { Position } from '@theia/monaco-editor-core/esm/vs/editor/common/core/position';
-import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { IConfigurationService } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configuration';
 import { DebugVariable } from '../console/debug-console-items';
@@ -58,7 +55,6 @@ export function createDebugHoverWidgetContainer(parent: interfaces.Container, ed
     child.bind(DebugEditor).toConstantValue(editor);
     child.bind(DebugHoverSource).toSelf();
     child.unbind(SourceTreeWidget);
-    child.bind(DebugExpressionProvider).toSelf();
     child.bind(DebugHoverWidget).toSelf();
     return child;
 }
@@ -167,7 +163,6 @@ export class DebugHoverWidget extends SourceTreeWidget implements monaco.editor.
     }
 
     protected async doShow(options: ShowDebugHoverOptions | undefined = this.options): Promise<void> {
-        const cancellationSource = new CancellationTokenSource();
 
         if (!this.isEditorFrame()) {
             this.hide();
@@ -185,56 +180,16 @@ export class DebugHoverWidget extends SourceTreeWidget implements monaco.editor.
         }
 
         this.options = options;
-        let matchingExpression: string | undefined;
 
-        const pluginExpressionProvider = StandaloneServices.get(ILanguageFeaturesService).evaluatableExpressionProvider;
-        const textEditorModel = this.editor.document.textEditorModel;
+        const result = await this.expressionProvider.getEvaluatableExpression(this.editor, options.selection);
 
-        if (pluginExpressionProvider && pluginExpressionProvider.has(textEditorModel)) {
-            const registeredProviders = pluginExpressionProvider.ordered(textEditorModel);
-            const position = new Position(this.options!.selection.startLineNumber, this.options!.selection.startColumn);
-
-            const promises = registeredProviders.map(support =>
-                Promise.resolve(support.provideEvaluatableExpression(textEditorModel, position, cancellationSource.token))
-            );
-
-            const results = await Promise.all(promises).then(ArrayUtils.coalesce);
-            if (results.length > 0) {
-                matchingExpression = results[0].expression;
-                const range = results[0].range;
-
-                if (!matchingExpression) {
-                    const lineContent = textEditorModel.getLineContent(position.lineNumber);
-                    matchingExpression = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
-                }
-            }
-        } else { // use fallback if no provider was registered
-            const model = this.editor.getControl().getModel();
-            if (model) {
-
-                matchingExpression = this.expressionProvider.get(model, options.selection);
-                if (matchingExpression) {
-                    const expressionLineContent = model.getLineContent(this.options.selection.startLineNumber);
-                    const startColumn =
-                        expressionLineContent.indexOf(
-                            matchingExpression,
-                            this.options.selection.startColumn - matchingExpression.length
-                        ) + 1;
-                    const endColumn = startColumn + matchingExpression.length;
-                    this.options.selection = new monaco.Range(
-                        this.options.selection.startLineNumber,
-                        startColumn,
-                        this.options.selection.startLineNumber,
-                        endColumn
-                    );
-                }
-            }
-        }
-
-        if (!matchingExpression) {
+        if (!result?.matchingExpression) {
             this.hide();
             return;
         }
+
+        this.options.selection = monaco.Range.lift(result.range);
+
         const toFocus = new DisposableCollection();
         if (this.options.focus === true) {
             toFocus.push(this.model.onNodeRefreshed(() => {
@@ -242,7 +197,7 @@ export class DebugHoverWidget extends SourceTreeWidget implements monaco.editor.
                 this.activate();
             }));
         }
-        const expression = await this.hoverSource.evaluate(matchingExpression);
+        const expression = await this.hoverSource.evaluate(result.matchingExpression);
         if (!expression) {
             toFocus.dispose();
             this.hide();

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

@@ -0,0 +1,79 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core';
+import * as React from '@theia/core/shared/react';
+import { BreakpointManager } from '../breakpoint/breakpoint-manager';
+import { DataBreakpoint } from '../breakpoint/breakpoint-marker';
+import { DebugBreakpoint, DebugBreakpointDecoration, DebugBreakpointOptions } from './debug-breakpoint';
+
+export class DebugDataBreakpoint extends DebugBreakpoint<DataBreakpoint> {
+    constructor(readonly origin: DataBreakpoint, options: DebugBreakpointOptions) {
+        super(BreakpointManager.DATA_URI, options);
+    }
+
+    setEnabled(enabled: boolean): void {
+        if (enabled !== this.origin.enabled) {
+            this.breakpoints.updateDataBreakpoint(this.origin.id, { enabled });
+        }
+    }
+
+    protected override isEnabled(): boolean {
+        return super.isEnabled() && this.isSupported();
+    }
+
+    protected isSupported(): boolean {
+        return Boolean(this.session?.capabilities.supportsDataBreakpoints);
+    }
+
+    remove(): void {
+        this.breakpoints.removeDataBreakpoint(this.origin.id);
+    }
+
+    protected doRender(): React.ReactNode {
+        return <span className="line-info theia-data-breakpoint" title={this.origin.info.description}>
+            <span className="name">{this.origin.info.description}</span>
+            <span className="theia-TreeNodeInfo theia-access-type" >{this.getAccessType()}</span>
+        </span>;
+    }
+
+    protected getAccessType(): string {
+        switch (this.origin.raw.accessType) {
+            case 'read': return 'Read';
+            case 'write': return 'Write';
+            default: return 'Access';
+        }
+    }
+
+    protected getBreakpointDecoration(message?: string[]): DebugBreakpointDecoration {
+        if (!this.isSupported()) {
+            return {
+                className: 'codicon-debug-breakpoint-unsupported',
+                message: message ?? [nls.localize('theia/debug/data-breakpoint', 'Data Breakpoint')],
+            };
+        }
+        if (this.origin.raw.condition || this.origin.raw.hitCondition) {
+            return {
+                className: 'codicon-debug-breakpoint-conditional',
+                message: message || [nls.localize('theia/debug/conditionalBreakpoint', 'Conditional Breakpoint')]
+            };
+        }
+        return {
+            className: 'codicon-debug-breakpoint-data',
+            message: message || [nls.localize('theia/debug/data-breakpoint', 'Data Breakpoint')]
+        };
+    }
+}

package/src/browser/style/index.css

@@ -71,6 +71,10 @@
   border-radius: 2px;
 }
 
+.theia-data-breakpoint .theia-access-type {
+    margin-left: var(--theia-ui-padding);
+}
+
 .theia-source-breakpoint > .theia-input {
   min-height: auto;
 }

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

@@ -39,15 +39,9 @@ export class DebugBreakpointsSource extends TreeSource {
         for (const exceptionBreakpoint of this.breakpoints.getExceptionBreakpoints()) {
             yield new DebugExceptionBreakpoint(exceptionBreakpoint, this.breakpoints);
         }
-        for (const functionBreakpoint of this.model.functionBreakpoints) {
-            yield functionBreakpoint;
-        }
-        for (const instructionBreakpoint of this.model.instructionBreakpoints) {
-            yield instructionBreakpoint;
-        }
-        for (const breakpoint of this.model.breakpoints) {
-            yield breakpoint;
-        }
+        yield* this.model.dataBreakpoints;
+        yield* this.model.functionBreakpoints;
+        yield* this.model.instructionBreakpoints;
+        yield* this.model.breakpoints;
     }
-
 }

package/src/browser/view/debug-stack-frames-widget.ts

@@ -122,8 +122,12 @@ export class DebugStackFramesWidget extends SourceTreeWidget {
     }
 
     protected override tapNode(node?: TreeNode): void {
-        if (TreeElementNode.is(node) && node.element instanceof LoadMoreStackFrames) {
-            node.element.open();
+        if (TreeElementNode.is(node)) {
+            if (node.element instanceof LoadMoreStackFrames) {
+                node.element.open();
+            } else if (node.element instanceof DebugStackFrame) {
+                node.element.open({ preview: true });
+            }
         }
         super.tapNode(node);
     }

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

@@ -15,11 +15,16 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct, interfaces, Container } from '@theia/core/shared/inversify';
-import { MenuPath } from '@theia/core/lib/common';
-import { SourceTreeWidget } from '@theia/core/lib/browser/source-tree';
+import { MenuPath, Disposable, CommandRegistry, MenuModelRegistry, DisposableCollection, Command } from '@theia/core/lib/common';
+import { SourceTreeWidget, TreeElementNode } from '@theia/core/lib/browser/source-tree';
 import { DebugVariablesSource } from './debug-variables-source';
 import { DebugViewModel } from './debug-view-model';
 import { nls } from '@theia/core/lib/common/nls';
+import { MouseEvent } from '@theia/core/shared/react';
+import { SelectableTreeNode, TreeNode, TreeSelection } from '@theia/core/lib/browser';
+import { DebugVariable } from '../console/debug-console-items';
+import { BreakpointManager } from '../breakpoint/breakpoint-manager';
+import { DataBreakpoint, DataBreakpointSource, DataBreakpointSourceType } from '../breakpoint/breakpoint-marker';
 
 @injectable()
 export class DebugVariablesWidget extends SourceTreeWidget {
@@ -27,6 +32,7 @@ export class DebugVariablesWidget extends SourceTreeWidget {
     static CONTEXT_MENU: MenuPath = ['debug-variables-context-menu'];
     static EDIT_MENU: MenuPath = [...DebugVariablesWidget.CONTEXT_MENU, 'a_edit'];
     static WATCH_MENU: MenuPath = [...DebugVariablesWidget.CONTEXT_MENU, 'b_watch'];
+    static DATA_BREAKPOINT_MENU: MenuPath = [...DebugVariablesWidget.CONTEXT_MENU, 'c_data_breakpoints'];
     static FACTORY_ID = 'debug:variables';
     static override createContainer(parent: interfaces.Container): Container {
         const child = SourceTreeWidget.createContainer(parent, {
@@ -49,6 +55,15 @@ export class DebugVariablesWidget extends SourceTreeWidget {
     @inject(DebugVariablesSource)
     protected readonly variables: DebugVariablesSource;
 
+    @inject(CommandRegistry)
+    protected readonly commandRegistry: CommandRegistry;
+
+    @inject(MenuModelRegistry)
+    protected readonly menuRegistry: MenuModelRegistry;
+
+    @inject(BreakpointManager)
+    protected readonly breakpointManager: BreakpointManager;
+
     @postConstruct()
     protected override init(): void {
         super.init();
@@ -58,4 +73,86 @@ export class DebugVariablesWidget extends SourceTreeWidget {
         this.source = this.variables;
     }
 
+    protected override handleContextMenuEvent(node: TreeNode | undefined, event: MouseEvent<HTMLElement>): void {
+        this.doHandleContextMenuEvent(node, event);
+    }
+
+    protected async doHandleContextMenuEvent(node: TreeNode | undefined, event: MouseEvent<HTMLElement>): Promise<void> {
+        event.stopPropagation();
+        event.preventDefault();
+        if (!SelectableTreeNode.is(node) || !TreeElementNode.is(node)) { return; }
+        // Keep the selection for the context menu, if the widget support multi-selection and the right click happens on an already selected node.
+        if (!this.props.multiSelect || !node.selected) {
+            const type = !!this.props.multiSelect && this.hasCtrlCmdMask(event) ? TreeSelection.SelectionType.TOGGLE : TreeSelection.SelectionType.DEFAULT;
+            this.model.addSelection({ node, type });
+        }
+        this.focusService.setFocus(node);
+        const contextMenuPath = this.props.contextMenuPath;
+        if (contextMenuPath) {
+            const { x, y } = event.nativeEvent;
+            const args = this.toContextMenuArgs(node);
+            const target = event.currentTarget;
+            const toDisposeOnHide = await this.getVariableCommands(node);
+            setTimeout(() => this.contextMenuRenderer.render({
+                menuPath: contextMenuPath,
+                context: target,
+                anchor: { x, y },
+                args,
+                onHide: () => toDisposeOnHide.dispose()
+            }), 10);
+        }
+    }
+
+    protected async getVariableCommands(node: TreeElementNode): Promise<Disposable> {
+        const selectedElement = node.element;
+        const { viewModel: { currentSession } } = this;
+        if (!currentSession?.capabilities.supportsDataBreakpoints || !(selectedElement instanceof DebugVariable)) {
+            return Disposable.NULL;
+        }
+        const { name, parent: { reference } } = selectedElement;
+        const dataBreakpointInfo = (await currentSession.sendRequest('dataBreakpointInfo', { name, variablesReference: reference })).body;
+        // eslint-disable-next-line no-null/no-null
+        if (dataBreakpointInfo.dataId === null) {
+            return Disposable.NULL;
+        }
+        const source: DataBreakpointSource = { type: DataBreakpointSourceType.Variable, variable: name };
+        return new DisposableCollection(
+            this.commandRegistry.registerCommand(Command.toDefaultLocalizedCommand({
+                id: `break-on-access:${currentSession.id}:${name}`,
+                label: 'Break on Value Access'
+            }), {
+                execute: () => this.breakpointManager.addDataBreakpoint(DataBreakpoint.create(
+                    { accessType: 'readWrite', dataId: dataBreakpointInfo.dataId! },
+                    dataBreakpointInfo,
+                    source
+                )),
+                isEnabled: () => !!dataBreakpointInfo.accessTypes?.includes('readWrite'),
+            }),
+            this.menuRegistry.registerMenuAction(DebugVariablesWidget.DATA_BREAKPOINT_MENU, { commandId: `break-on-access:${currentSession.id}:${name}`, order: 'c' }),
+            this.commandRegistry.registerCommand(Command.toDefaultLocalizedCommand({
+                id: `break-on-read:${currentSession.id}:${name}`,
+                label: 'Break on Value Read'
+            }), {
+                execute: () => this.breakpointManager.addDataBreakpoint(DataBreakpoint.create(
+                    { accessType: 'read', dataId: dataBreakpointInfo.dataId! },
+                    dataBreakpointInfo,
+                    source
+                )),
+                isEnabled: () => !!dataBreakpointInfo.accessTypes?.includes('read'),
+            }),
+            this.menuRegistry.registerMenuAction(DebugVariablesWidget.DATA_BREAKPOINT_MENU, { commandId: `break-on-read:${currentSession.id}:${name}`, order: 'a' }),
+            this.commandRegistry.registerCommand(Command.toDefaultLocalizedCommand({
+                id: `break-on-write:${currentSession.id}:${name}`,
+                label: 'Break on Value Change'
+            }), {
+                execute: () => this.breakpointManager.addDataBreakpoint(DataBreakpoint.create(
+                    { accessType: 'write', dataId: dataBreakpointInfo.dataId! },
+                    dataBreakpointInfo,
+                    source
+                )),
+                isEnabled: () => !!dataBreakpointInfo.accessTypes?.includes('write'),
+            }),
+            this.menuRegistry.registerMenuAction(DebugVariablesWidget.DATA_BREAKPOINT_MENU, { commandId: `break-on-write:${currentSession.id}:${name}`, order: 'b' }),
+        );
+    }
 }

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

@@ -28,6 +28,7 @@ import { DebugWatchManager } from '../debug-watch-manager';
 import { DebugFunctionBreakpoint } from '../model/debug-function-breakpoint';
 import { DebugInstructionBreakpoint } from '../model/debug-instruction-breakpoint';
 import { DebugSessionOptionsBase } from '../debug-session-options';
+import { DebugDataBreakpoint } from '../model/debug-data-breakpoint';
 
 @injectable()
 export class DebugViewModel implements Disposable {
@@ -137,6 +138,10 @@ export class DebugViewModel implements Disposable {
         return this.manager.getInstructionBreakpoints(this.currentSession);
     }
 
+    get dataBreakpoints(): DebugDataBreakpoint[] {
+        return this.manager.getDataBreakpoints(this.currentSession);
+    }
+
     async start(options: Partial<Pick<DebugSessionOptionsBase, 'startedByUser'>> = {}): Promise<void> {
         const { session } = this;
         if (!session) {