Fix double prompting for default build task when canceled

Fixes #81767

src/vs/workbench/services/configurationResolver/browser/configurationResolverService.ts

@@ -91,21 +91,21 @@ export abstract class BaseConfigurationResolverService extends AbstractVariableR
 		config = await this.resolveAny(folder, config);
 
 		// resolve input variables in the order in which they are encountered
-		return this.resolveWithInteraction(folder, config, section, variables, true).then(mapping => {
+		return this.resolveWithInteraction(folder, config, section, variables, false).then(mapping => {
 			// finally substitute evaluated command variables (if there are any)
 			if (!mapping) {
 				return null;
 			} else if (mapping.size > 0) {
-				return this.resolveAny(folder, config, fromMap(mapping));
+				return this.resolveAny(folder, config, fromMap(mapping), false);
 			} else {
 				return config;
 			}
 		});
 	}
 
-	public async resolveWithInteraction(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>, skipContributed: boolean = false): Promise<Map<string, string> | undefined> {
+	public async resolveWithInteraction(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>, resolveContributed: boolean = true): Promise<Map<string, string> | undefined> {
 		// resolve any non-interactive variables and any contributed variables
-		const resolved = await this.resolveAnyMap(folder, config);
+		const resolved = await this.resolveAnyMap(folder, config, resolveContributed);
 		config = resolved.newConfig;
 		const allVariableMapping: Map<string, string> = resolved.resolvedVariables;
 

src/vs/workbench/services/configurationResolver/common/configurationResolver.ts

@@ -20,7 +20,7 @@ export interface IConfigurationResolverService {
 	 * Recursively resolves all variables in the given config and returns a copy of it with substituted values.
 	 * Command variables are only substituted if a "commandValueMapping" dictionary is given and if it contains an entry for the command.
 	 */
-	resolveAny(folder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<any>;
+	resolveAny(folder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>, resolveContributed?: boolean): Promise<any>;
 
 	/**
 	 * Recursively resolves all variables (including commands and user input) in the given config and returns a copy of it with substituted values.

src/vs/workbench/services/configurationResolver/common/variableResolver.ts

@@ -53,7 +53,7 @@ export class AbstractVariableResolverService implements IConfigurationResolverSe
 		return this.recursiveResolve(root ? root.uri : undefined, value);
 	}
 
-	private async resolveAnyBase(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>, resolvedVariables?: Map<string, string>): Promise<any> {
+	private async resolveAnyBase(workspaceFolder: IWorkspaceFolder | undefined, config: any, resolveContributed: boolean, commandValueMapping?: IStringDictionary<string>, resolvedVariables?: Map<string, string>): Promise<any> {
 		const result = objects.deepClone(config) as any;
 
 		// hoist platform specific attributes to top level
@@ -71,16 +71,16 @@ export class AbstractVariableResolverService implements IConfigurationResolverSe
 		delete result.linux;
 
 		// substitute all variables recursively in string values
-		return this.recursiveResolvePromise(workspaceFolder ? workspaceFolder.uri : undefined, result, commandValueMapping, resolvedVariables);
+		return this.recursiveResolvePromise(workspaceFolder ? workspaceFolder.uri : undefined, result, resolveContributed, commandValueMapping, resolvedVariables);
 	}
 
-	public resolveAny(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<any> {
-		return this.resolveAnyBase(workspaceFolder, config, commandValueMapping);
+	public resolveAny(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>, resolveContributed: boolean = true): Promise<any> {
+		return this.resolveAnyBase(workspaceFolder, config, resolveContributed, commandValueMapping);
 	}
 
-	protected async resolveAnyMap(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<{ newConfig: any, resolvedVariables: Map<string, string> }> {
+	protected async resolveAnyMap(workspaceFolder: IWorkspaceFolder | undefined, config: any, resolveContributed: boolean, commandValueMapping?: IStringDictionary<string>): Promise<{ newConfig: any, resolvedVariables: Map<string, string> }> {
 		const resolvedVariables = new Map<string, string>();
-		const newConfig = await this.resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables);
+		const newConfig = await this.resolveAnyBase(workspaceFolder, config, resolveContributed, commandValueMapping, resolvedVariables);
 		return { newConfig, resolvedVariables };
 	}
 
@@ -116,17 +116,17 @@ export class AbstractVariableResolverService implements IConfigurationResolverSe
 		return value;
 	}
 
-	private async recursiveResolvePromise(folderUri: uri | undefined, value: any, commandValueMapping?: IStringDictionary<string>, resolvedVariables?: Map<string, string>): Promise<any> {
+	private async recursiveResolvePromise(folderUri: uri | undefined, value: any, resolveContributed: boolean, commandValueMapping?: IStringDictionary<string>, resolvedVariables?: Map<string, string>): Promise<any> {
 		if (types.isString(value)) {
-			return this.resolveStringPromise(folderUri, value, commandValueMapping, resolvedVariables);
+			return this.resolveStringPromise(folderUri, value, commandValueMapping, resolveContributed, resolvedVariables);
 		} else if (types.isArray(value)) {
-			return Promise.all(value.map(s => this.recursiveResolvePromise(folderUri, s, commandValueMapping, resolvedVariables)));
+			return Promise.all(value.map(s => this.recursiveResolvePromise(folderUri, s, resolveContributed, commandValueMapping, resolvedVariables)));
 		} else if (types.isObject(value)) {
 			let result: IStringDictionary<string | IStringDictionary<string> | string[]> = Object.create(null);
 			const keys = Object.keys(value);
 			for (let key of keys) {
-				const replaced = await this.resolveStringPromise(folderUri, key, commandValueMapping, resolvedVariables);
-				result[replaced] = await this.recursiveResolvePromise(folderUri, value[key], commandValueMapping, resolvedVariables);
+				const replaced = await this.resolveStringPromise(folderUri, key, commandValueMapping, resolveContributed, resolvedVariables);
+				result[replaced] = await this.recursiveResolvePromise(folderUri, value[key], resolveContributed, commandValueMapping, resolvedVariables);
 			}
 			return result;
 		}
@@ -150,17 +150,19 @@ export class AbstractVariableResolverService implements IConfigurationResolverSe
 		return replaced;
 	}
 
-	private async resolveStringPromise(folderUri: uri | undefined, value: string, commandValueMapping: IStringDictionary<string> | undefined, resolvedVariables?: Map<string, string>): Promise<string> {
+	private async resolveStringPromise(folderUri: uri | undefined, value: string, commandValueMapping: IStringDictionary<string> | undefined, resolveContributed: boolean, resolvedVariables?: Map<string, string>): Promise<string> {
 		// loop through all variables occurrences in 'value'
 		const matches = value.match(AbstractVariableResolverService.VARIABLE_REGEXP);
 		const replaces: Map<string, string> = new Map();
 		if (!matches) {
 			return value;
 		}
-		for (const match of matches) {
-			const evaluate = await this.evaluateSingleContributedVariable(match, match.match(AbstractVariableResolverService.VARIABLE_REGEXP_SINGLE)![1]);
-			if (evaluate !== match) {
-				replaces.set(match, evaluate);
+		if (resolveContributed) {
+			for (const match of matches) {
+				const evaluate = await this.evaluateSingleContributedVariable(match, match.match(AbstractVariableResolverService.VARIABLE_REGEXP_SINGLE)![1]);
+				if (evaluate !== match) {
+					replaces.set(match, evaluate);
+				}
 			}
 		}