@theia/debug 1.28.0-next.2 → 1.28.0-next.23

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

@@ -14,8 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import { DisposableCollection, Emitter, Event, MessageService, ProgressService, WaitUntilEvent } from '@theia/core';
 import { LabelProvider, ApplicationShell } from '@theia/core/lib/browser';
 import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
@@ -38,6 +36,7 @@ import { TaskIdentifier } from '@theia/task/lib/common';
 import { DebugSourceBreakpoint } from './model/debug-source-breakpoint';
 import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
 import * as monaco from '@theia/monaco-editor-core';
+import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint';
 
 export interface WillStartDebugSession extends WaitUntilEvent {
 }
@@ -56,8 +55,13 @@ export interface DidChangeBreakpointsEvent {
     uri: URI
 }
 
+export interface DidFocusStackFrameEvent {
+    session: DebugSession;
+    frame: DebugStackFrame | undefined;
+}
+
 export interface DebugSessionCustomEvent {
-    readonly body?: any
+    readonly body?: any // eslint-disable-line @typescript-eslint/no-explicit-any
     readonly event: string
     readonly session: DebugSession
 }
@@ -90,8 +94,11 @@ export class DebugSessionManager {
     protected readonly onDidReceiveDebugSessionCustomEventEmitter = new Emitter<DebugSessionCustomEvent>();
     readonly onDidReceiveDebugSessionCustomEvent: Event<DebugSessionCustomEvent> = this.onDidReceiveDebugSessionCustomEventEmitter.event;
 
+    protected readonly onDidFocusStackFrameEmitter = new Emitter<DidFocusStackFrameEvent>();
+    readonly onDidFocusStackFrame = this.onDidFocusStackFrameEmitter.event;
+
     protected readonly onDidChangeBreakpointsEmitter = new Emitter<DidChangeBreakpointsEvent>();
-    readonly onDidChangeBreakpoints: Event<DidChangeBreakpointsEvent> = this.onDidChangeBreakpointsEmitter.event;
+    readonly onDidChangeBreakpoints = this.onDidChangeBreakpointsEmitter.event;
     protected fireDidChangeBreakpoints(event: DidChangeBreakpointsEvent): void {
         this.onDidChangeBreakpointsEmitter.fire(event);
     }
@@ -250,8 +257,7 @@ export class DebugSessionManager {
                 context: options.workspaceFolderUri ? new URI(options.workspaceFolderUri) : undefined,
                 configurationSection: 'launch',
                 commandIdVariables,
-                configuration,
-                checkAllResolved: true
+                configuration
             });
 
             if (configuration) {
@@ -417,6 +423,7 @@ export class DebugSessionManager {
                 }
                 this.fireDidChange(current);
             }));
+            this.disposeOnCurrentSessionChanged.push(current.onDidFocusStackFrame(frame => this.onDidFocusStackFrameEmitter.fire({ session: current, frame })));
         }
         this.updateBreakpoints(previous, current);
         this.open();
@@ -475,6 +482,14 @@ export class DebugSessionManager {
         return this.breakpoints.getFunctionBreakpoints().map(origin => new DebugFunctionBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
     }
 
+    getInstructionBreakpoints(session = this.currentSession): DebugInstructionBreakpoint[] {
+        if (session && session.state > DebugState.Initializing) {
+            return session.getInstructionBreakpoints();
+        }
+        const { labelProvider, breakpoints, editorManager } = this;
+        return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
+    }
+
     getBreakpoints(session?: DebugSession): DebugSourceBreakpoint[];
     getBreakpoints(uri: URI, session?: DebugSession): DebugSourceBreakpoint[];
     getBreakpoints(arg?: URI | DebugSession, arg2?: DebugSession): DebugSourceBreakpoint[] {

package/src/browser/debug-session.tsx

@@ -42,6 +42,7 @@ import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { DebugContribution } from './debug-contribution';
 import { waitForEvent } from '@theia/core/lib/common/promise-util';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint';
 
 export enum DebugState {
     Inactive,
@@ -57,6 +58,10 @@ export class DebugSession implements CompositeTreeElement {
     protected fireDidChange(): void {
         this.onDidChangeEmitter.fire(undefined);
     }
+    protected readonly onDidFocusStackFrameEmitter = new Emitter<DebugStackFrame | undefined>();
+    get onDidFocusStackFrame(): Event<DebugStackFrame | undefined> {
+        return this.onDidFocusStackFrameEmitter.event;
+    }
 
     protected readonly onDidChangeBreakpointsEmitter = new Emitter<URI>();
     readonly onDidChangeBreakpoints: Event<URI> = this.onDidChangeBreakpointsEmitter.event;
@@ -235,6 +240,7 @@ export class DebugSession implements CompositeTreeElement {
         this.fireDidChange();
         if (thread) {
             this.toDisposeOnCurrentThread.push(thread.onDidChanged(() => this.fireDidChange()));
+            this.toDisposeOnCurrentThread.push(thread.onDidFocusStackFrame(frame => this.onDidFocusStackFrameEmitter.fire(frame)));
 
             // If this thread is missing stack frame information, then load that.
             this.updateFrames();
@@ -513,13 +519,15 @@ export class DebugSession implements CompositeTreeElement {
     }
 
     getFunctionBreakpoints(): DebugFunctionBreakpoint[] {
-        const breakpoints = [];
-        for (const breakpoint of this.getBreakpoints(BreakpointManager.FUNCTION_URI)) {
-            if (breakpoint instanceof DebugFunctionBreakpoint) {
-                breakpoints.push(breakpoint);
-            }
+        return this.getBreakpoints(BreakpointManager.FUNCTION_URI).filter((breakpoint): breakpoint is DebugFunctionBreakpoint => breakpoint instanceof DebugFunctionBreakpoint);
+    }
+
+    getInstructionBreakpoints(): DebugInstructionBreakpoint[] {
+        if (this.capabilities.supportsInstructionBreakpoints) {
+            return this.getBreakpoints(BreakpointManager.FUNCTION_URI)
+                .filter((breakpoint): breakpoint is DebugInstructionBreakpoint => breakpoint instanceof DebugInstructionBreakpoint);
         }
-        return breakpoints;
+        return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, this.asDebugBreakpointOptions()));
     }
 
     getBreakpoints(uri?: URI): DebugBreakpoint[] {
@@ -614,6 +622,8 @@ export class DebugSession implements CompositeTreeElement {
                 await this.sendExceptionBreakpoints();
             } else if (affectedUri.toString() === BreakpointManager.FUNCTION_URI.toString()) {
                 await this.sendFunctionBreakpoints(affectedUri);
+            } else if (affectedUri.toString() === BreakpointManager.INSTRUCTION_URI.toString()) {
+                await this.sendInstructionBreakpoints();
             } else {
                 await this.sendSourceBreakpoints(affectedUri, sourceModified);
             }
@@ -640,7 +650,7 @@ export class DebugSession implements CompositeTreeElement {
                 const response = await this.sendRequest('setFunctionBreakpoints', {
                     breakpoints: enabled.map(b => b.origin.raw)
                 });
-                response.body.breakpoints.map((raw, index) => {
+                response.body.breakpoints.forEach((raw, index) => {
                     // node debug adapter returns more breakpoints sometimes
                     if (enabled[index]) {
                         enabled[index].update({ raw });
@@ -679,7 +689,7 @@ export class DebugSession implements CompositeTreeElement {
                 sourceModified,
                 breakpoints: enabled.map(({ origin }) => origin.raw)
             });
-            response.body.breakpoints.map((raw, index) => {
+            response.body.breakpoints.forEach((raw, index) => {
                 // node debug adapter returns more breakpoints sometimes
                 if (enabled[index]) {
                     enabled[index].update({ raw });
@@ -705,6 +715,23 @@ export class DebugSession implements CompositeTreeElement {
         this.setSourceBreakpoints(affectedUri, all);
     }
 
+    protected async sendInstructionBreakpoints(): Promise<void> {
+        if (!this.capabilities.supportsInstructionBreakpoints) {
+            return;
+        }
+        const all = this.breakpoints.getInstructionBreakpoints().map(breakpoint => new DebugInstructionBreakpoint(breakpoint, this.asDebugBreakpointOptions()));
+        const enabled = all.filter(breakpoint => breakpoint.enabled);
+        try {
+            const response = await this.sendRequest('setInstructionBreakpoints', {
+                breakpoints: enabled.map(renderable => renderable.origin),
+            });
+            response.body.breakpoints.forEach((raw, index) => enabled[index]?.update({ raw }));
+        } catch {
+            enabled.forEach(breakpoint => breakpoint.update({ raw: { verified: false } }));
+        }
+        this.setBreakpoints(BreakpointManager.INSTRUCTION_URI, all);
+    }
+
     protected setBreakpoints(uri: URI, breakpoints: DebugBreakpoint[]): void {
         this._breakpoints.set(uri.toString(), breakpoints);
         this.fireDidChangeBreakpoints(uri);

package/src/browser/disassembly-view/disassembly-view-accessibility-provider.ts

@@ -0,0 +1,43 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core';
+import { IListAccessibilityProvider } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/list/listWidget';
+import { DisassembledInstructionEntry } from './disassembly-view-utilities';
+
+// This file is adapted from https://github.com/microsoft/vscode/blob/c061ce5c24fc480342fbc5f23244289d633c56eb/src/vs/workbench/contrib/debug/browser/disassemblyView.ts
+
+export class AccessibilityProvider implements IListAccessibilityProvider<DisassembledInstructionEntry> {
+
+    getWidgetAriaLabel(): string {
+        return nls.localize('disassemblyView', 'Disassembly View');
+    }
+
+    getAriaLabel(element: DisassembledInstructionEntry): string | null {
+        let label = '';
+
+        const instruction = element.instruction;
+        if (instruction.address !== '-1') {
+            label += `${nls.localize('theia/debug/instructionAddress', 'Address')}: ${instruction.address}`;
+        }
+        if (instruction.instructionBytes) {
+            label += `, ${nls.localize('theia/debug/instructionBytes', 'Bytes')}: ${instruction.instructionBytes}`;
+        }
+        label += `, ${nls.localize('theia/debug/instructionText', 'Instruction')}: ${instruction.instruction}`;
+
+        return label;
+    }
+}

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

@@ -0,0 +1,119 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { append, $, addStandardDisposableListener } from '@theia/monaco-editor-core/esm/vs/base/browser/dom';
+import { ITableRenderer } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/table/table';
+import { dispose } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
+import { BreakpointManager } from '../breakpoint/breakpoint-manager';
+import { BreakpointColumnTemplateData, DisassembledInstructionEntry, DisassemblyViewRendererReference } from './disassembly-view-utilities';
+
+// This file is adapted from https://github.com/microsoft/vscode/blob/c061ce5c24fc480342fbc5f23244289d633c56eb/src/vs/workbench/contrib/debug/browser/disassemblyView.ts
+
+export class BreakpointRenderer implements ITableRenderer<DisassembledInstructionEntry, BreakpointColumnTemplateData> {
+
+    static readonly TEMPLATE_ID = 'breakpoint';
+
+    templateId: string = BreakpointRenderer.TEMPLATE_ID;
+
+    protected readonly _breakpointIcon = 'codicon-debug-breakpoint';
+    protected readonly _breakpointDisabledIcon = 'codicon-debug-breakpoint-disabled';
+    protected readonly _breakpointHintIcon = 'codicon-debug-hint';
+    protected readonly _debugStackframe = 'codicon-debug-stackframe';
+    protected readonly _debugStackframeFocused = 'codicon-debug-stackframe-focused';
+
+    constructor(
+        protected readonly _disassemblyView: DisassemblyViewRendererReference,
+        protected readonly _debugService: BreakpointManager,
+    ) { }
+
+    renderTemplate(container: HTMLElement): BreakpointColumnTemplateData {
+        // align from the bottom so that it lines up with instruction when source code is present.
+        container.style.alignSelf = 'flex-end';
+
+        const icon = append(container, $('.disassembly-view'));
+        icon.classList.add('codicon');
+        icon.style.display = 'flex';
+        icon.style.alignItems = 'center';
+        icon.style.justifyContent = 'center';
+        icon.style.height = this._disassemblyView.fontInfo.lineHeight + 'px';
+
+        const currentElement: { element?: DisassembledInstructionEntry } = { element: undefined };
+
+        const disposables = [
+            this._disassemblyView.onDidChangeStackFrame(() => this.rerenderDebugStackframe(icon, currentElement.element)),
+            addStandardDisposableListener(container, 'mouseover', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    icon.classList.add(this._breakpointHintIcon);
+                }
+            }),
+            addStandardDisposableListener(container, 'mouseout', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    icon.classList.remove(this._breakpointHintIcon);
+                }
+            }),
+            addStandardDisposableListener(container, 'click', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    // 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);
+
+                    } else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
+                        this._debugService.addInstructionBreakpoint(currentElement.element.instruction.address, 0);
+                    }
+                }
+            })
+        ];
+
+        return { currentElement, icon, disposables };
+    }
+
+    renderElement(element: DisassembledInstructionEntry, index: number, templateData: BreakpointColumnTemplateData, height: number | undefined): void {
+        templateData.currentElement.element = element;
+        this.rerenderDebugStackframe(templateData.icon, element);
+    }
+
+    disposeTemplate(templateData: BreakpointColumnTemplateData): void {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+
+    protected rerenderDebugStackframe(icon: HTMLElement, element?: DisassembledInstructionEntry): void {
+        if (element?.instruction.address === this._disassemblyView.focusedCurrentInstructionAddress) {
+            icon.classList.add(this._debugStackframe);
+        } else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+            icon.classList.add(this._debugStackframeFocused);
+        } else {
+            icon.classList.remove(this._debugStackframe);
+            icon.classList.remove(this._debugStackframeFocused);
+        }
+
+        icon.classList.remove(this._breakpointHintIcon);
+
+        if (element?.isBreakpointSet) {
+            if (element.isBreakpointEnabled) {
+                icon.classList.add(this._breakpointIcon);
+                icon.classList.remove(this._breakpointDisabledIcon);
+            } else {
+                icon.classList.remove(this._breakpointIcon);
+                icon.classList.add(this._breakpointDisabledIcon);
+            }
+        } else {
+            icon.classList.remove(this._breakpointIcon);
+            icon.classList.remove(this._breakpointDisabledIcon);
+        }
+    }
+}

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

@@ -0,0 +1,109 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
+import { AbstractViewContribution, bindViewContribution, WidgetFactory } from '@theia/core/lib/browser';
+import { DisassemblyViewWidget } from './disassembly-view-widget';
+import { Command, CommandRegistry, MenuModelRegistry, nls } from '@theia/core';
+import { DebugService } from '../../common/debug-service';
+import { EditorManager, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
+import { DebugSessionManager } from '../debug-session-manager';
+import { DebugStackFrame } from '../model/debug-stack-frame';
+import { DebugSession, DebugState } from '../debug-session';
+import { DebugStackFramesWidget } from '../view/debug-stack-frames-widget';
+
+export const OPEN_DISASSEMBLY_VIEW_COMMAND: Command = {
+    id: 'open-disassembly-view',
+    label: nls.localize('theia/debug/open-disassembly-view', 'Open Disassembly View')
+};
+
+export const LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST = 'languageSupportsDisassembleRequest';
+export const FOCUSED_STACK_FRAME_HAS_INSTRUCTION_REFERENCE = 'focusedStackFrameHasInstructionReference';
+export const DISASSEMBLE_REQUEST_SUPPORTED = 'disassembleRequestSupported';
+export const DISASSEMBLY_VIEW_FOCUS = 'disassemblyViewFocus';
+
+@injectable()
+export class DisassemblyViewContribution extends AbstractViewContribution<DisassemblyViewWidget> {
+    @inject(DebugService) protected readonly debugService: DebugService;
+    @inject(EditorManager) protected readonly editorManager: EditorManager;
+    @inject(ContextKeyService) protected readonly contextKeyService: ContextKeyService;
+    @inject(DebugSessionManager) protected readonly debugSessionManager: DebugSessionManager;
+
+    constructor() {
+        super({
+            widgetId: DisassemblyViewWidget.ID,
+            widgetName: 'Disassembly View',
+            defaultWidgetOptions: { area: 'main' }
+        });
+    }
+
+    @postConstruct()
+    protected init(): void {
+        let activeEditorChangeCancellation = { cancelled: false };
+        const updateLanguageSupportsDisassemblyKey = async () => {
+            const editor = this.editorManager.currentEditor;
+            activeEditorChangeCancellation.cancelled = true;
+            const localCancellation = activeEditorChangeCancellation = { cancelled: false };
+
+            const language = editor?.editor.document.languageId;
+            const debuggersForLanguage = language && await this.debugService.getDebuggersForLanguage(language);
+            if (!localCancellation.cancelled) {
+                this.contextKeyService.setContext(LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, Boolean(debuggersForLanguage?.length));
+            }
+        };
+        this.editorManager.onCurrentEditorChanged(updateLanguageSupportsDisassemblyKey);
+        this.debugService.onDidChangeDebuggers?.(updateLanguageSupportsDisassemblyKey);
+        let lastSession: DebugSession | undefined;
+        let lastFrame: DebugStackFrame | undefined;
+        this.debugSessionManager.onDidChange(() => {
+            const { currentFrame, currentSession } = this.debugSessionManager;
+            if (currentFrame !== lastFrame) {
+                lastFrame = currentFrame;
+                this.contextKeyService.setContext(FOCUSED_STACK_FRAME_HAS_INSTRUCTION_REFERENCE, Boolean(currentFrame?.raw.instructionPointerReference));
+            }
+            if (currentSession !== lastSession) {
+                lastSession = currentSession;
+                this.contextKeyService.setContext(DISASSEMBLE_REQUEST_SUPPORTED, Boolean(currentSession?.capabilities.supportsDisassembleRequest));
+            }
+        });
+        this.shell.onDidChangeCurrentWidget(widget => {
+            this.contextKeyService.setContext(DISASSEMBLY_VIEW_FOCUS, widget instanceof DisassemblyViewWidget);
+        });
+    }
+
+    override registerCommands(commands: CommandRegistry): void {
+        commands.registerCommand(OPEN_DISASSEMBLY_VIEW_COMMAND, {
+            isEnabled: () => this.debugSessionManager.inDebugMode
+                && this.debugSessionManager.state === DebugState.Stopped
+                && this.contextKeyService.match('focusedStackFrameHasInstructionReference'),
+            execute: () => this.openView({ activate: true }),
+        });
+    }
+
+    override registerMenus(menus: MenuModelRegistry): void {
+        menus.registerMenuAction(DebugStackFramesWidget.CONTEXT_MENU,
+            { commandId: OPEN_DISASSEMBLY_VIEW_COMMAND.id, label: OPEN_DISASSEMBLY_VIEW_COMMAND.label });
+        menus.registerMenuAction([...EDITOR_CONTEXT_MENU, 'a_debug'],
+            { commandId: OPEN_DISASSEMBLY_VIEW_COMMAND.id, label: OPEN_DISASSEMBLY_VIEW_COMMAND.label, when: LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST });
+    }
+}
+
+export function bindDisassemblyView(bind: interfaces.Bind): void {
+    bind(DisassemblyViewWidget).toSelf();
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({ id: DisassemblyViewWidget.ID, createWidget: () => container.get(DisassemblyViewWidget) }));
+    bindViewContribution(bind, DisassemblyViewContribution);
+}