@codingame/monaco-vscode-debug-service-override 4.0.0 → 4.1.0

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

@@ -1,432 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
-import { equalsIgnoreCase } from 'vscode/vscode/vs/base/common/strings';
-import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Extensions } from 'vscode/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-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(( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            '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: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugName',
-                            "Name of configuration; appears in the launch configuration dropdown menu."
-                        )),
-                        default: 'Launch'
-                    },
-                    'debugServer': {
-                        type: 'number',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            '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: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugPrelaunchTask',
-                            "Task to run before debug session starts."
-                        ))
-                    },
-                    'postDebugTask': {
-                        anyOf: [taskSchema, {
-                                type: ['string'],
-                            }],
-                        default: '',
-                        defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugPostDebugTask',
-                            "Task to run after debug session ends."
-                        ))
-                    },
-                    'presentation': presentationSchema,
-                    'internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
-                    'suppressMultipleSessionWarning': {
-                        type: 'boolean',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            '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 => 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.hasDynamicConfigurationProviders() || dbg.hasConfigurationProvider());
-        }
-        if (candidates.length === 0 && languageLabel) {
-            if (languageLabel.indexOf(' ') >= 0) {
-                languageLabel = `'${languageLabel}'`;
-            }
-            const { confirmed } = await this.dialogService.confirm({
-                type: Severity$1.Warning,
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                    'CouldNotFindLanguage',
-                    "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
-                    languageLabel
-                )),
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                    { 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));
-        candidates = candidates.filter(a => !a.isHiddenFromDropdown);
-        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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                '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 ? ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            'installLanguage',
-            "Install an extension for {0}...",
-            languageLabel
-        )) : ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            'installExt',
-            "Install extension..."
-        )) });
-        const placeHolder = ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            '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 };