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

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

@@ -0,0 +1,117 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { CONTEXT_EXPRESSION_SELECTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { isSessionAttach } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+
+class ViewModel {
+    constructor(contextKeyService) {
+        this.contextKeyService = contextKeyService;
+        this.firstSessionStart = true;
+        this._onDidFocusSession = ( new Emitter());
+        this._onDidFocusThread = ( new Emitter());
+        this._onDidFocusStackFrame = ( new Emitter());
+        this._onDidSelectExpression = ( new Emitter());
+        this._onDidEvaluateLazyExpression = ( new Emitter());
+        this._onWillUpdateViews = ( new Emitter());
+        contextKeyService.bufferChangeEvents(() => {
+            this.expressionSelectedContextKey = CONTEXT_EXPRESSION_SELECTED.bindTo(contextKeyService);
+            this.loadedScriptsSupportedContextKey = CONTEXT_LOADED_SCRIPTS_SUPPORTED.bindTo(contextKeyService);
+            this.stepBackSupportedContextKey = CONTEXT_STEP_BACK_SUPPORTED.bindTo(contextKeyService);
+            this.focusedSessionIsAttach = CONTEXT_FOCUSED_SESSION_IS_ATTACH.bindTo(contextKeyService);
+            this.restartFrameSupportedContextKey = CONTEXT_RESTART_FRAME_SUPPORTED.bindTo(contextKeyService);
+            this.stepIntoTargetsSupported = CONTEXT_STEP_INTO_TARGETS_SUPPORTED.bindTo(contextKeyService);
+            this.jumpToCursorSupported = CONTEXT_JUMP_TO_CURSOR_SUPPORTED.bindTo(contextKeyService);
+            this.setVariableSupported = CONTEXT_SET_VARIABLE_SUPPORTED.bindTo(contextKeyService);
+            this.setExpressionSupported = CONTEXT_SET_EXPRESSION_SUPPORTED.bindTo(contextKeyService);
+            this.multiSessionDebug = CONTEXT_MULTI_SESSION_DEBUG.bindTo(contextKeyService);
+            this.terminateDebuggeeSupported = CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
+            this.suspendDebuggeeSupported = CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
+            this.disassembleRequestSupported = CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED.bindTo(contextKeyService);
+            this.focusedStackFrameHasInstructionPointerReference = CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE.bindTo(contextKeyService);
+        });
+    }
+    getId() {
+        return 'root';
+    }
+    get focusedSession() {
+        return this._focusedSession;
+    }
+    get focusedThread() {
+        return this._focusedThread;
+    }
+    get focusedStackFrame() {
+        return this._focusedStackFrame;
+    }
+    setFocus(stackFrame, thread, session, explicit) {
+        const shouldEmitForStackFrame = this._focusedStackFrame !== stackFrame;
+        const shouldEmitForSession = this._focusedSession !== session;
+        const shouldEmitForThread = this._focusedThread !== thread;
+        this._focusedStackFrame = stackFrame;
+        this._focusedThread = thread;
+        this._focusedSession = session;
+        this.contextKeyService.bufferChangeEvents(() => {
+            this.loadedScriptsSupportedContextKey.set(session ? !!session.capabilities.supportsLoadedSourcesRequest : false);
+            this.stepBackSupportedContextKey.set(session ? !!session.capabilities.supportsStepBack : false);
+            this.restartFrameSupportedContextKey.set(session ? !!session.capabilities.supportsRestartFrame : false);
+            this.stepIntoTargetsSupported.set(session ? !!session.capabilities.supportsStepInTargetsRequest : false);
+            this.jumpToCursorSupported.set(session ? !!session.capabilities.supportsGotoTargetsRequest : false);
+            this.setVariableSupported.set(session ? !!session.capabilities.supportsSetVariable : false);
+            this.setExpressionSupported.set(session ? !!session.capabilities.supportsSetExpression : false);
+            this.terminateDebuggeeSupported.set(session ? !!session.capabilities.supportTerminateDebuggee : false);
+            this.suspendDebuggeeSupported.set(session ? !!session.capabilities.supportSuspendDebuggee : false);
+            this.disassembleRequestSupported.set(!!session?.capabilities.supportsDisassembleRequest);
+            this.focusedStackFrameHasInstructionPointerReference.set(!!stackFrame?.instructionPointerReference);
+            const attach = !!session && isSessionAttach(session);
+            this.focusedSessionIsAttach.set(attach);
+        });
+        if (shouldEmitForSession) {
+            this._onDidFocusSession.fire(session);
+        }
+        if (shouldEmitForStackFrame) {
+            this._onDidFocusStackFrame.fire({ stackFrame, explicit, session });
+        }
+        else if (shouldEmitForThread) {
+            this._onDidFocusThread.fire({ thread, explicit, session });
+        }
+    }
+    get onDidFocusSession() {
+        return this._onDidFocusSession.event;
+    }
+    get onDidFocusThread() {
+        return this._onDidFocusThread.event;
+    }
+    get onDidFocusStackFrame() {
+        return this._onDidFocusStackFrame.event;
+    }
+    getSelectedExpression() {
+        return this.selectedExpression;
+    }
+    setSelectedExpression(expression, settingWatch) {
+        this.selectedExpression = expression ? { expression, settingWatch: settingWatch } : undefined;
+        this.expressionSelectedContextKey.set(!!expression);
+        this._onDidSelectExpression.fire(this.selectedExpression);
+    }
+    get onDidSelectExpression() {
+        return this._onDidSelectExpression.event;
+    }
+    get onDidEvaluateLazyExpression() {
+        return this._onDidEvaluateLazyExpression.event;
+    }
+    updateViews() {
+        this._onWillUpdateViews.fire();
+    }
+    get onWillUpdateViews() {
+        return this._onWillUpdateViews.event;
+    }
+    isMultiSessionView() {
+        return !!this.multiSessionDebug.get();
+    }
+    setMultiSessionView(isMultiSessionView) {
+        this.multiSessionDebug.set(isMultiSessionView);
+    }
+    async evaluateLazyExpression(expression) {
+        await expression.evaluateLazy();
+        this._onDidEvaluateLazyExpression.fire(expression);
+    }
+}
+
+export { ViewModel };

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

@@ -0,0 +1,260 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { debuggerDisabledMessage, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver';
+import { applyDeprecatedVariableMessage } from '../../../services/configurationResolver/common/configurationResolverUtils.js';
+import { ITextResourcePropertiesService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isDebuggerMainContribution } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+import { cleanRemoteAuthority } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+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;
+        this.configurationService = configurationService;
+        this.resourcePropertiesService = resourcePropertiesService;
+        this.configurationResolverService = configurationResolverService;
+        this.environmentService = environmentService;
+        this.debugService = debugService;
+        this.contextKeyService = contextKeyService;
+        this.mergedExtensionDescriptions = [];
+        this.debuggerContribution = { type: dbgContribution.type };
+        this.merge(dbgContribution, extensionDescription);
+        this.debuggerWhen = typeof this.debuggerContribution.when === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
+    }
+    merge(otherDebuggerContribution, extensionDescription) {
+        function mixin(destination, source, overwrite, level = 0) {
+            if (!isObject(destination)) {
+                return source;
+            }
+            if (isObject(source)) {
+                ( Object.keys(source)).forEach(key => {
+                    if (key !== '__proto__') {
+                        if (isObject(destination[key]) && isObject(source[key])) {
+                            mixin(destination[key], source[key], overwrite, level + 1);
+                        }
+                        else {
+                            if (key in destination) {
+                                if (overwrite) {
+                                    if (level === 0 && key === 'type') ;
+                                    else {
+                                        destination[key] = source[key];
+                                    }
+                                }
+                            }
+                            else {
+                                destination[key] = source[key];
+                            }
+                        }
+                    }
+                });
+            }
+            return destination;
+        }
+        if (this.mergedExtensionDescriptions.indexOf(extensionDescription) < 0) {
+            this.mergedExtensionDescriptions.push(extensionDescription);
+            mixin(this.debuggerContribution, otherDebuggerContribution, extensionDescription.isBuiltin);
+            if (isDebuggerMainContribution(otherDebuggerContribution)) {
+                this.mainExtensionDescription = extensionDescription;
+            }
+        }
+    }
+    async startDebugging(configuration, parentSessionId) {
+        const parentSession = this.debugService.getModel().getSession(parentSessionId);
+        return await this.debugService.startDebugging(undefined, configuration, { parentSession }, undefined);
+    }
+    async createDebugAdapter(session) {
+        await this.adapterManager.activateDebuggers('onDebugAdapterProtocolTracker', this.type);
+        const da = this.adapterManager.createDebugAdapter(session);
+        if (da) {
+            return Promise.resolve(da);
+        }
+        throw new Error(nls.localize('cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
+    }
+    async substituteVariables(folder, config) {
+        const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
+        return await this.configurationResolverService.resolveWithInteractionReplace(folder, substitutedConfig, 'launch', this.variables, substitutedConfig.__configurationTarget);
+    }
+    runInTerminal(args, sessionId) {
+        return this.adapterManager.runInTerminal(this.type, args, sessionId);
+    }
+    get label() {
+        return this.debuggerContribution.label || this.debuggerContribution.type;
+    }
+    get type() {
+        return this.debuggerContribution.type;
+    }
+    get variables() {
+        return this.debuggerContribution.variables;
+    }
+    get configurationSnippets() {
+        return this.debuggerContribution.configurationSnippets;
+    }
+    get languages() {
+        return this.debuggerContribution.languages;
+    }
+    get when() {
+        return this.debuggerWhen;
+    }
+    get enabled() {
+        return !this.debuggerWhen || this.contextKeyService.contextMatchesRules(this.debuggerWhen);
+    }
+    get strings() {
+        return this.debuggerContribution.strings ?? this.debuggerContribution.uiMessages;
+    }
+    interestedInLanguage(languageId) {
+        return !!(this.languages && this.languages.indexOf(languageId) >= 0);
+    }
+    hasInitialConfiguration() {
+        return !!this.debuggerContribution.initialConfigurations;
+    }
+    hasConfigurationProvider() {
+        return this.debugService.getConfigurationManager().hasDebugConfigurationProvider(this.type);
+    }
+    getInitialConfigurationContent(initialConfigs) {
+        let initialConfigurations = this.debuggerContribution.initialConfigurations || [];
+        if (initialConfigs) {
+            initialConfigurations = initialConfigurations.concat(initialConfigs);
+        }
+        const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
+        const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
+        const comment1 = ( nls.localize(
+            'launch.config.comment1',
+            "Use IntelliSense to learn about possible attributes."
+        ));
+        const comment2 = ( nls.localize(
+            'launch.config.comment2',
+            "Hover to view descriptions of existing attributes."
+        ));
+        const comment3 = ( nls.localize(
+            'launch.config.comment3',
+            "For more information, visit: {0}",
+            'https://go.microsoft.com/fwlink/?linkid=830387'
+        ));
+        let content = [
+            '{',
+            `\t// ${comment1}`,
+            `\t// ${comment2}`,
+            `\t// ${comment3}`,
+            `\t"version": "0.2.0",`,
+            `\t"configurations": ${configs}`,
+            '}'
+        ].join(eol);
+        const editorConfig = this.configurationService.getValue();
+        if (editorConfig.editor && editorConfig.editor.insertSpaces) {
+            content = content.replace(( new RegExp('\t', 'g')), ' '.repeat(editorConfig.editor.tabSize));
+        }
+        return Promise.resolve(content);
+    }
+    getMainExtensionDescriptor() {
+        return this.mainExtensionDescription || this.mergedExtensionDescriptions[0];
+    }
+    getCustomTelemetryEndpoint() {
+        const aiKey = this.debuggerContribution.aiKey;
+        if (!aiKey) {
+            return undefined;
+        }
+        const sendErrorTelemtry = cleanRemoteAuthority(this.environmentService.remoteAuthority) !== 'other';
+        return {
+            id: `${this.getMainExtensionDescriptor().publisher}.${this.type}`,
+            aiKey,
+            sendErrorTelemetry: sendErrorTelemtry
+        };
+    }
+    getSchemaAttributes(definitions) {
+        if (!this.debuggerContribution.configurationAttributes) {
+            return null;
+        }
+        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;
+            attributes.additionalProperties = false;
+            attributes.type = 'object';
+            if (!attributes.properties) {
+                attributes.properties = {};
+            }
+            const properties = attributes.properties;
+            properties['type'] = {
+                enum: [this.type],
+                enumDescriptions: [this.label],
+                description: ( nls.localize('debugType', "Type of configuration.")),
+                pattern: '^(?!node2)',
+                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
+                doNotSuggest: !!this.debuggerContribution.deprecated,
+                errorMessage: ( nls.localize(
+                    'debugTypeNotRecognised',
+                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
+                )),
+                patternErrorMessage: ( nls.localize(
+                    'node2NotSupported',
+                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
+                ))
+            };
+            properties['request'] = {
+                enum: [request],
+                description: ( nls.localize(
+                    'debugRequest',
+                    "Request type of configuration. Can be \"launch\" or \"attach\"."
+                )),
+            };
+            for (const prop in definitions['common'].properties) {
+                properties[prop] = {
+                    $ref: `#/definitions/common/properties/${prop}`
+                };
+            }
+            ( Object.keys(properties)).forEach(name => {
+                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/${platformSpecificDefinitionId}`,
+                        description: ( nls.localize(
+                            'debugWindowsConfiguration',
+                            "Windows specific launch configuration attributes."
+                        )),
+                    },
+                    osx: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( nls.localize('debugOSXConfiguration', "OS X specific launch configuration attributes.")),
+                    },
+                    linux: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( nls.localize(
+                            'debugLinuxConfiguration',
+                            "Linux specific launch configuration attributes."
+                        )),
+                    }
+                }
+            };
+            return attributesCopy;
+        }));
+    }
+};
+Debugger = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ITextResourcePropertiesService)),
+    ( __param(5, IConfigurationResolverService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, IDebugService)),
+    ( __param(8, IContextKeyService))
+], Debugger));
+
+export { Debugger };

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

@@ -0,0 +1,27 @@
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+
+class DisassemblyViewInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = undefined;
+    }
+    static { this.ID = 'debug.disassemblyView.input'; }
+    get typeId() {
+        return DisassemblyViewInput.ID;
+    }
+    static get instance() {
+        if (!DisassemblyViewInput._instance || DisassemblyViewInput._instance.isDisposed()) {
+            DisassemblyViewInput._instance = ( new DisassemblyViewInput());
+        }
+        return DisassemblyViewInput._instance;
+    }
+    getName() {
+        return ( localize('disassemblyInputName', "Disassembly"));
+    }
+    matches(other) {
+        return other instanceof DisassemblyViewInput;
+    }
+}
+
+export { DisassemblyViewInput };

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

@@ -0,0 +1,83 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+
+async function showLoadedScriptMenu(accessor) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const debugService = accessor.get(IDebugService);
+    const editorService = accessor.get(IEditorService);
+    const sessions = debugService.getModel().getSessions(false);
+    const modelService = accessor.get(IModelService);
+    const languageService = accessor.get(ILanguageService);
+    const labelService = accessor.get(ILabelService);
+    const localDisposableStore = ( new DisposableStore());
+    const quickPick = quickInputService.createQuickPick();
+    localDisposableStore.add(quickPick);
+    quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
+    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', "Search loaded scripts by name"));
+    quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
+    localDisposableStore.add(quickPick.onDidChangeValue(async () => {
+        quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
+    }));
+    localDisposableStore.add(quickPick.onDidAccept(() => {
+        const selectedItem = quickPick.selectedItems[0];
+        selectedItem.accept();
+        quickPick.hide();
+        localDisposableStore.dispose();
+    }));
+    quickPick.show();
+}
+async function _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService) {
+    const items = [];
+    items.push({ type: 'separator', label: session.name });
+    const sources = await session.getLoadedSources();
+    sources.forEach((element) => {
+        const pick = _createPick(element, filter, editorService, modelService, languageService, labelService);
+        if (pick) {
+            items.push(pick);
+        }
+    });
+    return items;
+}
+async function _getPicks(filter, sessions, editorService, modelService, languageService, labelService) {
+    const loadedScriptPicks = [];
+    const picks = await Promise.all(( sessions.map(
+        (session) => _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService)
+    )));
+    for (const row of picks) {
+        for (const elem of row) {
+            loadedScriptPicks.push(elem);
+        }
+    }
+    return loadedScriptPicks;
+}
+function _createPick(source, filter, editorService, modelService, languageService, labelService) {
+    const label = labelService.getUriBasenameLabel(source.uri);
+    const desc = labelService.getUriLabel(dirname(source.uri));
+    const labelHighlights = matchesFuzzy(filter, label, true);
+    const descHighlights = matchesFuzzy(filter, desc, true);
+    if (labelHighlights || descHighlights) {
+        return {
+            label,
+            description: desc === '.' ? undefined : desc,
+            highlights: { label: labelHighlights ?? undefined, description: descHighlights ?? undefined },
+            iconClasses: getIconClasses(modelService, languageService, source.uri),
+            accept: () => {
+                if (source.available) {
+                    source.openInEditor(editorService, { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 });
+                }
+            }
+        };
+    }
+    return undefined;
+}
+
+export { showLoadedScriptMenu };