@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/browser/disassemblyView.js

@@ -0,0 +1,663 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { PixelRatio } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { append, $, addStandardDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { BareFontInfo } from 'monaco-editor/esm/vs/editor/common/config/fontInfo.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { DISASSEMBLY_VIEW_ID, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { breakpoint, debugBreakpointHint, debugStackframe, debugStackframeFocused } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { StringBuilder } from 'monaco-editor/esm/vs/editor/common/core/stringBuilder.js';
+import { dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { topStackFrameColor, focusedStackFrameColor } from './callStackEditorContribution.js';
+import { InstructionBreakpoint } from '../common/debugModel.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { getUriFromSource } from '../common/debugSource.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isUri } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { applyFontInfo } from 'monaco-editor/esm/vs/editor/browser/config/domFontInfo.js';
+import { binarySearch2 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+var DisassemblyView_1, BreakpointRenderer_1, InstructionRenderer_1;
+const disassemblyNotAvailable = {
+    allowBreakpoint: false,
+    isBreakpointSet: false,
+    isBreakpointEnabled: false,
+    instruction: {
+        address: '-1',
+        instruction: ( (localize('instructionNotAvailable', "Disassembly not available.")))
+    },
+    instructionAddress: BigInt(-1)
+};
+let DisassemblyView = class DisassemblyView extends EditorPane {
+    static { DisassemblyView_1 = this; }
+    static { this.NUM_INSTRUCTIONS_TO_LOAD = 50; }
+    constructor(telemetryService, themeService, storageService, _configurationService, _instantiationService, _debugService) {
+        super(DISASSEMBLY_VIEW_ID, telemetryService, themeService, storageService);
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._debugService = _debugService;
+        this._instructionBpList = [];
+        this._enableSourceCodeRender = true;
+        this._loadingLock = false;
+        this._disassembledInstructions = undefined;
+        this._onDidChangeStackFrame = ( (new Emitter()));
+        this._previousDebuggingState = _debugService.state;
+        this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
+        this._register(_configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor')) {
+                this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
+            }
+            if (e.affectsConfiguration('debug')) {
+                const newValue = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+                if (this._enableSourceCodeRender !== newValue) {
+                    this._enableSourceCodeRender = newValue;
+                    this.reloadDisassembly(undefined);
+                }
+                else {
+                    this._disassembledInstructions?.rerender();
+                }
+            }
+        }));
+    }
+    get fontInfo() { return this._fontInfo; }
+    get currentInstructionAddresses() {
+        return (
+             (( (( (this._debugService.getModel().getSessions(false).
+                map(session => session.getAllThreads()))).
+                reduce((prev, curr) => prev.concat(curr), []).
+                map(thread => thread.getTopStackFrame()))).
+                map(frame => frame?.instructionPointerReference))
+        );
+    }
+    get focusedCurrentInstructionAddress() {
+        return this._debugService.getViewModel().focusedStackFrame?.thread.getTopStackFrame()?.instructionPointerReference;
+    }
+    get focusedInstructionAddress() {
+        return this._debugService.getViewModel().focusedStackFrame?.instructionPointerReference;
+    }
+    get isSourceCodeRender() { return this._enableSourceCodeRender; }
+    get debugSession() {
+        return this._debugService.getViewModel().focusedSession;
+    }
+    get onDidChangeStackFrame() { return this._onDidChangeStackFrame.event; }
+    createEditor(parent) {
+        this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+        const lineHeight = this.fontInfo.lineHeight;
+        const thisOM = this;
+        const delegate = new class {
+            constructor() {
+                this.headerRowHeight = 0;
+            }
+            getHeight(row) {
+                if (thisOM.isSourceCodeRender && row.instruction.location?.path && row.instruction.line) {
+                    if (row.instruction.endLine) {
+                        return lineHeight * (row.instruction.endLine - row.instruction.line + 2);
+                    }
+                    else {
+                        return lineHeight * 2;
+                    }
+                }
+                return lineHeight;
+            }
+        };
+        const instructionRenderer = this._register(this._instantiationService.createInstance(InstructionRenderer, this));
+        this._disassembledInstructions = this._register(this._instantiationService.createInstance(WorkbenchTable, 'DisassemblyView', parent, delegate, [
+            {
+                label: '',
+                tooltip: '',
+                weight: 0,
+                minimumWidth: this.fontInfo.lineHeight,
+                maximumWidth: this.fontInfo.lineHeight,
+                templateId: BreakpointRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('disassemblyTableColumnLabel', "instructions"))),
+                tooltip: '',
+                weight: 0.3,
+                templateId: InstructionRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+        ], [
+            this._instantiationService.createInstance(BreakpointRenderer, this),
+            instructionRenderer,
+        ], {
+            identityProvider: { getId: (e) => e.instruction.address },
+            horizontalScrolling: false,
+            overrideStyles: {
+                listBackground: editorBackground
+            },
+            multipleSelectionSupport: false,
+            setRowLineHeight: false,
+            openOnSingleClick: false,
+            accessibilityProvider: ( (new AccessibilityProvider())),
+            mouseSupport: false
+        }));
+        this.reloadDisassembly();
+        this._register(this._disassembledInstructions.onDidScroll(e => {
+            if (this._loadingLock) {
+                return;
+            }
+            if (e.oldScrollTop > e.scrollTop && e.scrollTop < e.height) {
+                this._loadingLock = true;
+                const topElement = Math.floor(e.scrollTop / this.fontInfo.lineHeight) + DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD;
+                this.scrollUp_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then((success) => {
+                    if (success) {
+                        this._disassembledInstructions.reveal(topElement, 0);
+                    }
+                    this._loadingLock = false;
+                });
+            }
+            else if (e.oldScrollTop < e.scrollTop && e.scrollTop + e.height > e.scrollHeight - e.height) {
+                this._loadingLock = true;
+                this.scrollDown_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then(() => { this._loadingLock = false; });
+            }
+        }));
+        this._register(this._debugService.getViewModel().onDidFocusStackFrame((stackFrame) => {
+            if (this._disassembledInstructions) {
+                this.goToAddress();
+                this._onDidChangeStackFrame.fire();
+            }
+        }));
+        this._register(this._debugService.getModel().onDidChangeBreakpoints(bpEvent => {
+            if (bpEvent && this._disassembledInstructions) {
+                let changed = false;
+                bpEvent.added?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        if (index >= 0) {
+                            this._disassembledInstructions.row(index).isBreakpointSet = true;
+                            this._disassembledInstructions.row(index).isBreakpointEnabled = bp.enabled;
+                            changed = true;
+                        }
+                    }
+                });
+                bpEvent.removed?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        if (index >= 0) {
+                            this._disassembledInstructions.row(index).isBreakpointSet = false;
+                            changed = true;
+                        }
+                    }
+                });
+                bpEvent.changed?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        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;
+                            }
+                        }
+                    }
+                });
+                this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+                if (changed) {
+                    this._onDidChangeStackFrame.fire();
+                }
+            }
+        }));
+        this._register(this._debugService.onDidChangeState(e => {
+            if (((e === 3  || e === 2) ) &&
+                ((this._previousDebuggingState !== 3  && this._previousDebuggingState !== 2) )) {
+                this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
+                this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+            }
+            this._previousDebuggingState = e;
+        }));
+    }
+    layout(dimension) {
+        this._disassembledInstructions?.layout(dimension.height);
+    }
+    goToAddress(address, focus) {
+        if (!this._disassembledInstructions) {
+            return;
+        }
+        if (!address) {
+            address = this.focusedInstructionAddress;
+        }
+        if (!address) {
+            return;
+        }
+        const index = this.getIndexFromAddress(address);
+        if (index >= 0) {
+            this._disassembledInstructions.reveal(index);
+            if (focus) {
+                this._disassembledInstructions.domFocus();
+                this._disassembledInstructions.setFocus([index]);
+            }
+        }
+        else if (this._debugService.state === 2 ) {
+            this.reloadDisassembly(address);
+        }
+    }
+    async scrollUp_LoadDisassembledInstructions(instructionCount) {
+        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
+            const address = this._disassembledInstructions?.row(0).instruction.address;
+            return this.loadDisassembledInstructions(address, -instructionCount, instructionCount);
+        }
+        return false;
+    }
+    async scrollDown_LoadDisassembledInstructions(instructionCount) {
+        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
+            const address = this._disassembledInstructions?.row(this._disassembledInstructions?.length - 1).instruction.address;
+            return this.loadDisassembledInstructions(address, 1, instructionCount);
+        }
+        return false;
+    }
+    async loadDisassembledInstructions(address, instructionOffset, instructionCount) {
+        if (!address || address === '-1') {
+            address = this.focusedInstructionAddress;
+        }
+        if (!address) {
+            return false;
+        }
+        const session = this.debugSession;
+        const resultEntries = await session?.disassemble(address, 0, instructionOffset, instructionCount);
+        if (session && resultEntries && this._disassembledInstructions) {
+            const newEntries = [];
+            let lastLocation;
+            let lastLine;
+            for (let i = 0; i < resultEntries.length; i++) {
+                const found = this._instructionBpList.find(p => p.instructionReference === resultEntries[i].address);
+                const instruction = resultEntries[i];
+                if (instruction.location) {
+                    lastLocation = instruction.location;
+                    lastLine = undefined;
+                }
+                if (instruction.line) {
+                    const currentLine = {
+                        startLineNumber: instruction.line,
+                        startColumn: instruction.column ?? 0,
+                        endLineNumber: instruction.endLine ?? instruction.line,
+                        endColumn: instruction.endColumn ?? 0,
+                    };
+                    if (!Range.equalsRange(currentLine, lastLine ?? null)) {
+                        lastLine = currentLine;
+                        instruction.location = lastLocation;
+                    }
+                }
+                newEntries.push({ allowBreakpoint: true, isBreakpointSet: found !== undefined, isBreakpointEnabled: !!found?.enabled, instruction: instruction });
+            }
+            const specialEntriesToRemove = this._disassembledInstructions.length === 1 ? 1 : 0;
+            if (instructionOffset >= 0) {
+                this._disassembledInstructions.splice(this._disassembledInstructions.length, specialEntriesToRemove, newEntries);
+            }
+            else {
+                this._disassembledInstructions.splice(0, specialEntriesToRemove, newEntries);
+            }
+            return true;
+        }
+        return false;
+    }
+    getIndexFromAddress(instructionAddress) {
+        const disassembledInstructions = this._disassembledInstructions;
+        if (disassembledInstructions && disassembledInstructions.length > 0) {
+            const address = BigInt(instructionAddress);
+            if (address) {
+                return binarySearch2(disassembledInstructions.length, index => {
+                    const row = disassembledInstructions.row(index);
+                    this.ensureAddressParsed(row);
+                    if (row.instructionAddress > address) {
+                        return 1;
+                    }
+                    else if (row.instructionAddress < address) {
+                        return -1;
+                    }
+                    else {
+                        return 0;
+                    }
+                });
+            }
+        }
+        return -1;
+    }
+    ensureAddressParsed(entry) {
+        if (entry.instructionAddress !== undefined) {
+            return;
+        }
+        else {
+            entry.instructionAddress = BigInt(entry.instruction.address);
+        }
+    }
+    reloadDisassembly(targetAddress) {
+        if (this._disassembledInstructions) {
+            this._loadingLock = true;
+            this._disassembledInstructions.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
+            this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+            this.loadDisassembledInstructions(targetAddress, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
+                if (this._disassembledInstructions.length > 0) {
+                    const targetIndex = Math.floor(this._disassembledInstructions.length / 2);
+                    this._disassembledInstructions.reveal(targetIndex, 0.5);
+                    this._disassembledInstructions.domFocus();
+                    this._disassembledInstructions.setFocus([targetIndex]);
+                }
+                this._loadingLock = false;
+            });
+        }
+    }
+};
+DisassemblyView = DisassemblyView_1 = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IStorageService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IDebugService)))
+], DisassemblyView)));
+let BreakpointRenderer = class BreakpointRenderer {
+    static { BreakpointRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'breakpoint'; }
+    constructor(_disassemblyView, _debugService) {
+        this._disassemblyView = _disassemblyView;
+        this._debugService = _debugService;
+        this.templateId = BreakpointRenderer_1.TEMPLATE_ID;
+        this._breakpointIcon = 'codicon-' + breakpoint.regular.id;
+        this._breakpointDisabledIcon = 'codicon-' + breakpoint.disabled.id;
+        this._breakpointHintIcon = 'codicon-' + debugBreakpointHint.id;
+        this._debugStackframe = 'codicon-' + debugStackframe.id;
+        this._debugStackframeFocused = 'codicon-' + debugStackframeFocused.id;
+    }
+    renderTemplate(container) {
+        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: 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) {
+                    icon.classList.add(this._breakpointHintIcon);
+                    if (currentElement.element.isBreakpointSet) {
+                        this._debugService.removeInstructionBreakpoints(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, index, templateData, height) {
+        templateData.currentElement.element = element;
+        this.rerenderDebugStackframe(templateData.icon, element);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+    rerenderDebugStackframe(icon, element) {
+        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);
+        }
+    }
+};
+BreakpointRenderer = BreakpointRenderer_1 = ( (__decorate([
+    ( (__param(1, IDebugService)))
+], BreakpointRenderer)));
+let InstructionRenderer = class InstructionRenderer extends Disposable {
+    static { InstructionRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'instruction'; }
+    static { this.INSTRUCTION_ADDR_MIN_LENGTH = 25; }
+    static { this.INSTRUCTION_BYTES_MIN_LENGTH = 30; }
+    constructor(_disassemblyView, themeService, editorService, textModelService, uriService, logService) {
+        super();
+        this._disassemblyView = _disassemblyView;
+        this.editorService = editorService;
+        this.textModelService = textModelService;
+        this.uriService = uriService;
+        this.logService = logService;
+        this.templateId = InstructionRenderer_1.TEMPLATE_ID;
+        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) {
+        const sourcecode = append(container, $('.sourcecode'));
+        const instruction = append(container, $('.instruction'));
+        this.applyFontInfo(sourcecode);
+        this.applyFontInfo(instruction);
+        const currentElement = { element: undefined };
+        const cellDisposable = [];
+        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, index, templateData, height) {
+        this.renderElementInner(element, index, templateData, height);
+    }
+    async renderElementInner(element, index, templateData, height) {
+        templateData.currentElement.element = element;
+        const instruction = element.instruction;
+        templateData.sourcecode.innerText = '';
+        const sb = ( (new StringBuilder(1000)));
+        if (this._disassemblyView.isSourceCodeRender && instruction.location?.path && instruction.line) {
+            const sourceURI = this.getUriFromSource(instruction);
+            if (sourceURI) {
+                let textModel = undefined;
+                const sourceSB = ( (new StringBuilder(10000)));
+                const ref = await this.textModelService.createModelReference(sourceURI);
+                textModel = ref.object.textEditorModel;
+                templateData.cellDisposable.push(ref);
+                if (textModel && templateData.currentElement.element === element) {
+                    let lineNumber = instruction.line;
+                    while (lineNumber && lineNumber >= 1 && lineNumber <= textModel.getLineCount()) {
+                        const lineContent = textModel.getLineContent(lineNumber);
+                        sourceSB.appendString(`  ${lineNumber}: `);
+                        sourceSB.appendString(lineContent + '\n');
+                        if (instruction.endLine && lineNumber < instruction.endLine) {
+                            lineNumber++;
+                            continue;
+                        }
+                        break;
+                    }
+                    templateData.sourcecode.innerText = sourceSB.build();
+                }
+            }
+        }
+        let spacesToAppend = 10;
+        if (instruction.address !== '-1') {
+            sb.appendString(instruction.address);
+            if (instruction.address.length < InstructionRenderer_1.INSTRUCTION_ADDR_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer_1.INSTRUCTION_ADDR_MIN_LENGTH - instruction.address.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendString(' ');
+            }
+        }
+        if (instruction.instructionBytes) {
+            sb.appendString(instruction.instructionBytes);
+            spacesToAppend = 10;
+            if (instruction.instructionBytes.length < InstructionRenderer_1.INSTRUCTION_BYTES_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer_1.INSTRUCTION_BYTES_MIN_LENGTH - instruction.instructionBytes.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendString(' ');
+            }
+        }
+        sb.appendString(instruction.instruction);
+        templateData.instruction.innerText = sb.build();
+        this.rerenderBackground(templateData.instruction, templateData.sourcecode, element);
+    }
+    disposeElement(element, index, templateData, height) {
+        dispose(templateData.cellDisposable);
+        templateData.cellDisposable = [];
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+    rerenderBackground(instruction, sourceCode, element) {
+        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';
+        }
+    }
+    openSourceCode(instruction) {
+        if (instruction) {
+            const sourceURI = this.getUriFromSource(instruction);
+            const selection = instruction.endLine ? {
+                startLineNumber: instruction.line,
+                endLineNumber: instruction.endLine,
+                startColumn: instruction.column || 1,
+                endColumn: instruction.endColumn || 1073741824 ,
+            } : {
+                startLineNumber: instruction.line,
+                endLineNumber: instruction.line,
+                startColumn: instruction.column || 1,
+                endColumn: instruction.endColumn || 1073741824 ,
+            };
+            this.editorService.openEditor({
+                resource: sourceURI,
+                description: ( (localize('editorOpenedFromDisassemblyDescription', "from disassembly"))),
+                options: {
+                    preserveFocus: false,
+                    selection: selection,
+                    revealIfOpened: true,
+                    selectionRevealType: 1 ,
+                    pinned: false,
+                }
+            });
+        }
+    }
+    getUriFromSource(instruction) {
+        const path = instruction.location.path;
+        if (path && isUri(path)) {
+            return this.uriService.asCanonicalUri(( (URI.parse(path))));
+        }
+        if (path && isAbsolute(path)) {
+            return this.uriService.asCanonicalUri(URI.file(path));
+        }
+        return getUriFromSource(instruction.location, instruction.location.path, this._disassemblyView.debugSession.getId(), this.uriService, this.logService);
+    }
+    applyFontInfo(element) {
+        applyFontInfo(element, this._disassemblyView.fontInfo);
+        element.style.whiteSpace = 'pre';
+    }
+};
+InstructionRenderer = InstructionRenderer_1 = ( (__decorate([
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IEditorService))),
+    ( (__param(3, ITextModelService))),
+    ( (__param(4, IUriIdentityService))),
+    ( (__param(5, ILogService)))
+], InstructionRenderer)));
+class AccessibilityProvider {
+    getWidgetAriaLabel() {
+        return (
+             (localize('disassemblyView', "Disassembly View"))
+        );
+    }
+    getAriaLabel(element) {
+        let label = '';
+        const instruction = element.instruction;
+        if (instruction.address !== '-1') {
+            label += `${( ( localize('instructionAddress', "Address")))}: ${instruction.address}`;
+        }
+        if (instruction.instructionBytes) {
+            label += `, ${( ( localize('instructionBytes', "Bytes")))}: ${instruction.instructionBytes}`;
+        }
+        label += `, ${( ( localize(`instructionText`, "Instruction")))}: ${instruction.instruction}`;
+        return label;
+    }
+}
+let DisassemblyViewContribution = class DisassemblyViewContribution {
+    constructor(editorService, debugService, contextKeyService) {
+        contextKeyService.bufferChangeEvents(() => {
+            this._languageSupportsDisassemleRequest = CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST.bindTo(contextKeyService);
+        });
+        const onDidActiveEditorChangeListener = () => {
+            if (this._onDidChangeModelLanguage) {
+                this._onDidChangeModelLanguage.dispose();
+                this._onDidChangeModelLanguage = undefined;
+            }
+            const activeTextEditorControl = editorService.activeTextEditorControl;
+            if (isCodeEditor(activeTextEditorControl)) {
+                const language = activeTextEditorControl.getModel()?.getLanguageId();
+                this._languageSupportsDisassemleRequest?.set(!!language && debugService.getAdapterManager().someDebuggerInterestedInLanguage(language));
+                this._onDidChangeModelLanguage = activeTextEditorControl.onDidChangeModelLanguage(e => {
+                    this._languageSupportsDisassemleRequest?.set(debugService.getAdapterManager().someDebuggerInterestedInLanguage(e.newLanguage));
+                });
+            }
+            else {
+                this._languageSupportsDisassemleRequest?.set(false);
+            }
+        };
+        onDidActiveEditorChangeListener();
+        this._onDidActiveEditorChangeListener = editorService.onDidActiveEditorChange(onDidActiveEditorChangeListener);
+    }
+    dispose() {
+        this._onDidActiveEditorChangeListener.dispose();
+        this._onDidChangeModelLanguage?.dispose();
+    }
+};
+DisassemblyViewContribution = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IContextKeyService)))
+], DisassemblyViewContribution)));
+
+export { DisassemblyView, DisassemblyViewContribution };