@theia/plugin-ext 1.25.0-next.14 → 1.25.0-next.17

package/src/main/browser/debug/plugin-debug-service.ts

@@ -147,52 +147,74 @@ export class PluginDebugService implements DebugService {
         return configurationsRecord;
     }
 
-    async resolveDebugConfiguration(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration> {
-        let resolved = config;
-
+    async resolveDebugConfiguration(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined
+    ): Promise<DebugConfiguration | undefined | null> {
         const allProviders = Array.from(this.configurationProviders.values());
+
+        const resolvers = allProviders
+            .filter(p => p.type === config.type && !!p.resolveDebugConfiguration)
+            .map(p => p.resolveDebugConfiguration);
+
         // Append debug type '*' at the end
-        const pluginProviders = allProviders.filter(p => p.type === config.type && !!p.resolveDebugConfiguration);
-        pluginProviders.push(...allProviders.filter(p => p.type === '*' && !!p.resolveDebugConfiguration));
+        resolvers.push(
+            ...allProviders
+                .filter(p => p.type === '*' && !!p.resolveDebugConfiguration)
+                .map(p => p.resolveDebugConfiguration)
+        );
 
-        for (const provider of pluginProviders) {
-            try {
-                const next = await provider.resolveDebugConfiguration(workspaceFolderUri, resolved);
-                if (next) {
-                    resolved = next;
-                } else {
-                    return resolved;
-                }
-            } catch (e) {
-                console.error(e);
-            }
-        }
+        const resolved = await this.resolveDebugConfigurationByResolversChain(config, workspaceFolderUri, resolvers);
 
-        return this.delegated.resolveDebugConfiguration(resolved, workspaceFolderUri);
+        return resolved ? this.delegated.resolveDebugConfiguration(resolved, workspaceFolderUri) : resolved;
     }
 
-    async resolveDebugConfigurationWithSubstitutedVariables(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration> {
-        let resolved = config;
-
+    async resolveDebugConfigurationWithSubstitutedVariables(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined
+    ): Promise<DebugConfiguration | undefined | null> {
         const allProviders = Array.from(this.configurationProviders.values());
+
+        const resolvers = allProviders
+            .filter(p => p.type === config.type && !!p.resolveDebugConfigurationWithSubstitutedVariables)
+            .map(p => p.resolveDebugConfigurationWithSubstitutedVariables);
+
         // Append debug type '*' at the end
-        const pluginProviders = allProviders.filter(p => p.type === config.type && !!p.resolveDebugConfigurationWithSubstitutedVariables);
-        pluginProviders.push(...allProviders.filter(p => p.type === '*' && !!p.resolveDebugConfigurationWithSubstitutedVariables));
+        resolvers.push(
+            ...allProviders
+                .filter(p => p.type === '*' && !!p.resolveDebugConfigurationWithSubstitutedVariables)
+                .map(p => p.resolveDebugConfigurationWithSubstitutedVariables)
+        );
 
-        for (const provider of pluginProviders) {
+        const resolved = await this.resolveDebugConfigurationByResolversChain(config, workspaceFolderUri, resolvers);
+
+        return resolved
+            ? this.delegated.resolveDebugConfigurationWithSubstitutedVariables(resolved, workspaceFolderUri)
+            : resolved;
+    }
+
+    protected async resolveDebugConfigurationByResolversChain(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined,
+        resolvers: ((
+            folder: string | undefined,
+            debugConfiguration: DebugConfiguration
+        ) => Promise<DebugConfiguration | null | undefined>)[]
+    ): Promise<DebugConfiguration | undefined | null> {
+        let resolved: DebugConfiguration | undefined | null = config;
+        for (const resolver of resolvers) {
             try {
-                const next = await provider.resolveDebugConfigurationWithSubstitutedVariables(workspaceFolderUri, resolved);
-                if (next) {
-                    resolved = next;
-                } else {
-                    return resolved;
+                if (!resolved) {
+                    // A provider has indicated to stop and process undefined or null as per specified in the vscode API
+                    // https://code.visualstudio.com/api/references/vscode-api#DebugConfigurationProvider
+                    break;
                 }
+                resolved = await resolver(workspaceFolderUri, resolved);
             } catch (e) {
                 console.error(e);
             }
         }
-
-        return this.delegated.resolveDebugConfigurationWithSubstitutedVariables(resolved, workspaceFolderUri);
+        return resolved;
     }
 
     registerDebugger(contribution: DebuggerContribution): Disposable {

package/src/plugin/comments.ts

@@ -171,7 +171,7 @@ export class CommentsExtImpl implements CommentsExt {
 
         const documentData = this._documents.getDocumentData(URI.revive(uriComponents));
         if (documentData) {
-            const ranges: theia.Range[] | undefined = await commentController.commentingRangeProvider!.provideCommentingRanges(documentData.document, token);
+            const ranges: theia.Range[] | undefined | null = await commentController.commentingRangeProvider!.provideCommentingRanges(documentData.document, token);
             if (ranges) {
                 return ranges.map(x => fromRange(x));
             }

package/src/plugin/languages/lens.ts

@@ -71,7 +71,7 @@ export class CodeLensAdapter {
             return undefined;
         }
 
-        let newLens: theia.CodeLens | undefined;
+        let newLens: theia.CodeLens | undefined | null;
         if (typeof this.provider.resolveCodeLens === 'function' && !lens.isResolved) {
             newLens = await this.provider.resolveCodeLens(lens, token);
             if (token.isCancellationRequested) {

package/src/plugin/node/debug/debug.ts

@@ -346,12 +346,20 @@ export class DebugExtImpl implements DebugExt {
         return { provider, type };
     }
 
-    async $provideDebugConfigurationsByHandle(handle: number, workspaceFolderUri: string | undefined): Promise<theia.DebugConfiguration[]> {
+    async $provideDebugConfigurationsByHandle(
+        handle: number,
+        workspaceFolderUri: string | undefined
+    ): Promise<theia.DebugConfiguration[]> {
         const { provider, type } = this.getConfigurationProviderRecord(handle);
 
-        const configurations = await provider.provideDebugConfigurations?.(this.toWorkspaceFolder(workspaceFolderUri));
+        const configurations = await provider.provideDebugConfigurations?.(
+            this.toWorkspaceFolder(workspaceFolderUri)
+        );
+
         if (!configurations) {
-            throw new Error('nothing returned from DebugConfigurationProvider.provideDebugConfigurations, type: ' + type);
+            throw new Error(
+                'nothing returned from DebugConfigurationProvider.provideDebugConfigurations, type: ' + type
+            );
         }
 
         return configurations;
@@ -361,88 +369,24 @@ export class DebugExtImpl implements DebugExt {
         handle: number,
         workspaceFolderUri: string | undefined,
         debugConfiguration: theia.DebugConfiguration
-    ): Promise<theia.DebugConfiguration | undefined> {
-
+    ): Promise<theia.DebugConfiguration | undefined | null> {
         const { provider } = this.getConfigurationProviderRecord(handle);
-        return provider.resolveDebugConfiguration?.(this.toWorkspaceFolder(workspaceFolderUri), debugConfiguration);
+        return provider.resolveDebugConfiguration?.(
+            this.toWorkspaceFolder(workspaceFolderUri),
+            debugConfiguration
+        );
     }
 
     async $resolveDebugConfigurationWithSubstitutedVariablesByHandle(
         handle: number,
         workspaceFolderUri: string | undefined,
         debugConfiguration: theia.DebugConfiguration
-    ): Promise<theia.DebugConfiguration | undefined> {
-
+    ): Promise<theia.DebugConfiguration | undefined | null> {
         const { provider } = this.getConfigurationProviderRecord(handle);
-        return provider.resolveDebugConfigurationWithSubstitutedVariables?.(this.toWorkspaceFolder(workspaceFolderUri), debugConfiguration);
-    }
-
-    async $provideDebugConfigurations(debugType: string, workspaceFolderUri: string | undefined, dynamic: boolean = false): Promise<theia.DebugConfiguration[]> {
-        let result: theia.DebugConfiguration[] = [];
-
-        const trigger = dynamic ? DebugConfigurationProviderTriggerKind.Dynamic : DebugConfigurationProviderTriggerKind.Initial;
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugType && p.trigger === trigger)
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.provideDebugConfigurations) {
-                result = result.concat(await provider.provideDebugConfigurations(this.toWorkspaceFolder(workspaceFolderUri)) || []);
-            }
-        }
-
-        return result;
-    }
-
-    async $resolveDebugConfigurations(debugConfiguration: theia.DebugConfiguration, workspaceFolderUri: string | undefined): Promise<theia.DebugConfiguration | undefined> {
-        let current = debugConfiguration;
-
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugConfiguration.type || p.type === '*')
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.resolveDebugConfiguration) {
-                try {
-                    const next = await provider.resolveDebugConfiguration(this.toWorkspaceFolder(workspaceFolderUri), current);
-                    if (next) {
-                        current = next;
-                    } else {
-                        return current;
-                    }
-                } catch (e) {
-                    console.error(e);
-                }
-            }
-        }
-
-        return current;
-    }
-
-    async $resolveDebugConfigurationWithSubstitutedVariables(debugConfiguration: theia.DebugConfiguration, workspaceFolderUri: string | undefined):
-        Promise<theia.DebugConfiguration | undefined> {
-        let current = debugConfiguration;
-
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugConfiguration.type || p.type === '*')
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.resolveDebugConfigurationWithSubstitutedVariables) {
-                try {
-                    const next = await provider.resolveDebugConfigurationWithSubstitutedVariables(this.toWorkspaceFolder(workspaceFolderUri), current);
-                    if (next) {
-                        current = next;
-                    } else {
-                        return current;
-                    }
-                } catch (e) {
-                    console.error(e);
-                }
-            }
-        }
-
-        return current;
+        return provider.resolveDebugConfigurationWithSubstitutedVariables?.(
+            this.toWorkspaceFolder(workspaceFolderUri),
+            debugConfiguration
+        );
     }
 
     protected async createDebugAdapterTracker(session: theia.DebugSession): Promise<theia.DebugAdapterTracker> {

package/src/plugin/tree/tree-views.ts

@@ -262,7 +262,8 @@ class TreeViewExtImpl<T> implements Disposable {
             // root
             return [];
         }
-        const parent = this.treeDataProvider.getParent && await this.treeDataProvider.getParent(element);
+        const result = this.treeDataProvider.getParent && await this.treeDataProvider.getParent(element);
+        const parent = result ? result : undefined;
         const chain = await this.calculateRevealParentChain(parent);
         if (!chain) {
             // parents are inconsistent

package/src/plugin/workspace.ts

@@ -276,7 +276,7 @@ export class WorkspaceExtImpl implements WorkspaceExt {
         };
     }
 
-    async $provideTextDocumentContent(documentURI: string): Promise<string | undefined> {
+    async $provideTextDocumentContent(documentURI: string): Promise<string | undefined | null> {
         const uri = URI.parse(documentURI);
         const provider = this.documentContentProviders.get(uri.scheme);
         if (provider) {