@theia/debug 1.28.0-next.1 → 1.28.0-next.13

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);
@@ -834,7 +861,7 @@ export class DebugSession implements CompositeTreeElement {
         }
         let debugSession: DebugSession | undefined = this;
         do {
-            debugSession = this.parentSession;
+            debugSession = debugSession.parentSession;
         } while (debugSession?.parentSession && debugSession.configuration.consoleMode === DebugConsoleMode.MergeWithParent);
         return debugSession;
     }

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);
+}

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

@@ -0,0 +1,245 @@
+// *****************************************************************************
+// 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 { open, OpenerService } from '@theia/core/lib/browser';
+import { URI as TheiaURI } from '@theia/core/lib/common/uri';
+import { EditorOpenerOptions } from '@theia/editor/lib/browser';
+import { IDisposable, Uri as URI } from '@theia/monaco-editor-core';
+import { $, addStandardDisposableListener, append } 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 { Color } from '@theia/monaco-editor-core/esm/vs/base/common/color';
+import { Disposable, dispose } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
+import { isAbsolute } from '@theia/monaco-editor-core/esm/vs/base/common/path';
+import { Constants } from '@theia/monaco-editor-core/esm/vs/base/common/uint';
+import { applyFontInfo } from '@theia/monaco-editor-core/esm/vs/editor/browser/config/domFontInfo';
+import { createStringBuilder } from '@theia/monaco-editor-core/esm/vs/editor/common/core/stringBuilder';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { ITextModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { DebugProtocol } from 'vscode-debugprotocol';
+import { DebugSource } from '../model/debug-source';
+import { DisassembledInstructionEntry, DisassemblyViewRendererReference, InstructionColumnTemplateData } from './disassembly-view-utilities';
+
+// This file is adapted from https://github.com/microsoft/vscode/blob/c061ce5c24fc480342fbc5f23244289d633c56eb/src/vs/workbench/contrib/debug/browser/disassemblyView.ts
+
+const topStackFrameColor = 'editor.stackFrameHighlightBackground';
+const focusedStackFrameColor = 'editor.focusedStackFrameHighlightBackground';
+
+export class InstructionRenderer extends Disposable implements ITableRenderer<DisassembledInstructionEntry, InstructionColumnTemplateData> {
+
+    static readonly TEMPLATE_ID = 'instruction';
+
+    protected static readonly INSTRUCTION_ADDR_MIN_LENGTH = 25;
+    protected static readonly INSTRUCTION_BYTES_MIN_LENGTH = 30;
+
+    templateId: string = InstructionRenderer.TEMPLATE_ID;
+
+    protected _topStackFrameColor: Color | undefined;
+    protected _focusedStackFrameColor: Color | undefined;
+
+    constructor(
+        protected readonly _disassemblyView: DisassemblyViewRendererReference,
+        protected readonly openerService: OpenerService,
+        protected readonly uriService: { asCanonicalUri(uri: URI): URI },
+        @IThemeService themeService: IThemeService,
+        @ITextModelService protected readonly textModelService: ITextModelService,
+    ) {
+        super();
+
+        this._topStackFrameColor = themeService.getColorTheme().getColor(topStackFrameColor);
+        this._focusedStackFrameColor = themeService.getColorTheme().getColor(focusedStackFrameColor);
+
+        this._register(themeService.onDidColorThemeChange(e => {
+            this._topStackFrameColor = e.getColor(topStackFrameColor);
+            this._focusedStackFrameColor = e.getColor(focusedStackFrameColor);
+        }));
+    }
+
+    renderTemplate(container: HTMLElement): InstructionColumnTemplateData {
+        const sourcecode = append(container, $('.sourcecode'));
+        const instruction = append(container, $('.instruction'));
+        this.applyFontInfo(sourcecode);
+        this.applyFontInfo(instruction);
+        const currentElement: { element?: DisassembledInstructionEntry } = { element: undefined };
+        const cellDisposable: IDisposable[] = [];
+
+        const disposables = [
+            this._disassemblyView.onDidChangeStackFrame(() => this.rerenderBackground(instruction, sourcecode, currentElement.element)),
+            addStandardDisposableListener(sourcecode, 'dblclick', () => this.openSourceCode(currentElement.element?.instruction!)),
+        ];
+
+        return { currentElement, instruction, sourcecode, cellDisposable, disposables };
+    }
+
+    renderElement(element: DisassembledInstructionEntry, index: number, templateData: InstructionColumnTemplateData, height: number | undefined): void {
+        this.renderElementInner(element, index, templateData, height);
+    }
+
+    protected async renderElementInner(element: DisassembledInstructionEntry, index: number, column: InstructionColumnTemplateData, height: number | undefined): Promise<void> {
+        column.currentElement.element = element;
+        const instruction = element.instruction;
+        column.sourcecode.innerText = '';
+        const sb = createStringBuilder(1000);
+
+        if (this._disassemblyView.isSourceCodeRender && instruction.location?.path && instruction.line) {
+            const sourceURI = this.getUriFromSource(instruction);
+
+            if (sourceURI) {
+                let textModel: ITextModel | undefined = undefined;
+                const sourceSB = createStringBuilder(10000);
+                const ref = await this.textModelService.createModelReference(sourceURI);
+                textModel = ref.object.textEditorModel;
+                column.cellDisposable.push(ref);
+
+                // templateData could have moved on during async.  Double check if it is still the same source.
+                if (textModel && column.currentElement.element === element) {
+                    let lineNumber = instruction.line;
+
+                    while (lineNumber && lineNumber >= 1 && lineNumber <= textModel.getLineCount()) {
+                        const lineContent = textModel.getLineContent(lineNumber);
+                        sourceSB.appendASCIIString(`  ${lineNumber}: `);
+                        sourceSB.appendASCIIString(lineContent + '\n');
+
+                        if (instruction.endLine && lineNumber < instruction.endLine) {
+                            lineNumber++;
+                            continue;
+                        }
+
+                        break;
+                    }
+
+                    column.sourcecode.innerText = sourceSB.build();
+                }
+            }
+        }
+
+        let spacesToAppend = 10;
+
+        if (instruction.address !== '-1') {
+            sb.appendASCIIString(instruction.address);
+            if (instruction.address.length < InstructionRenderer.INSTRUCTION_ADDR_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer.INSTRUCTION_ADDR_MIN_LENGTH - instruction.address.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendASCIIString(' ');
+            }
+        }
+
+        if (instruction.instructionBytes) {
+            sb.appendASCIIString(instruction.instructionBytes);
+            spacesToAppend = 10;
+            if (instruction.instructionBytes.length < InstructionRenderer.INSTRUCTION_BYTES_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer.INSTRUCTION_BYTES_MIN_LENGTH - instruction.instructionBytes.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendASCIIString(' ');
+            }
+        }
+
+        sb.appendASCIIString(instruction.instruction);
+        column.instruction.innerText = sb.build();
+
+        this.rerenderBackground(column.instruction, column.sourcecode, element);
+    }
+
+    disposeElement(element: DisassembledInstructionEntry, index: number, templateData: InstructionColumnTemplateData, height: number | undefined): void {
+        dispose(templateData.cellDisposable);
+        templateData.cellDisposable = [];
+    }
+
+    disposeTemplate(templateData: InstructionColumnTemplateData): void {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+
+    protected rerenderBackground(instruction: HTMLElement, sourceCode: HTMLElement, element?: DisassembledInstructionEntry): void {
+        if (element && this._disassemblyView.currentInstructionAddresses.includes(element.instruction.address)) {
+            instruction.style.background = this._topStackFrameColor?.toString() || 'transparent';
+        } else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+            instruction.style.background = this._focusedStackFrameColor?.toString() || 'transparent';
+        } else {
+            instruction.style.background = 'transparent';
+        }
+    }
+
+    protected openSourceCode(instruction: DebugProtocol.DisassembledInstruction | undefined): void {
+        if (instruction) {
+            const sourceURI = this.getUriFromSource(instruction);
+            const selection: EditorOpenerOptions['selection'] = instruction.endLine ? {
+                start: { line: instruction.line!, character: instruction.column ?? 0 },
+                end: { line: instruction.endLine, character: instruction.endColumn ?? Constants.MAX_SAFE_SMALL_INTEGER }
+            } : {
+                start: { line: instruction.line!, character: instruction.column ?? 0 },
+                end: { line: instruction.line, character: instruction.endColumn ?? Constants.MAX_SAFE_SMALL_INTEGER }
+            };
+
+            const openerOptions: EditorOpenerOptions = {
+                selection,
+                mode: 'activate',
+                widgetOptions: { area: 'main' }
+            };
+            open(this.openerService, new TheiaURI(sourceURI), openerOptions);
+        }
+    }
+
+    protected getUriFromSource(instruction: DebugProtocol.DisassembledInstruction): URI {
+        // Try to resolve path before consulting the debugSession.
+        const path = instruction.location!.path;
+        if (path && isUri(path)) { // path looks like a uri
+            return this.uriService.asCanonicalUri(URI.parse(path));
+        }
+        // assume a filesystem path
+        if (path && isAbsolute(path)) {
+            return this.uriService.asCanonicalUri(URI.file(path));
+        }
+
+        return getUriFromSource(instruction.location!, instruction.location!.path, this._disassemblyView.debugSession!.id, this.uriService);
+    }
+
+    protected applyFontInfo(element: HTMLElement): void {
+        applyFontInfo(element, this._disassemblyView.fontInfo);
+        element.style.whiteSpace = 'pre';
+    }
+}
+
+export function getUriFromSource(raw: DebugProtocol.Source, path: string | undefined, sessionId: string, uriIdentityService: { asCanonicalUri(uri: URI): URI }): URI {
+    if (typeof raw.sourceReference === 'number' && raw.sourceReference > 0) {
+        return URI.from({
+            scheme: DebugSource.SCHEME,
+            path,
+            query: `session=${sessionId}&ref=${raw.sourceReference}`
+        });
+    }
+
+    if (path && isUri(path)) { // path looks like a uri
+        return uriIdentityService.asCanonicalUri(URI.parse(path));
+    }
+    // assume a filesystem path
+    if (path && isAbsolute(path)) {
+        return uriIdentityService.asCanonicalUri(URI.file(path));
+    }
+    // path is relative: since VS Code cannot deal with this by itself
+    // create a debug url that will result in a DAP 'source' request when the url is resolved.
+    return uriIdentityService.asCanonicalUri(URI.from({
+        scheme: DebugSource.SCHEME,
+        path,
+        query: `session=${sessionId}`
+    }));
+}
+
+function isUri(candidate: string | undefined): boolean {
+    return Boolean(candidate && candidate.match(DebugSource.SCHEME_PATTERN));
+}

package/src/browser/disassembly-view/disassembly-view-table-delegate.ts

@@ -0,0 +1,39 @@
+// *****************************************************************************
+// 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 { ITableVirtualDelegate } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/table/table';
+import { BareFontInfo } from '@theia/monaco-editor-core/esm/vs/editor/common/config/fontInfo';
+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 DisassemblyViewTableDelegate implements ITableVirtualDelegate<DisassembledInstructionEntry> {
+    constructor(protected readonly fontInfoProvider: { fontInfo: BareFontInfo, isSourceCodeRender: boolean }) { }
+
+    headerRowHeight = 0;
+
+    getHeight(row: DisassembledInstructionEntry): number {
+        if (this.fontInfoProvider.isSourceCodeRender && row.instruction.location?.path && row.instruction.line !== undefined) {
+            if (row.instruction.endLine !== undefined) {
+                return this.fontInfoProvider.fontInfo.lineHeight + (row.instruction.endLine - row.instruction.line + 2);
+            } else {
+                return this.fontInfoProvider.fontInfo.lineHeight * 2;
+            }
+        }
+
+        return this.fontInfoProvider.fontInfo.lineHeight;
+    }
+}