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

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

@@ -0,0 +1,400 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Breakpoints } from '../common/breakpoints.js';
+import { CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_EXTENSION_AVAILABLE, INTERNAL_CONSOLE_OPTIONS_SCHEMA } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Debugger } from '../common/debugger.js';
+import { debuggersExtPoint, breakpointsExtPoint, launchSchema, presentationSchema } from '../common/debugSchemas.js';
+import { TaskDefinitionRegistry } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskDefinitionRegistry';
+import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+let AdapterManager = class AdapterManager extends Disposable {
+    constructor(delegate, editorService, configurationService, quickInputService, instantiationService, commandService, extensionService, contextKeyService, languageService, dialogService, lifecycleService) {
+        super();
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.quickInputService = quickInputService;
+        this.instantiationService = instantiationService;
+        this.commandService = commandService;
+        this.extensionService = extensionService;
+        this.contextKeyService = contextKeyService;
+        this.languageService = languageService;
+        this.dialogService = dialogService;
+        this.lifecycleService = lifecycleService;
+        this.debugAdapterFactories = ( new Map());
+        this._onDidRegisterDebugger = ( new Emitter());
+        this._onDidDebuggersExtPointRead = ( new Emitter());
+        this.breakpointContributions = [];
+        this.debuggerWhenKeys = ( new Set());
+        this.usedDebugTypes = ( new Set());
+        this.adapterDescriptorFactories = [];
+        this.debuggers = [];
+        this.registerListeners();
+        this.contextKeyService.bufferChangeEvents(() => {
+            this.debuggersAvailable = CONTEXT_DEBUGGERS_AVAILABLE.bindTo(contextKeyService);
+            this.debugExtensionsAvailable = CONTEXT_DEBUG_EXTENSION_AVAILABLE.bindTo(contextKeyService);
+        });
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this.debuggerWhenKeys)) {
+                this.debuggersAvailable.set(this.hasEnabledDebuggers());
+                this.updateDebugAdapterSchema();
+            }
+        }));
+        this._register(this.onDidDebuggersExtPointRead(() => {
+            this.debugExtensionsAvailable.set(this.debuggers.length > 0);
+        }));
+        this.lifecycleService.when(4 )
+            .then(() => this.debugExtensionsAvailable.set(this.debuggers.length > 0));
+        this._register(delegate.onDidNewSession(s => {
+            this.usedDebugTypes.add(s.configuration.type);
+        }));
+    }
+    registerListeners() {
+        debuggersExtPoint.setHandler((extensions, delta) => {
+            delta.added.forEach(added => {
+                added.value.forEach(rawAdapter => {
+                    if (!rawAdapter.type || (typeof rawAdapter.type !== 'string')) {
+                        added.collector.error(( nls.localize(
+                            'debugNoType',
+                            "Debugger 'type' can not be omitted and must be of type 'string'."
+                        )));
+                    }
+                    if (rawAdapter.type !== '*') {
+                        const existing = this.getDebugger(rawAdapter.type);
+                        if (existing) {
+                            existing.merge(rawAdapter, added.description);
+                        }
+                        else {
+                            const dbg = this.instantiationService.createInstance(Debugger, this, rawAdapter, added.description);
+                            dbg.when?.keys().forEach(key => this.debuggerWhenKeys.add(key));
+                            this.debuggers.push(dbg);
+                        }
+                    }
+                });
+            });
+            extensions.forEach(extension => {
+                extension.value.forEach(rawAdapter => {
+                    if (rawAdapter.type === '*') {
+                        this.debuggers.forEach(dbg => dbg.merge(rawAdapter, extension.description));
+                    }
+                });
+            });
+            delta.removed.forEach(removed => {
+                const removedTypes = ( removed.value.map(rawAdapter => rawAdapter.type));
+                this.debuggers = this.debuggers.filter(d => removedTypes.indexOf(d.type) === -1);
+            });
+            this.updateDebugAdapterSchema();
+            this._onDidDebuggersExtPointRead.fire();
+        });
+        breakpointsExtPoint.setHandler(extensions => {
+            this.breakpointContributions = extensions.flatMap(ext => ( ext.value.map(
+                breakpoint => this.instantiationService.createInstance(Breakpoints, breakpoint)
+            )));
+        });
+    }
+    updateDebugAdapterSchema() {
+        const items = launchSchema.properties['configurations'].items;
+        const taskSchema = TaskDefinitionRegistry.getJsonSchema();
+        const definitions = {
+            'common': {
+                properties: {
+                    'name': {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'debugName',
+                            "Name of configuration; appears in the launch configuration dropdown menu."
+                        )),
+                        default: 'Launch'
+                    },
+                    'debugServer': {
+                        type: 'number',
+                        description: ( nls.localize(
+                            'debugServer',
+                            "For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode"
+                        )),
+                        default: 4711
+                    },
+                    'preLaunchTask': {
+                        anyOf: [taskSchema, {
+                                type: ['string']
+                            }],
+                        default: '',
+                        defaultSnippets: [{ body: { task: '', type: '' } }],
+                        description: ( nls.localize('debugPrelaunchTask', "Task to run before debug session starts."))
+                    },
+                    'postDebugTask': {
+                        anyOf: [taskSchema, {
+                                type: ['string'],
+                            }],
+                        default: '',
+                        defaultSnippets: [{ body: { task: '', type: '' } }],
+                        description: ( nls.localize('debugPostDebugTask', "Task to run after debug session ends."))
+                    },
+                    'presentation': presentationSchema,
+                    'internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
+                    'suppressMultipleSessionWarning': {
+                        type: 'boolean',
+                        description: ( nls.localize(
+                            'suppressMultipleSessionWarning',
+                            "Disable the warning when trying to start the same debug configuration more than once."
+                        )),
+                        default: true
+                    }
+                }
+            }
+        };
+        launchSchema.definitions = definitions;
+        items.oneOf = [];
+        items.defaultSnippets = [];
+        this.debuggers.forEach(adapter => {
+            const schemaAttributes = adapter.getSchemaAttributes(definitions);
+            if (schemaAttributes && items.oneOf) {
+                items.oneOf.push(...schemaAttributes);
+            }
+            const configurationSnippets = adapter.configurationSnippets;
+            if (configurationSnippets && items.defaultSnippets) {
+                items.defaultSnippets.push(...configurationSnippets);
+            }
+        });
+        jsonRegistry.registerSchema(launchSchemaId, launchSchema);
+    }
+    registerDebugAdapterFactory(debugTypes, debugAdapterLauncher) {
+        debugTypes.forEach(debugType => this.debugAdapterFactories.set(debugType, debugAdapterLauncher));
+        this.debuggersAvailable.set(this.hasEnabledDebuggers());
+        this._onDidRegisterDebugger.fire();
+        return {
+            dispose: () => {
+                debugTypes.forEach(debugType => this.debugAdapterFactories.delete(debugType));
+            }
+        };
+    }
+    hasEnabledDebuggers() {
+        for (const [type] of this.debugAdapterFactories) {
+            const dbg = this.getDebugger(type);
+            if (dbg && dbg.enabled) {
+                return true;
+            }
+        }
+        return false;
+    }
+    createDebugAdapter(session) {
+        const factory = this.debugAdapterFactories.get(session.configuration.type);
+        if (factory) {
+            return factory.createDebugAdapter(session);
+        }
+        return undefined;
+    }
+    substituteVariables(debugType, folder, config) {
+        const factory = this.debugAdapterFactories.get(debugType);
+        if (factory) {
+            return factory.substituteVariables(folder, config);
+        }
+        return Promise.resolve(config);
+    }
+    runInTerminal(debugType, args, sessionId) {
+        const factory = this.debugAdapterFactories.get(debugType);
+        if (factory) {
+            return factory.runInTerminal(args, sessionId);
+        }
+        return Promise.resolve(void 0);
+    }
+    registerDebugAdapterDescriptorFactory(debugAdapterProvider) {
+        this.adapterDescriptorFactories.push(debugAdapterProvider);
+        return {
+            dispose: () => {
+                this.unregisterDebugAdapterDescriptorFactory(debugAdapterProvider);
+            }
+        };
+    }
+    unregisterDebugAdapterDescriptorFactory(debugAdapterProvider) {
+        const ix = this.adapterDescriptorFactories.indexOf(debugAdapterProvider);
+        if (ix >= 0) {
+            this.adapterDescriptorFactories.splice(ix, 1);
+        }
+    }
+    getDebugAdapterDescriptor(session) {
+        const config = session.configuration;
+        const providers = this.adapterDescriptorFactories.filter(p => p.type === config.type && p.createDebugAdapterDescriptor);
+        if (providers.length === 1) {
+            return providers[0].createDebugAdapterDescriptor(session);
+        }
+        return Promise.resolve(undefined);
+    }
+    getDebuggerLabel(type) {
+        const dbgr = this.getDebugger(type);
+        if (dbgr) {
+            return dbgr.label;
+        }
+        return undefined;
+    }
+    get onDidRegisterDebugger() {
+        return this._onDidRegisterDebugger.event;
+    }
+    get onDidDebuggersExtPointRead() {
+        return this._onDidDebuggersExtPointRead.event;
+    }
+    canSetBreakpointsIn(model) {
+        const languageId = model.getLanguageId();
+        if (!languageId || languageId === 'jsonc' || languageId === 'log') {
+            return false;
+        }
+        if (this.configurationService.getValue('debug').allowBreakpointsEverywhere) {
+            return true;
+        }
+        return ( this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled));
+    }
+    getDebugger(type) {
+        return this.debuggers.find(dbg => strings.equalsIgnoreCase(dbg.type, type));
+    }
+    getEnabledDebugger(type) {
+        const adapter = this.getDebugger(type);
+        return adapter && adapter.enabled ? adapter : undefined;
+    }
+    someDebuggerInterestedInLanguage(languageId) {
+        return !!this.debuggers
+            .filter(d => d.enabled)
+            .find(a => a.interestedInLanguage(languageId));
+    }
+    async guessDebugger(gettingConfigurations) {
+        const activeTextEditorControl = this.editorService.activeTextEditorControl;
+        let candidates = [];
+        let languageLabel = null;
+        let model = null;
+        if (isCodeEditor(activeTextEditorControl)) {
+            model = activeTextEditorControl.getModel();
+            const language = model ? model.getLanguageId() : undefined;
+            if (language) {
+                languageLabel = this.languageService.getLanguageName(language);
+            }
+            const adapters = this.debuggers
+                .filter(a => a.enabled)
+                .filter(a => language && a.interestedInLanguage(language));
+            if (adapters.length === 1) {
+                return adapters[0];
+            }
+            if (adapters.length > 1) {
+                candidates = adapters;
+            }
+        }
+        if ((!languageLabel || gettingConfigurations || (model && this.canSetBreakpointsIn(model))) && candidates.length === 0) {
+            await this.activateDebuggers('onDebugInitialConfigurations');
+            candidates = this.debuggers
+                .filter(a => a.enabled)
+                .filter(dbg => dbg.hasInitialConfiguration() || dbg.hasConfigurationProvider());
+        }
+        if (candidates.length === 0 && languageLabel) {
+            if (languageLabel.indexOf(' ') >= 0) {
+                languageLabel = `'${languageLabel}'`;
+            }
+            const { confirmed } = await this.dialogService.confirm({
+                type: Severity.Warning,
+                message: ( nls.localize(
+                    'CouldNotFindLanguage',
+                    "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
+                    languageLabel
+                )),
+                primaryButton: ( nls.localize(
+                    { key: 'findExtension', comment: ['&& denotes a mnemonic'] },
+                    "&&Find {0} extension",
+                    languageLabel
+                ))
+            });
+            if (confirmed) {
+                await this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
+            }
+            return undefined;
+        }
+        this.initExtensionActivationsIfNeeded();
+        candidates.sort((first, second) => first.label.localeCompare(second.label));
+        const suggestedCandidates = [];
+        const otherCandidates = [];
+        candidates.forEach(d => {
+            const descriptor = d.getMainExtensionDescriptor();
+            if (descriptor.id && !!this.earlyActivatedExtensions?.has(descriptor.id)) {
+                suggestedCandidates.push(d);
+            }
+            else if (( this.usedDebugTypes.has(d.type))) {
+                suggestedCandidates.push(d);
+            }
+            else {
+                otherCandidates.push(d);
+            }
+        });
+        const picks = [];
+        if (suggestedCandidates.length > 0) {
+            picks.push({ type: 'separator', label: ( nls.localize('suggestedDebuggers', "Suggested")) }, ...( suggestedCandidates.map(c => ({ label: c.label, debugger: c }))));
+        }
+        if (otherCandidates.length > 0) {
+            if (picks.length > 0) {
+                picks.push({ type: 'separator', label: '' });
+            }
+            picks.push(...( otherCandidates.map(c => ({ label: c.label, debugger: c }))));
+        }
+        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( nls.localize('installLanguage', "Install an extension for {0}...", languageLabel)) : ( nls.localize('installExt', "Install extension...")) });
+        const placeHolder = ( nls.localize('selectDebug', "Select debugger"));
+        return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder })
+            .then(picked => {
+            if (picked && picked.debugger) {
+                return picked.debugger;
+            }
+            if (picked) {
+                this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
+            }
+            return undefined;
+        });
+    }
+    initExtensionActivationsIfNeeded() {
+        if (!this.earlyActivatedExtensions) {
+            this.earlyActivatedExtensions = ( new Set());
+            const status = this.extensionService.getExtensionsStatus();
+            for (const id in status) {
+                if (!!status[id].activationTimes) {
+                    this.earlyActivatedExtensions.add(id);
+                }
+            }
+        }
+    }
+    async activateDebuggers(activationEvent, debugType) {
+        this.initExtensionActivationsIfNeeded();
+        const promises = [
+            this.extensionService.activateByEvent(activationEvent),
+            this.extensionService.activateByEvent('onDebug')
+        ];
+        if (debugType) {
+            promises.push(this.extensionService.activateByEvent(`${activationEvent}:${debugType}`));
+        }
+        await Promise.all(promises);
+    }
+};
+AdapterManager = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, IDialogService)),
+    ( __param(10, ILifecycleService))
+], AdapterManager));
+
+export { AdapterManager };