@theia/debug 1.27.0-next.7 → 1.27.0-next.8

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@theia/debug",
-  "version": "1.27.0-next.7+5f887e22825",
+  "version": "1.27.0-next.8+e1e200a7bfb",
   "description": "Theia - Debug Extension",
   "dependencies": {
-    "@theia/console": "1.27.0-next.7+5f887e22825",
-    "@theia/core": "1.27.0-next.7+5f887e22825",
-    "@theia/editor": "1.27.0-next.7+5f887e22825",
-    "@theia/filesystem": "1.27.0-next.7+5f887e22825",
-    "@theia/markers": "1.27.0-next.7+5f887e22825",
-    "@theia/monaco": "1.27.0-next.7+5f887e22825",
+    "@theia/console": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/core": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/editor": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/filesystem": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/markers": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/monaco": "1.27.0-next.8+e1e200a7bfb",
     "@theia/monaco-editor-core": "1.65.2",
-    "@theia/output": "1.27.0-next.7+5f887e22825",
-    "@theia/process": "1.27.0-next.7+5f887e22825",
-    "@theia/task": "1.27.0-next.7+5f887e22825",
-    "@theia/terminal": "1.27.0-next.7+5f887e22825",
-    "@theia/variable-resolver": "1.27.0-next.7+5f887e22825",
-    "@theia/workspace": "1.27.0-next.7+5f887e22825",
+    "@theia/output": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/process": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/task": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/terminal": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/variable-resolver": "1.27.0-next.8+e1e200a7bfb",
+    "@theia/workspace": "1.27.0-next.8+e1e200a7bfb",
     "jsonc-parser": "^2.2.0",
     "mkdirp": "^0.5.0",
     "p-debounce": "^2.1.0",
@@ -68,5 +68,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "5f887e22825c7284b16104b517678ca0a2824319"
+  "gitHead": "e1e200a7bfb9c7b9b87bf63dd8e101e734281222"
 }

package/src/browser/console/debug-console-contribution.tsx

@@ -189,7 +189,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         return <SelectComponent
             key="debugConsoleSeverity"
             options={severityElements}
-            value={this.consoleSessionManager.severity || Severity.Ignore}
+            defaultValue={this.consoleSessionManager.severity || Severity.Ignore}
             onChange={this.changeSeverity} />;
     }
 
@@ -207,7 +207,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         return <SelectComponent
             key="debugConsoleSelector"
             options={availableConsoles}
-            value={0}
+            defaultValue={0}
             onChange={this.changeDebugConsole} />;
     }
 

package/src/browser/debug-configuration-manager.ts

@@ -86,10 +86,16 @@ export class DebugConfigurationManager {
         return this.onWillProvideDynamicDebugConfigurationEmitter.event;
     }
 
+    get onDidChangeConfigurationProviders(): Event<void> {
+        return this.debug.onDidChangeDebugConfigurationProviders;
+    }
+
     protected debugConfigurationTypeKey: ContextKey<string>;
 
     protected initialized: Promise<void>;
 
+    protected recentDynamicOptionsTracker: DebugSessionOptions[] = [];
+
     @postConstruct()
     protected async init(): Promise<void> {
         this.debugConfigurationTypeKey = this.contextKeyService.createKey<string>('debugConfigurationType', undefined);
@@ -126,6 +132,9 @@ export class DebugConfigurationManager {
         this.updateCurrent();
     }, 500);
 
+    /**
+     * All _non-dynamic_ debug configurations.
+     */
     get all(): IterableIterator<DebugSessionOptions> {
         return this.getAll();
     }
@@ -160,11 +169,61 @@ export class DebugConfigurationManager {
     get current(): DebugSessionOptions | undefined {
         return this._currentOptions;
     }
+
+    async getSelectedConfiguration(): Promise<DebugSessionOptions | undefined> {
+        // providerType applies to dynamic configurations only
+        if (!this._currentOptions?.providerType) {
+            return this._currentOptions;
+        }
+
+        // Refresh a dynamic configuration from the provider.
+        // This allow providers to update properties before the execution e.g. program
+        const { providerType, configuration: { name } } = this._currentOptions;
+        const configuration = await this.fetchDynamicDebugConfiguration(name, providerType);
+
+        if (!configuration) {
+            const message = nls.localize(
+                'theia/debug/missingConfiguration',
+                "Dynamic configuration '{0}:{1}' is missing or not applicable", providerType, name);
+            throw new Error(message);
+        }
+
+        return { configuration, providerType };
+    }
+
     set current(option: DebugSessionOptions | undefined) {
         this.updateCurrent(option);
+        this.updateRecentlyUsedDynamicConfigurationOptions(option);
+    }
+
+    protected updateRecentlyUsedDynamicConfigurationOptions(option: DebugSessionOptions | undefined): void {
+        if (option?.providerType) { // if it's a dynamic configuration option
+            // Removing an item already present in the list
+            const index = this.recentDynamicOptionsTracker.findIndex(item => this.dynamicOptionsMatch(item, option));
+            if (index > -1) {
+                this.recentDynamicOptionsTracker.splice(index, 1);
+            }
+            // Adding new item, most recent at the top of the list
+            const recentMax = 3;
+            if (this.recentDynamicOptionsTracker.unshift(option) > recentMax) {
+                // Keep the latest 3 dynamic configuration options to not clutter the dropdown.
+                this.recentDynamicOptionsTracker.splice(recentMax);
+            }
+        }
     }
+
+    protected dynamicOptionsMatch(one: DebugSessionOptions, other: DebugSessionOptions): boolean {
+        return one.providerType !== undefined
+        && one.configuration.name === other.configuration.name
+        && one.providerType === other.providerType;
+    }
+
+    get recentDynamicOptions(): readonly DebugSessionOptions[] {
+        return this.recentDynamicOptionsTracker;
+    }
+
     protected updateCurrent(options: DebugSessionOptions | undefined = this._currentOptions): void {
-        this._currentOptions = options && !options.configuration.dynamic ? this.find(options.configuration.name, options.workspaceFolderUri) : options;
+        this._currentOptions = options && this.find(options.configuration, options.workspaceFolderUri, options.providerType);
 
         if (!this._currentOptions) {
             const model = this.getModel();
@@ -181,7 +240,24 @@ export class DebugConfigurationManager {
         this.debugConfigurationTypeKey.set(this.current && this.current.configuration.type);
         this.onDidChangeEmitter.fire(undefined);
     }
-    find(name: string, workspaceFolderUri: string | undefined): DebugSessionOptions | undefined {
+
+    /**
+     * @deprecated since v1.27.0
+     */
+    find(name: string, workspaceFolderUri: string): DebugSessionOptions | undefined;
+    /**
+     * Find / Resolve DebugSessionOptions from a given target debug configuration
+     */
+    find(targetConfiguration: DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined;
+    find(nameOrTargetConfiguration: string | DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined {
+        // providerType is only applicable to dynamic debug configurations
+        if (typeof nameOrTargetConfiguration === 'object' && providerType) {
+            return {
+                configuration: nameOrTargetConfiguration,
+                providerType
+            };
+        }
+        const name = typeof nameOrTargetConfiguration === 'string' ? nameOrTargetConfiguration : nameOrTargetConfiguration.name;
         for (const model of this.models.values()) {
             if (model.workspaceFolderUri === workspaceFolderUri) {
                 for (const configuration of model.configurations) {
@@ -194,7 +270,6 @@ export class DebugConfigurationManager {
                 }
             }
         }
-        return undefined;
     }
 
     async openConfiguration(): Promise<void> {
@@ -349,7 +424,13 @@ export class DebugConfigurationManager {
         return this.debug.provideDynamicDebugConfigurations!();
     }
 
+    async fetchDynamicDebugConfiguration(name: string, type: string): Promise<DebugConfiguration | undefined> {
+        await this.fireWillProvideDynamicDebugConfiguration();
+        return this.debug.fetchDynamicDebugConfiguration(name, type);
+    }
+
     protected async fireWillProvideDynamicDebugConfiguration(): Promise<void> {
+        await this.initialized;
         await WaitUntilEvent.fire(this.onWillProvideDynamicDebugConfigurationEmitter, {});
     }
 
@@ -384,29 +465,43 @@ export class DebugConfigurationManager {
     async load(): Promise<void> {
         await this.initialized;
         const data = await this.storage.getData<DebugConfigurationManager.Data>('debug.configurations', {});
-        if (data.current) {
-            this.current = this.find(data.current.name, data.current.workspaceFolderUri);
+        this.resolveRecentDynamicOptionsFromData(data.recentDynamicOptions);
+
+        // Between versions v1.26 and v1.27, the expected format of the data changed so that old stored data
+        // may not contain the configuration key.
+        if (data.current && 'configuration' in data.current) {
+            this.current = this.find(data.current.configuration, data.current.workspaceFolderUri, data.current.providerType);
+        }
+    }
+
+    protected resolveRecentDynamicOptionsFromData(options?: DebugSessionOptions[]): void {
+        if (!options || this.recentDynamicOptionsTracker.length !== 0) {
+            return;
         }
+
+        this.recentDynamicOptionsTracker = options;
     }
 
     save(): void {
         const data: DebugConfigurationManager.Data = {};
-        const { current } = this;
+        const { current, recentDynamicOptionsTracker } = this;
         if (current) {
-            data.current = {
-                name: current.configuration.name,
-                workspaceFolderUri: current.workspaceFolderUri
-            };
+            data.current = current;
         }
-        this.storage.setData('debug.configurations', data);
-    }
 
+        if (this.recentDynamicOptionsTracker.length > 0) {
+            data.recentDynamicOptions = recentDynamicOptionsTracker;
+        }
+
+        if (Object.keys(data).length > 0) {
+            this.storage.setData('debug.configurations', data);
+        }
+    }
 }
+
 export namespace DebugConfigurationManager {
     export interface Data {
-        current?: {
-            name: string
-            workspaceFolderUri?: string
-        }
+        current?: DebugSessionOptions,
+        recentDynamicOptions?: DebugSessionOptions[]
     }
 }

package/src/browser/debug-prefix-configuration.ts

@@ -123,10 +123,10 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
 
         // Resolve dynamic configurations from providers
         const record = await this.debugConfigurationManager.provideDynamicDebugConfigurations();
-        for (const [type, dynamicConfigurations] of Object.entries(record)) {
+        for (const [providerType, dynamicConfigurations] of Object.entries(record)) {
             if (dynamicConfigurations.length > 0) {
                 items.push({
-                    label: type,
+                    label: providerType,
                     type: 'separator'
                 });
             }
@@ -134,7 +134,7 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
             for (const configuration of dynamicConfigurations) {
                 items.push({
                     label: configuration.name,
-                    execute: () => this.runDynamicConfiguration({ configuration })
+                    execute: () => this.runConfiguration({ configuration, providerType })
                 });
             }
         }
@@ -145,21 +145,13 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
     /**
      * Set the current debug configuration, and execute debug start command.
      *
-     * @param configuration the `DebugSessionOptions`.
+     * @param configurationOptions the `DebugSessionOptions`.
      */
-    protected runConfiguration(configuration: DebugSessionOptions): void {
-        this.debugConfigurationManager.current = { ...configuration };
+    protected runConfiguration(configurationOptions: DebugSessionOptions): void {
+        this.debugConfigurationManager.current = configurationOptions;
         this.commandRegistry.executeCommand(DebugCommands.START.id);
     }
 
-    /**
-     * Execute the debug start command without affecting the current debug configuration
-     * @param configuration the `DebugSessionOptions`.
-     */
-    protected runDynamicConfiguration(configuration: DebugSessionOptions): void {
-        this.commandRegistry.executeCommand(DebugCommands.START.id, configuration);
-    }
-
     /**
      * Handle the visibility of the debug status bar.
      * @param event the preference change event.

package/src/browser/debug-session-options.ts

@@ -16,15 +16,42 @@
 
 import { DebugConfiguration } from '../common/debug-common';
 
-export interface DebugSessionOptions {
+export interface DebugSessionOptionsBase {
+    workspaceFolderUri?: string,
+    providerType?: string // Applicable to dynamic configurations
+}
+
+export interface DebugSessionOptions extends DebugSessionOptionsBase {
     configuration: DebugConfiguration
-    workspaceFolderUri?: string
 }
+
+export interface DebugSessionOptionsData extends DebugSessionOptionsBase, DebugConfiguration {
+}
+
 export interface InternalDebugSessionOptions extends DebugSessionOptions {
     id: number
 }
 export namespace InternalDebugSessionOptions {
+
+    const SEPARATOR = '__CONF__';
+
     export function is(options: DebugSessionOptions): options is InternalDebugSessionOptions {
-        return ('id' in options);
+        return 'id' in options;
+    }
+
+    export function toValue(debugSessionOptions: DebugSessionOptions): string {
+        return debugSessionOptions.configuration.name + SEPARATOR +
+            debugSessionOptions.configuration.type + SEPARATOR +
+            debugSessionOptions.configuration.request + SEPARATOR +
+            debugSessionOptions.workspaceFolderUri + SEPARATOR +
+            debugSessionOptions.providerType;
+    }
+
+    export function parseValue(value: string): DebugSessionOptionsData {
+        const split = value.split(SEPARATOR);
+        if (split.length !== 5) {
+            throw new Error('Unexpected argument, the argument is expected to have been generated by the \'toValue\' function');
+        }
+        return {name: split[0], type: split[1], request: split[2], workspaceFolderUri: split[3], providerType: split[4]};
     }
 }

package/src/browser/editor/debug-breakpoint-widget.tsx

@@ -214,7 +214,7 @@ export class DebugBreakpointWidget implements Disposable {
             this._input.getControl().setValue(this._values[this.context] || '');
         }
         ReactDOM.render(<SelectComponent
-            value={this.context} onChange={this.updateInput}
+            defaultValue={this.context} onChange={this.updateInput}
             options={[
                 { value: 'condition', label: nls.localizeByDefault('Expression') },
                 { value: 'hitCondition', label: nls.localizeByDefault('Hit Count') },

package/src/browser/view/debug-configuration-select.tsx

@@ -0,0 +1,234 @@
+/********************************************************************************
+ * Copyright (C) 2021 Ericsson and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import URI from '@theia/core/lib/common/uri';
+import * as React from '@theia/core/shared/react';
+import { DebugConfigurationManager } from '../debug-configuration-manager';
+import { DebugSessionOptions, InternalDebugSessionOptions } from '../debug-session-options';
+import { SelectComponent, SelectOption } from '@theia/core/lib/browser/widgets/select-component';
+import { QuickInputService } from '@theia/core/lib/browser';
+import { nls } from '@theia/core/lib/common/nls';
+
+interface DynamicPickItem { label: string, configurationType: string, request: string, providerType: string }
+
+export interface DebugConfigurationSelectProps {
+    manager: DebugConfigurationManager,
+    quickInputService: QuickInputService,
+    isMultiRoot: boolean
+}
+
+export interface DebugProviderSelectState {
+    providerTypes: string[],
+    currentValue: string | undefined
+}
+
+export class DebugConfigurationSelect extends React.Component<DebugConfigurationSelectProps, DebugProviderSelectState> {
+    protected static readonly SEPARATOR = '──────────';
+    protected static readonly PICK = '__PICK__';
+    protected static readonly NO_CONFIGURATION = '__NO_CONF__';
+    protected static readonly ADD_CONFIGURATION = '__ADD_CONF__';
+
+    private readonly selectRef = React.createRef<SelectComponent>();
+    private manager: DebugConfigurationManager;
+    private quickInputService: QuickInputService;
+
+    constructor(props: DebugConfigurationSelectProps) {
+        super(props);
+        this.manager = props.manager;
+        this.quickInputService = props.quickInputService;
+        this.state = {
+            providerTypes: [],
+            currentValue: undefined
+        };
+        this.manager.onDidChangeConfigurationProviders(() => {
+            this.refreshDebugConfigurations();
+        });
+    }
+
+    override componentDidMount(): void {
+        this.refreshDebugConfigurations();
+    }
+
+    override render(): React.ReactNode {
+        return <SelectComponent
+            options={this.renderOptions()}
+            defaultValue={this.currentValue}
+            onChange={option => this.setCurrentConfiguration(option)}
+            onFocus={() => this.refreshDebugConfigurations()}
+            onBlur={() => this.refreshDebugConfigurations()}
+            ref={this.selectRef}
+        />;
+    }
+
+    protected get currentValue(): string {
+        const { current } = this.manager;
+        return current ? InternalDebugSessionOptions.toValue(current) : DebugConfigurationSelect.NO_CONFIGURATION;
+    }
+
+    protected readonly setCurrentConfiguration = (option: SelectOption) => {
+        const value = option.value;
+        if (!value) {
+            return false;
+        } else if (value === DebugConfigurationSelect.ADD_CONFIGURATION) {
+            this.manager.addConfiguration();
+        } else if (value.startsWith(DebugConfigurationSelect.PICK)) {
+            const providerType = this.parsePickValue(value);
+            this.selectDynamicConfigFromQuickPick(providerType);
+        } else {
+            const { name, type, request, workspaceFolderUri, providerType } = InternalDebugSessionOptions.parseValue(value);
+            this.manager.current = this.manager.find(
+                { name, type, request },
+                workspaceFolderUri,
+                providerType === 'undefined' ? undefined : providerType
+            );
+        }
+    };
+
+    protected toPickValue(providerType: string): string {
+        return DebugConfigurationSelect.PICK + providerType;
+    }
+
+    protected parsePickValue(value: string): string {
+        return value.slice(DebugConfigurationSelect.PICK.length);
+    }
+
+    protected async resolveDynamicConfigurationPicks(providerType: string): Promise<DynamicPickItem[]> {
+        const configurationsOfProviderType =
+            (await this.manager.provideDynamicDebugConfigurations())[providerType];
+
+        if (!configurationsOfProviderType) {
+            return [];
+        }
+
+        return configurationsOfProviderType.map(configuration => ({
+            label: configuration.name,
+            configurationType: configuration.type,
+            request: configuration.request,
+            providerType
+        }));
+    }
+
+    protected async selectDynamicConfigFromQuickPick(providerType: string): Promise<void> {
+        const picks: DynamicPickItem[] = await this.resolveDynamicConfigurationPicks(providerType);
+
+        if (picks.length === 0) {
+            return;
+        }
+
+        const selected: DynamicPickItem | undefined = await this.quickInputService.showQuickPick(
+            picks,
+            {
+                placeholder: nls.localizeByDefault('Select Launch Configuration')
+            }
+        );
+
+        if (!selected) {
+            return;
+        }
+
+        const selectedConfiguration = {
+            name: selected.label,
+            type: selected.configurationType,
+            request: selected.request
+        };
+        this.manager.current = this.manager.find(selectedConfiguration, undefined, selected.providerType);
+        this.refreshDebugConfigurations();
+    }
+
+    protected refreshDebugConfigurations = async () => {
+        const configsPerType = await this.manager.provideDynamicDebugConfigurations();
+        const providerTypes = [];
+        for (const [ type, configurations ] of Object.entries(configsPerType)) {
+            if (configurations.length > 0) {
+                providerTypes.push(type);
+            }
+        }
+        this.selectRef.current!.value = this.currentValue;
+        this.setState({ providerTypes, currentValue: this.currentValue });
+    };
+
+    protected renderOptions(): SelectOption[] {
+        const options: SelectOption[] = [];
+
+        // Add non dynamic debug configurations
+        for (const config of this.manager.all) {
+            const value = InternalDebugSessionOptions.toValue(config);
+            options.push({
+                value,
+                label: this.toName(config, this.props.isMultiRoot)
+            });
+        }
+
+        // Add recently used dynamic debug configurations
+        const { recentDynamicOptions } = this.manager;
+        if (recentDynamicOptions.length > 0) {
+            if (options.length > 0) {
+                options.push({
+                    separator: true
+                });
+            }
+            for (const dynamicOption of recentDynamicOptions) {
+                const value = InternalDebugSessionOptions.toValue(dynamicOption);
+                options.push({
+                    value,
+                    label: this.toName(dynamicOption, this.props.isMultiRoot) + ' (' + dynamicOption.providerType + ')'
+                });
+            }
+        }
+
+        // Placing a 'No Configuration' entry enables proper functioning of the 'onChange' event, by
+        // having an entry to switch from (E.g. a case where only one dynamic configuration type is available)
+        if (options.length === 0) {
+            const value = DebugConfigurationSelect.NO_CONFIGURATION;
+            options.push({
+                value,
+                label: nls.localizeByDefault('No Configurations')
+            });
+        }
+
+        // Add dynamic configuration types for quick pick selection
+        const types = this.state.providerTypes;
+        if (types.length > 0) {
+            options.push({
+                separator: true
+            });
+            for (const type of types) {
+                const value = this.toPickValue(type);
+                options.push({
+                    value,
+                    label: type + '...'
+                });
+            }
+        }
+
+        options.push({
+            separator: true
+        });
+        options.push({
+            value: DebugConfigurationSelect.ADD_CONFIGURATION,
+            label: nls.localizeByDefault('Add Configuration...')
+        });
+
+        return options;
+    }
+
+    protected toName({ configuration, workspaceFolderUri }: DebugSessionOptions, multiRoot: boolean): string {
+        if (!workspaceFolderUri || !multiRoot) {
+            return configuration.name;
+        }
+        return `${configuration.name} (${new URI(workspaceFolderUri).path.base})`;
+    }
+}