@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/debug/browser/debugEditorActions.js

@@ -7,7 +7,7 @@ import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorCont
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
 import { MessageController } from 'monaco-editor/esm/vs/editor/contrib/message/browser/messageController.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { registerAction2, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
@@ -233,7 +233,7 @@ class RunToCursorAction extends EditorAction {
             id: RunToCursorAction.ID,
             label: RunToCursorAction.LABEL,
             alias: 'Debug: Run to Cursor',
-            precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), EditorContextKeys.editorTextFocus)),
+            precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ( PanelFocusContext.toNegated()), ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {
                 group: 'debug',
                 order: 2
@@ -300,7 +300,7 @@ class SelectionToWatchExpressionsAction extends EditorAction {
             id: SelectionToWatchExpressionsAction.ID,
             label: SelectionToWatchExpressionsAction.LABEL,
             alias: 'Debug: Add to Watch',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus)),
+            precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus)),
             contextMenuOpts: {
                 group: 'debug',
                 order: 1
@@ -507,6 +507,8 @@ class CloseExceptionWidgetAction extends EditorAction {
         contribution?.closeExceptionWidget();
     }
 }
+registerAction2(OpenDisassemblyViewAction);
+registerAction2(ToggleDisassemblyViewSourceCodeAction);
 registerEditorAction(ToggleBreakpointAction);
 registerEditorAction(ConditionalBreakpointAction);
 registerEditorAction(LogPointAction);

package/dist/vscode/vs/workbench/contrib/debug/browser/debugEditorContribution.js

@@ -306,12 +306,15 @@ let DebugEditorContribution = class DebugEditorContribution {
     async showHover(position, focus) {
         const sf = this.debugService.getViewModel().focusedStackFrame;
         const model = this.editor.getModel();
-        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri) && !this.altPressed) {
+        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
             const result = await this.hoverWidget.showAt(position, focus);
             if (result === 1 ) {
                 this.showEditorHover(position, focus);
             }
         }
+        else {
+            this.showEditorHover(position, focus);
+        }
     }
     showEditorHover(position, focus) {
         const hoverController = this.editor.getContribution(ModesHoverController.ID);
@@ -334,7 +337,7 @@ let DebugEditorContribution = class DebugEditorContribution {
     get showHoverScheduler() {
         const hoverOption = this.editor.getOption(58 );
         const scheduler = ( new RunOnceScheduler(() => {
-            if (this.hoverPosition) {
+            if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition, false);
             }
         }, hoverOption.delay * 2));

package/dist/vscode/vs/workbench/contrib/debug/browser/debugHover.js

@@ -4,6 +4,7 @@ import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrol
 import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import * as lifecycle from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
 import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
@@ -49,6 +50,7 @@ let DebugHoverWidget = class DebugHoverWidget {
         this.instantiationService = instantiationService;
         this.allowEditorOverflow = true;
         this.highlightDecorations = this.editor.createDecorationsCollection();
+        this.isUpdatingTree = false;
         this.toDispose = [];
         this._isVisible = false;
         this.showAtPosition = null;
@@ -89,7 +91,16 @@ let DebugHoverWidget = class DebugHoverWidget {
         this.domNode.style.backgroundColor = asCssVariable(editorHoverBackground);
         this.domNode.style.border = `1px solid ${asCssVariable(editorHoverBorder)}`;
         this.domNode.style.color = asCssVariable(editorHoverForeground);
-        this.toDispose.push(this.tree.onDidChangeContentHeight(() => this.layoutTreeAndContainer(false)));
+        this.toDispose.push(this.tree.onDidChangeContentHeight(() => {
+            if (!this.isUpdatingTree) {
+                this.layoutTreeAndContainer();
+            }
+        }));
+        this.toDispose.push(this.tree.onDidChangeContentWidth(() => {
+            if (!this.isUpdatingTree) {
+                this.layoutTreeAndContainer();
+            }
+        }));
         this.registerListeners();
         this.editor.addContentWidget(this);
     }
@@ -184,10 +195,10 @@ let DebugHoverWidget = class DebugHoverWidget {
             return undefined;
         }
         this.valueContainer.hidden = true;
-        await this.tree.setInput(expression);
+        this.expressionToRender = expression;
         this.complexValueTitle.textContent = expression.value;
         this.complexValueTitle.title = expression.value;
-        this.layoutTreeAndContainer(true);
+        this.editor.layoutContentWidget(this);
         this.tree.scrollTop = 0;
         this.tree.scrollLeft = 0;
         this.complexValueContainer.hidden = false;
@@ -196,14 +207,30 @@ let DebugHoverWidget = class DebugHoverWidget {
             this.tree.domFocus();
         }
     }
-    layoutTreeAndContainer(initialLayout) {
+    layoutTreeAndContainer() {
+        this.layoutTree();
+        this.editor.layoutContentWidget(this);
+    }
+    layoutTree() {
         const scrollBarHeight = 10;
         const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight);
+        const realTreeWidth = this.tree.contentWidth;
+        const treeWidth = clamp(realTreeWidth, 400, 550);
+        this.tree.layout(treeHeight, treeWidth);
         this.treeContainer.style.height = `${treeHeight}px`;
-        this.tree.layout(treeHeight, initialLayout ? 400 : undefined);
-        this.editor.layoutContentWidget(this);
         this.scrollbar.scanDomNode();
     }
+    beforeRender() {
+        if (this.expressionToRender) {
+            const expression = this.expressionToRender;
+            this.expressionToRender = undefined;
+            this.isUpdatingTree = true;
+            this.tree.setInput(expression).finally(() => {
+                this.isUpdatingTree = false;
+            });
+        }
+        return null;
+    }
     afterRender(positionPreference) {
         if (positionPreference) {
             this.positionPreference = [positionPreference];

package/dist/vscode/vs/workbench/contrib/debug/browser/debugSession.js

@@ -1118,7 +1118,7 @@ let DebugSession = class DebugSession {
     appendToRepl(data, isImportant) {
         this.repl.appendToRepl(this, data);
         if (isImportant) {
-            this.notificationService.notify({ message: ( data.toString()), severity: data.sev, source: this.name });
+            this.notificationService.notify({ message: ( data.output.toString()), severity: data.sev, source: this.name });
         }
     }
 };

package/dist/vscode/vs/workbench/contrib/debug/browser/debugTaskRunner.js

@@ -169,7 +169,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                 choice = result;
                 if (checkboxChecked) {
                     choiceMap[err.message] = choice;
-                    this.storageService.store(DEBUG_TASK_ERROR_CHOICE_KEY, JSON.stringify(choiceMap), 1 , 0 );
+                    this.storageService.store(DEBUG_TASK_ERROR_CHOICE_KEY, JSON.stringify(choiceMap), 1 , 1 );
                 }
             }
             if (choice === DebugChoice.ConfigureTask) {

package/dist/vscode/vs/workbench/contrib/debug/browser/repl.js

@@ -583,21 +583,21 @@ let Repl = class Repl extends FilterViewPane {
     saveState() {
         const replHistory = this.history.getHistory();
         if (replHistory.length) {
-            this.storageService.store(HISTORY_STORAGE_KEY, JSON.stringify(replHistory), 1 , 0 );
+            this.storageService.store(HISTORY_STORAGE_KEY, JSON.stringify(replHistory), 1 , 1 );
         }
         else {
             this.storageService.remove(HISTORY_STORAGE_KEY, 1 );
         }
         const filterHistory = this.filterWidget.getHistory();
         if (filterHistory.length) {
-            this.storageService.store(FILTER_HISTORY_STORAGE_KEY, JSON.stringify(filterHistory), 1 , 0 );
+            this.storageService.store(FILTER_HISTORY_STORAGE_KEY, JSON.stringify(filterHistory), 1 , 1 );
         }
         else {
             this.storageService.remove(FILTER_HISTORY_STORAGE_KEY, 1 );
         }
         const filterValue = this.filterWidget.getFilterText();
         if (filterValue) {
-            this.storageService.store(FILTER_VALUE_STORAGE_KEY, filterValue, 1 , 0 );
+            this.storageService.store(FILTER_VALUE_STORAGE_KEY, filterValue, 1 , 1 );
         }
         else {
             this.storageService.remove(FILTER_VALUE_STORAGE_KEY, 1 );

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { distinct, lastIndex } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { RunOnceScheduler, DeferredPromise } 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';
 import { stringHash } from 'monaco-editor/esm/vs/base/common/hash.js';
@@ -726,6 +726,7 @@ class BaseBreakpoint extends Enablement {
     }
     toJSON() {
         const result = Object.create(null);
+        result.id = this.getId();
         result.enabled = this.enabled;
         result.condition = this.condition;
         result.hitCondition = this.hitCondition;
@@ -1038,7 +1039,10 @@ let DebugModel = class DebugModel {
     }
     clearThreads(id, removeThreads, reference = undefined) {
         const session = this.sessions.find(p => p.getId() === id);
-        this.schedulers.forEach(scheduler => scheduler.dispose());
+        this.schedulers.forEach(entry => {
+            entry.scheduler.dispose();
+            entry.completeDeferred.complete();
+        });
         this.schedulers.clear();
         if (session) {
             session.clearThreads(removeThreads, reference);
@@ -1066,22 +1070,30 @@ let DebugModel = class DebugModel {
             const wholeCallStack = ( (new Promise((c, e) => {
                 topCallStack = thread.fetchCallStack(1).then(() => {
                     if (!( (this.schedulers.has(thread.getId())))) {
-                        this.schedulers.set(thread.getId(), ( (new RunOnceScheduler(() => {
-                            thread.fetchCallStack(19).then(() => {
-                                const stale = thread.getStaleCallStack();
-                                const current = thread.getCallStack();
-                                let bottomOfCallStackChanged = stale.length !== current.length;
-                                for (let i = 1; i < stale.length && !bottomOfCallStackChanged; i++) {
-                                    bottomOfCallStackChanged = !stale[i].equals(current[i]);
-                                }
-                                if (bottomOfCallStackChanged) {
-                                    this._onDidChangeCallStack.fire();
-                                }
-                                c();
-                            });
-                        }, 420))));
+                        const deferred = ( (new DeferredPromise()));
+                        this.schedulers.set(thread.getId(), {
+                            completeDeferred: deferred,
+                            scheduler: ( (new RunOnceScheduler(() => {
+                                thread.fetchCallStack(19).then(() => {
+                                    const stale = thread.getStaleCallStack();
+                                    const current = thread.getCallStack();
+                                    let bottomOfCallStackChanged = stale.length !== current.length;
+                                    for (let i = 1; i < stale.length && !bottomOfCallStackChanged; i++) {
+                                        bottomOfCallStackChanged = !stale[i].equals(current[i]);
+                                    }
+                                    if (bottomOfCallStackChanged) {
+                                        this._onDidChangeCallStack.fire();
+                                    }
+                                }).finally(() => {
+                                    deferred.complete();
+                                    this.schedulers.delete(thread.getId());
+                                });
+                            }, 420)))
+                        });
                     }
-                    this.schedulers.get(thread.getId()).schedule();
+                    const entry = this.schedulers.get(thread.getId());
+                    entry.scheduler.schedule();
+                    entry.completeDeferred.p.then(c, e);
                     this._onDidChangeCallStack.fire();
                 });
             })));

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

@@ -23,13 +23,13 @@ let DebugStorage = class DebugStorage {
         return this.storageService.get(DEBUG_UX_STATE_KEY, 1 , 'default');
     }
     storeDebugUxState(value) {
-        this.storageService.store(DEBUG_UX_STATE_KEY, value, 1 , 0 );
+        this.storageService.store(DEBUG_UX_STATE_KEY, value, 1 , 1 );
     }
     loadBreakpoints() {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, 1 , '[]')).map((breakpoint) => {
-                return ( new Breakpoint(( URI.parse(breakpoint.uri.external || breakpoint.source.uri.external)), breakpoint.lineNumber, breakpoint.column, breakpoint.enabled, breakpoint.condition, breakpoint.hitCondition, breakpoint.logMessage, breakpoint.adapterData, this.textFileService, this.uriIdentityService, this.logService));
+                return ( new Breakpoint(( URI.parse(breakpoint.uri.external || breakpoint.source.uri.external)), breakpoint.lineNumber, breakpoint.column, breakpoint.enabled, breakpoint.condition, breakpoint.hitCondition, breakpoint.logMessage, breakpoint.adapterData, this.textFileService, this.uriIdentityService, this.logService, breakpoint.id));
             }));
         }
         catch (e) { }
@@ -39,7 +39,7 @@ let DebugStorage = class DebugStorage {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 , '[]')).map((fb) => {
-                return ( new FunctionBreakpoint(fb.name, fb.enabled, fb.hitCondition, fb.condition, fb.logMessage));
+                return ( new FunctionBreakpoint(fb.name, fb.enabled, fb.hitCondition, fb.condition, fb.logMessage, fb.id));
             }));
         }
         catch (e) { }
@@ -77,7 +77,8 @@ let DebugStorage = class DebugStorage {
                     dbp.condition,
                     dbp.logMessage,
                     dbp.accessTypes,
-                    dbp.accessType
+                    dbp.accessType,
+                    dbp.id
                 ));
             }));
         }
@@ -98,11 +99,11 @@ let DebugStorage = class DebugStorage {
         return JSON.parse(this.storageService.get(DEBUG_CHOSEN_ENVIRONMENTS_KEY, 1 , '{}'));
     }
     storeChosenEnvironments(environments) {
-        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), 1 , 0 );
+        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), 1 , 1 );
     }
     storeWatchExpressions(watchExpressions) {
         if (watchExpressions.length) {
-            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), 1 , 0 );
+            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, 1 );
@@ -111,28 +112,28 @@ let DebugStorage = class DebugStorage {
     storeBreakpoints(debugModel) {
         const breakpoints = debugModel.getBreakpoints();
         if (breakpoints.length) {
-            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), 1 , 0 );
+            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_BREAKPOINTS_KEY, 1 );
         }
         const functionBreakpoints = debugModel.getFunctionBreakpoints();
         if (functionBreakpoints.length) {
-            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), 1 , 0 );
+            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 );
         }
         const dataBreakpoints = debugModel.getDataBreakpoints().filter(dbp => dbp.canPersist);
         if (dataBreakpoints.length) {
-            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), 1 , 0 );
+            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_DATA_BREAKPOINTS_KEY, 1 );
         }
         const exceptionBreakpoints = debugModel.getExceptionBreakpoints();
         if (exceptionBreakpoints.length) {
-            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), 1 , 0 );
+            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 );

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

@@ -12,6 +12,7 @@ import { isDebuggerMainContribution } from './debugUtils.js';
 import { cleanRemoteAuthority } from '../../../../platform/telemetry/common/telemetryUtils.js';
 import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
 import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { filter } from 'monaco-editor/esm/vs/base/common/objects.js';
 let Debugger = class Debugger {
     constructor(adapterManager, dbgContribution, extensionDescription, configurationService, resourcePropertiesService, configurationResolverService, environmentService, debugService, contextKeyService) {
         this.adapterManager = adapterManager;
@@ -171,6 +172,7 @@ let Debugger = class Debugger {
         }
         return ( ( Object.keys(this.debuggerContribution.configurationAttributes)).map(request => {
             const definitionId = `${this.type}:${request}`;
+            const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
             const attributes = this.debuggerContribution.configurationAttributes[request];
             const defaultRequired = ['name', 'type', 'request'];
             attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
@@ -212,30 +214,32 @@ let Debugger = class Debugger {
                 applyDeprecatedVariableMessage(properties[name]);
             });
             definitions[definitionId] = { ...attributes };
+            definitions[platformSpecificDefinitionId] = {
+                type: 'object',
+                additionalProperties: false,
+                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+            };
             const attributesCopy = { ...attributes };
             attributesCopy.properties = {
                 ...properties,
                 ...{
                     windows: {
-                        $ref: `#/definitions/${definitionId}`,
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
                         description: ( nls.localize(
                             'debugWindowsConfiguration',
                             "Windows specific launch configuration attributes."
                         )),
-                        required: [],
                     },
                     osx: {
-                        $ref: `#/definitions/${definitionId}`,
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
                         description: ( nls.localize('debugOSXConfiguration', "OS X specific launch configuration attributes.")),
-                        required: [],
                     },
                     linux: {
-                        $ref: `#/definitions/${definitionId}`,
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
                         description: ( nls.localize(
                             'debugLinuxConfiguration',
                             "Linux specific launch configuration attributes."
                         )),
-                        required: [],
                     }
                 }
             };