@codingame/monaco-vscode-debug-service-override 1.82.6 → 1.83.0-next.0

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

@@ -1,12 +1,13 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { registerColor, asCssVariableName, asCssVariable } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { STATUS_BAR_FOREGROUND, STATUS_BAR_BORDER } from 'vscode/vscode/vs/workbench/common/theme';
+import { STATUS_BAR_FOREGROUND, STATUS_BAR_BORDER, COMMAND_CENTER_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 
 const STATUS_BAR_DEBUGGING_BACKGROUND = registerColor('statusBar.debuggingBackground', {
     dark: '#CC6633',
@@ -35,6 +36,15 @@ const STATUS_BAR_DEBUGGING_BORDER = registerColor('statusBar.debuggingBorder', {
     'statusBarDebuggingBorder',
     "Status bar border color separating to the sidebar and editor when a program is being debugged. The status bar is shown in the bottom of the window"
 )));
+const COMMAND_CENTER_DEBUGGING_BACKGROUND = registerColor('commandCenter.debuggingBackground', {
+    dark: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    hcDark: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    light: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    hcLight: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 }
+}, ( localize(
+    'commandCenter-activeBackground',
+    "Command center background color when a program is being debugged"
+)), true);
 let StatusBarColorProvider = class StatusBarColorProvider {
     set enabled(enabled) {
         if (enabled === !!this.disposable) {
@@ -53,29 +63,35 @@ let StatusBarColorProvider = class StatusBarColorProvider {
             this.disposable = undefined;
         }
     }
-    constructor(debugService, contextService, statusbarService, configurationService) {
+    constructor(debugService, contextService, statusbarService, layoutService, configurationService) {
         this.debugService = debugService;
         this.contextService = contextService;
         this.statusbarService = statusbarService;
+        this.layoutService = layoutService;
         this.configurationService = configurationService;
         this.disposables = ( new DisposableStore());
         this.debugService.onDidChangeState(this.update, this, this.disposables);
         this.contextService.onDidChangeWorkbenchState(this.update, this, this.disposables);
         this.configurationService.onDidChangeConfiguration((e) => {
-            if (e.affectsConfiguration('debug.enableStatusBarColor')) {
+            if (e.affectsConfiguration('debug.enableStatusBarColor') || e.affectsConfiguration('debug.toolBarLocation')) {
                 this.update();
             }
         });
         this.update();
     }
     update() {
-        const decorateStatusBar = this.configurationService.getValue('debug').enableStatusBarColor;
-        if (!decorateStatusBar) {
+        const debugConfig = this.configurationService.getValue('debug');
+        const isInDebugMode = isStatusbarInDebugMode(this.debugService.state, this.debugService.getModel().getSessions());
+        if (!debugConfig.enableStatusBarColor) {
             this.enabled = false;
         }
         else {
-            this.enabled = isStatusbarInDebugMode(this.debugService.state, this.debugService.getModel().getSessions());
+            this.enabled = isInDebugMode;
         }
+        const isInCommandCenter = debugConfig.toolBarLocation === 'commandCenter';
+        this.layoutService.container.style.setProperty(asCssVariableName(COMMAND_CENTER_BACKGROUND), isInCommandCenter && isInDebugMode
+            ? asCssVariable(COMMAND_CENTER_DEBUGGING_BACKGROUND)
+            : '');
     }
     dispose() {
         this.disposable?.dispose();
@@ -86,7 +102,8 @@ StatusBarColorProvider = ( __decorate([
     ( __param(0, IDebugService)),
     ( __param(1, IWorkspaceContextService)),
     ( __param(2, IStatusbarService)),
-    ( __param(3, IConfigurationService))
+    ( __param(3, ILayoutService)),
+    ( __param(4, IConfigurationService))
 ], StatusBarColorProvider));
 function isStatusbarInDebugMode(state, sessions) {
     if (state === 0  || state === 1  || sessions.every(s => s.suppressDebugStatusbar || s.configuration?.noDebug)) {
@@ -95,4 +112,4 @@ function isStatusbarInDebugMode(state, sessions) {
     return true;
 }
 
-export { STATUS_BAR_DEBUGGING_BACKGROUND, STATUS_BAR_DEBUGGING_BORDER, STATUS_BAR_DEBUGGING_FOREGROUND, StatusBarColorProvider, isStatusbarInDebugMode };
+export { COMMAND_CENTER_DEBUGGING_BACKGROUND, STATUS_BAR_DEBUGGING_BACKGROUND, STATUS_BAR_DEBUGGING_BORDER, STATUS_BAR_DEBUGGING_FOREGROUND, StatusBarColorProvider, isStatusbarInDebugMode };

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

@@ -97,6 +97,7 @@ let VariablesView = class VariablesView extends ViewPane {
             forgetScopes = true;
             this.tree.updateChildren();
         }));
+        this._register(this.tree);
         this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
         this._register(this.tree.onContextMenu(async (e) => await this.onContextMenu(e)));
         this._register(this.onDidChangeBodyVisibility(visible => {

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

@@ -345,6 +345,7 @@ class WatchExpressionsDragAndDrop {
         const position = targetElement instanceof Expression ? watches.indexOf(targetElement) : watches.length - 1;
         this.debugService.moveWatchExpression(draggedElement.getId(), position);
     }
+    dispose() { }
 }
 registerAction2(class Collapse extends ViewAction {
     constructor() {

package/vscode/src/vs/workbench/contrib/debug/common/debugModel.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { distinct, findLastIndex } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { DeferredPromise, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { decodeBase64, VSBuffer, encodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
@@ -20,6 +20,7 @@ import { DisassemblyViewInput } from './disassemblyViewInput.js';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { findLastIdx } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
 
 class ExpressionContainer {
     static { this.allValues = ( (new Map())); }
@@ -421,8 +422,9 @@ class StackFrame {
         const threadStopReason = this.thread.stoppedDetails?.reason;
         if (this.instructionPointerReference &&
             (threadStopReason === 'instruction breakpoint' ||
-                (threadStopReason === 'step' && this.thread.lastSteppingGranularity === 'instruction'))) {
-            return editorService.openEditor(DisassemblyViewInput.instance, { pinned: true });
+                (threadStopReason === 'step' && this.thread.lastSteppingGranularity === 'instruction') ||
+                editorService.activeEditor instanceof DisassemblyViewInput)) {
+            return editorService.openEditor(DisassemblyViewInput.instance, { pinned: true, revealIfOpened: true });
         }
         if (this.source.available) {
             return this.source.openInEditor(editorService, this.range, preserveFocus, sideBySide, pinned);
@@ -936,11 +938,12 @@ class ExceptionBreakpoint extends BaseBreakpoint {
     }
 }
 class InstructionBreakpoint extends BaseBreakpoint {
-    constructor(instructionReference, offset, canPersist, enabled, hitCondition, condition, logMessage, id = generateUuid()) {
+    constructor(instructionReference, offset, canPersist, enabled, hitCondition, condition, logMessage, address, id = generateUuid()) {
         super(enabled, hitCondition, condition, logMessage, id);
         this.instructionReference = instructionReference;
         this.offset = offset;
         this.canPersist = canPersist;
+        this.address = address;
     }
     toJSON() {
         const result = super.toJSON();
@@ -1020,7 +1023,7 @@ let DebugModel = class DebugModel extends Disposable {
         }
         let index = -1;
         if (session.parentSession) {
-            index = findLastIndex(this.sessions, s => s.parentSession === session.parentSession || s === session.parentSession);
+            index = findLastIdx(this.sessions, s => s.parentSession === session.parentSession || s === session.parentSession);
         }
         if (index >= 0) {
             this.sessions.splice(index + 1, 0, session);
@@ -1418,16 +1421,30 @@ let DebugModel = class DebugModel extends Disposable {
         }
         this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
     }
-    addInstructionBreakpoint(address, offset, condition, hitCondition) {
-        const newInstructionBreakpoint = ( (new InstructionBreakpoint(address, offset, false, true, hitCondition, condition, undefined)));
+    addInstructionBreakpoint(instructionReference, offset, address, condition, hitCondition) {
+        const newInstructionBreakpoint = ( (new InstructionBreakpoint(
+            instructionReference,
+            offset,
+            false,
+            true,
+            hitCondition,
+            condition,
+            undefined,
+            address
+        )));
         this.instructionBreakpoints.push(newInstructionBreakpoint);
         this._onDidChangeBreakpoints.fire({ added: [newInstructionBreakpoint], sessionOnly: true });
     }
-    removeInstructionBreakpoints(address) {
-        let removed;
-        if (address) {
-            removed = this.instructionBreakpoints.filter(fbp => fbp.instructionReference === address);
-            this.instructionBreakpoints = this.instructionBreakpoints.filter(fbp => fbp.instructionReference !== address);
+    removeInstructionBreakpoints(instructionReference, offset) {
+        let removed = [];
+        if (instructionReference) {
+            for (let i = 0; i < this.instructionBreakpoints.length; i++) {
+                const ibp = this.instructionBreakpoints[i];
+                if (ibp.instructionReference === instructionReference && (offset === undefined || ibp.offset === offset)) {
+                    removed.push(ibp);
+                    this.instructionBreakpoints.splice(i--, 1);
+                }
+            }
         }
         else {
             removed = this.instructionBreakpoints;

package/vscode/src/vs/workbench/contrib/debug/common/debugSchemas.js

@@ -100,6 +100,14 @@ const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
                     type: 'string',
                     default: ''
                 },
+                hiddenWhen: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.hiddenWhen',
+                        "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
+                    )),
+                    type: 'string',
+                    default: ''
+                },
                 deprecated: {
                     description: ( nls.localize(
                         'vscode.extension.contributes.debuggers.deprecated',

package/vscode/src/vs/workbench/contrib/debug/common/debugStorage.js

@@ -22,11 +22,11 @@ let DebugStorage = class DebugStorage extends Disposable {
         this.textFileService = textFileService;
         this.uriIdentityService = uriIdentityService;
         this.logService = logService;
-        this.breakpoints = observableValue('debugBreakpoints', this.loadBreakpoints());
-        this.functionBreakpoints = observableValue('debugFunctionBreakpoints', this.loadFunctionBreakpoints());
-        this.exceptionBreakpoints = observableValue('debugExceptionBreakpoints', this.loadExceptionBreakpoints());
-        this.dataBreakpoints = observableValue('debugDataBreakpoints', this.loadDataBreakpoints());
-        this.watchExpressions = observableValue('debugWatchExpressions', this.loadWatchExpressions());
+        this.breakpoints = observableValue(this, this.loadBreakpoints());
+        this.functionBreakpoints = observableValue(this, this.loadFunctionBreakpoints());
+        this.exceptionBreakpoints = observableValue(this, this.loadExceptionBreakpoints());
+        this.dataBreakpoints = observableValue(this, this.loadDataBreakpoints());
+        this.watchExpressions = observableValue(this, this.loadWatchExpressions());
         this._register(storageService.onDidChangeValue(1 , undefined, this._store)(e => {
             if (e.external) {
                 switch (e.key) {

package/vscode/src/vs/workbench/contrib/debug/common/debugger.js

@@ -27,6 +27,7 @@ let Debugger = class Debugger {
         this.debuggerContribution = { type: dbgContribution.type };
         this.merge(dbgContribution, extensionDescription);
         this.debuggerWhen = typeof this.debuggerContribution.when === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
+        this.debuggerHiddenWhen = typeof this.debuggerContribution.hiddenWhen === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.hiddenWhen) : undefined;
     }
     merge(otherDebuggerContribution, extensionDescription) {
         function mixin(destination, source, overwrite, level = 0) {
@@ -102,9 +103,18 @@ let Debugger = class Debugger {
     get when() {
         return this.debuggerWhen;
     }
+    get hiddenWhen() {
+        return this.debuggerHiddenWhen;
+    }
     get enabled() {
         return !this.debuggerWhen || this.contextKeyService.contextMatchesRules(this.debuggerWhen);
     }
+    get isHiddenFromDropdown() {
+        if (!this.debuggerHiddenWhen) {
+            return false;
+        }
+        return this.contextKeyService.contextMatchesRules(this.debuggerHiddenWhen);
+    }
     get strings() {
         return this.debuggerContribution.strings ?? this.debuggerContribution.uiMessages;
     }