@codingame/monaco-vscode-debug-service-override 1.83.1 → 1.83.2

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

@@ -43,7 +43,7 @@ const disassemblyNotAvailable = {
     address: 0n,
     instruction: {
         address: '-1',
-        instruction: ( (localize('instructionNotAvailable', "Disassembly not available.")))
+        instruction: ( localize('instructionNotAvailable', "Disassembly not available."))
     },
 };
 let DisassemblyView = class DisassemblyView extends EditorPane {
@@ -57,9 +57,9 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._instructionBpList = [];
         this._enableSourceCodeRender = true;
         this._loadingLock = false;
-        this._referenceToMemoryAddress = ( (new Map()));
+        this._referenceToMemoryAddress = ( new Map());
         this._disassembledInstructions = undefined;
-        this._onDidChangeStackFrame = this._register(( (new Emitter({ leakWarningThreshold: 1000 }))));
+        this._onDidChangeStackFrame = this._register(( new Emitter({ leakWarningThreshold: 1000 })));
         this._previousDebuggingState = _debugService.state;
         this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
         this._register(_configurationService.onDidChangeConfiguration(e => {
@@ -79,14 +79,12 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     }
     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))).
-                map(ref => ref ? this.getReferenceAddress(ref) : undefined))
-        );
+        return ( ( ( ( this._debugService.getModel().getSessions(false).
+            map(session => session.getAllThreads())).
+            reduce((prev, curr) => prev.concat(curr), []).
+            map(thread => thread.getTopStackFrame())).
+            map(frame => frame?.instructionPointerReference)).
+            map(ref => ref ? this.getReferenceAddress(ref) : undefined));
     }
     get focusedCurrentInstructionReference() {
         return this._debugService.getViewModel().focusedStackFrame?.thread.getTopStackFrame()?.instructionPointerReference;
@@ -148,7 +146,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 project(row) { return row; }
             },
             {
-                label: ( (localize('disassemblyTableColumnLabel', "instructions"))),
+                label: ( localize('disassemblyTableColumnLabel', "instructions")),
                 tooltip: '',
                 weight: 0.3,
                 templateId: InstructionRenderer.TEMPLATE_ID,
@@ -166,7 +164,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             multipleSelectionSupport: false,
             setRowLineHeight: false,
             openOnSingleClick: false,
-            accessibilityProvider: ( (new AccessibilityProvider())),
+            accessibilityProvider: ( new AccessibilityProvider()),
             mouseSupport: false
         }));
         if (this.focusedInstructionReference) {
@@ -298,7 +296,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         return 0;
     }
     async primeMemoryReference(instructionReference) {
-        if (( (this._referenceToMemoryAddress.has(instructionReference)))) {
+        if (( this._referenceToMemoryAddress.has(instructionReference))) {
             return true;
         }
         const s = await this.debugSession?.disassemble(instructionReference, 0, 0, 1);
@@ -316,7 +314,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     async loadDisassembledInstructions(instructionReference, offset, instructionOffset, instructionCount) {
         const session = this.debugSession;
         const resultEntries = await session?.disassemble(instructionReference, offset, instructionOffset, instructionCount);
-        if (!( (this._referenceToMemoryAddress.has(instructionReference))) && instructionOffset !== 0) {
+        if (!( this._referenceToMemoryAddress.has(instructionReference)) && instructionOffset !== 0) {
             await this.loadDisassembledInstructions(instructionReference, 0, 0, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD);
         }
         if (session && resultEntries && this._disassembledInstructions) {
@@ -369,7 +367,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 return 0;
             }
             const refBaseAddress = this._referenceToMemoryAddress.get(instructionReference);
-            const bps = ( (this._instructionBpList.map(p => {
+            const bps = ( this._instructionBpList.map(p => {
                 const base = this._referenceToMemoryAddress.get(p.instructionReference);
                 if (!base) {
                     return undefined;
@@ -378,7 +376,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                     enabled: p.enabled,
                     address: base + BigInt(p.offset || 0),
                 };
-            })));
+            }));
             if (refBaseAddress !== undefined) {
                 for (const entry of newEntries) {
                     const bp = bps.find(p => p?.address === entry.address);
@@ -459,14 +457,14 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
     }
 };
-DisassemblyView = DisassemblyView_1 = ( (__decorate([
-    ( (__param(0, ITelemetryService))),
-    ( (__param(1, IThemeService))),
-    ( (__param(2, IStorageService))),
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, IInstantiationService))),
-    ( (__param(5, IDebugService)))
-], DisassemblyView)));
+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'; }
@@ -553,9 +551,9 @@ let BreakpointRenderer = class BreakpointRenderer {
         }
     }
 };
-BreakpointRenderer = BreakpointRenderer_1 = ( (__decorate([
-    ( (__param(1, IDebugService)))
-], BreakpointRenderer)));
+BreakpointRenderer = BreakpointRenderer_1 = ( __decorate([
+    ( __param(1, IDebugService))
+], BreakpointRenderer));
 let InstructionRenderer = class InstructionRenderer extends Disposable {
     static { InstructionRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'instruction'; }
@@ -596,12 +594,12 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         templateData.currentElement.element = element;
         const instruction = element.instruction;
         templateData.sourcecode.innerText = '';
-        const sb = ( (new StringBuilder(1000)));
+        const sb = ( new StringBuilder(1000));
         if (this._disassemblyView.isSourceCodeRender && element.showSourceLocation && instruction.location?.path && instruction.line !== undefined) {
             const sourceURI = this.getUriFromSource(instruction);
             if (sourceURI) {
                 let textModel = undefined;
-                const sourceSB = ( (new StringBuilder(10000)));
+                const sourceSB = ( new StringBuilder(10000));
                 const ref = await this.textModelService.createModelReference(sourceURI);
                 textModel = ref.object.textEditorModel;
                 templateData.cellDisposable.push(ref);
@@ -680,7 +678,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
             };
             this.editorService.openEditor({
                 resource: sourceURI,
-                description: ( (localize('editorOpenedFromDisassemblyDescription', "from disassembly"))),
+                description: ( localize('editorOpenedFromDisassemblyDescription', "from disassembly")),
                 options: {
                     preserveFocus: false,
                     selection: selection,
@@ -694,7 +692,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
     getUriFromSource(instruction) {
         const path = instruction.location.path;
         if (path && isUri(path)) {
-            return this.uriService.asCanonicalUri(( (URI.parse(path))));
+            return this.uriService.asCanonicalUri(( URI.parse(path)));
         }
         if (path && isAbsolute(path)) {
             return this.uriService.asCanonicalUri(URI.file(path));
@@ -706,29 +704,27 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         element.style.whiteSpace = 'pre';
     }
 };
-InstructionRenderer = InstructionRenderer_1 = ( (__decorate([
-    ( (__param(1, IThemeService))),
-    ( (__param(2, IEditorService))),
-    ( (__param(3, ITextModelService))),
-    ( (__param(4, IUriIdentityService))),
-    ( (__param(5, ILogService)))
-], InstructionRenderer)));
+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"))
-        );
+        return ( localize('disassemblyView', "Disassembly View"));
     }
     getAriaLabel(element) {
         let label = '';
         const instruction = element.instruction;
         if (instruction.address !== '-1') {
-            label += `${( ( localize('instructionAddress', "Address")))}: ${instruction.address}`;
+            label += `${( localize('instructionAddress', "Address"))}: ${instruction.address}`;
         }
         if (instruction.instructionBytes) {
-            label += `, ${( ( localize('instructionBytes', "Bytes")))}: ${instruction.instructionBytes}`;
+            label += `, ${( localize('instructionBytes', "Bytes"))}: ${instruction.instructionBytes}`;
         }
-        label += `, ${( ( localize(`instructionText`, "Instruction")))}: ${instruction.instruction}`;
+        label += `, ${( localize(`instructionText`, "Instruction"))}: ${instruction.instruction}`;
         return label;
     }
 }
@@ -762,10 +758,10 @@ let DisassemblyViewContribution = class DisassemblyViewContribution {
         this._onDidChangeModelLanguage?.dispose();
     }
 };
-DisassemblyViewContribution = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, IDebugService))),
-    ( (__param(2, IContextKeyService)))
-], DisassemblyViewContribution)));
+DisassemblyViewContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IDebugService)),
+    ( __param(2, IContextKeyService))
+], DisassemblyViewContribution));
 
 export { DisassemblyView, DisassemblyViewContribution };

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

@@ -5,25 +5,24 @@ import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/b
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { CONTEXT_DEBUGGERS_AVAILABLE, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Extensions, ViewContentGroups, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.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 { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { DEBUG_START_COMMAND_ID, SELECT_AND_START_ID } from './debugCommands.js';
+import { DEBUG_START_COMMAND_ID } from './debugCommands.js';
 
 const debugStartLanguageKey = 'debugStartLanguage';
-const CONTEXT_DEBUG_START_LANGUAGE = ( (new RawContextKey(debugStartLanguageKey, undefined)));
-const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( (new RawContextKey('debuggerInterestedInActiveEditor', false)));
+const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
+const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey('debuggerInterestedInActiveEditor', false));
 let WelcomeView = class WelcomeView extends ViewPane {
     static { this.ID = 'workbench.debug.welcome'; }
-    static { this.LABEL = ( (localize('run', "Run"))); }
+    static { this.LABEL = ( localize('run', "Run")); }
     constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, telemetryService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
         this.debugService = debugService;
@@ -46,7 +45,7 @@ let WelcomeView = class WelcomeView extends ViewPane {
             }
             this.debuggerInterestedContext.set(false);
         };
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         this._register(disposables);
         this._register(editorService.onDidActiveEditorChange(() => {
             disposables.clear();
@@ -70,33 +69,20 @@ let WelcomeView = class WelcomeView extends ViewPane {
         return true;
     }
 };
-WelcomeView = ( (__decorate([
-    ( (__param(1, IThemeService))),
-    ( (__param(2, IKeybindingService))),
-    ( (__param(3, IContextMenuService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, IContextKeyService))),
-    ( (__param(6, IDebugService))),
-    ( (__param(7, IEditorService))),
-    ( (__param(8, IInstantiationService))),
-    ( (__param(9, IViewDescriptorService))),
-    ( (__param(10, IOpenerService))),
-    ( (__param(11, IStorageService))),
-    ( (__param(12, ITelemetryService)))
-], WelcomeView)));
-const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
+WelcomeView = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IDebugService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, ITelemetryService))
+], WelcomeView));
 let debugKeybindingLabel = '';
-( (viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( ( localize('runAndDebugAction', "Run and Debug")))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
-    when: CONTEXT_DEBUGGERS_AVAILABLE,
-    group: ViewContentGroups.Debug,
-    order: 1
-})));
-( (viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( ( localize('detectThenRunAndDebug', "Show all automatic debug configurations")))}](command:${SELECT_AND_START_ID}).`,
-    when: CONTEXT_DEBUGGERS_AVAILABLE,
-    group: ViewContentGroups.Debug,
-    order: 10
-})));
 
 export { WelcomeView };