cmakeTaskProvider.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import { CMakeDriver } from './drivers/drivers';
import * as proc from './proc';
import * as nls from 'vscode-nls';
import { Environment, EnvironmentUtils } from './environmentVariables';
import * as logging from './logging';
import { extensionManager, getActiveProject } from './extension';
import { CMakeProject, ConfigureTrigger } from './cmakeProject';
import * as preset from '@cmt/presets/preset';
import { UseCMakePresets } from './config';
import * as telemetry from '@cmt/telemetry';
import * as util from '@cmt/util';
import * as expand from '@cmt/expand';
import { CommandResult } from 'vscode-cmake-tools';

nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
const localize: nls.LocalizeFunc = nls.loadMessageBundle();
const log = logging.createLogger('TaskProvider');

const endOfLine: string = "\r\n";

export interface CMakeTaskDefinition extends vscode.TaskDefinition {
    type: string;
    label: string;
    command: string; // Command is either "build", "configure", "install", "test", "package" or "workflow".
    targets?: string[]; // only in "build" command
    preset?: string;
    options?: { cwd?: string; environment?: Environment };
}

export class CMakeTask extends vscode.Task {
    detail?: string;
    isDefault?: boolean;
    isTemplate?: boolean;
}

export interface TaskMenu extends vscode.QuickPickItem {
    task: CMakeTask;
}

export enum CommandType {
    build = "build",
    config = "configure",
    install = "install",
    test = "test",
    package = "package",
    workflow = "workflow",
    clean = "clean",
    cleanRebuild = "cleanRebuild"
}

const localizeCommandType = (cmd: CommandType): string => {
    switch (cmd) {
        case CommandType.build: {
            return localize("build", "build");
        }
        case CommandType.install: {
            return localize("install", "install");
        }
        case CommandType.test: {
            return localize("test", "test");
        }
        case CommandType.package: {
            return localize("package", "package");
        }
        case CommandType.workflow: {
            return localize("workflow", "workflow");
        }
        case CommandType.config: {
            return localize("configure", "configure");
        }
        case CommandType.clean: {
            return localize("clean", "clean");
        }
        case CommandType.cleanRebuild: {
            return localize("clean.rebuild", "clean rebuild");
        }
        default: {
            return "";
        }
    };
};

/**
 * Returns the default preset name for the given project and command type.
 *
 * @param project Project to get the default preset name for.
 * @param commandType Command type to get the default preset name for.
 * @returns The default preset name for the given project and command type.
 */
function getDefaultPresetNameForProject(project: CMakeProject | undefined, commandType: CommandType): string | undefined {
    if (!project) {
        return undefined;
    }
    switch (commandType) {
        case CommandType.config:
            return project.configurePreset?.name;
        case CommandType.build:
            return project.buildPreset?.name;
        case CommandType.install:
            return project.buildPreset?.name;
        case CommandType.clean:
            return project.buildPreset?.name;
        case CommandType.cleanRebuild:
            return project.buildPreset?.name;
        case CommandType.test:
            return project.testPreset?.name;
        case CommandType.package:
            return project.packagePreset?.name;
        case CommandType.workflow:
            return project.workflowPreset?.name;
        default:
            return undefined;
    }
}

async function getDefaultPresetNameForActiveProject(commandType: CommandType, resolve: boolean = false): Promise<string | undefined> {
    let result: string | undefined;
    switch (commandType) {
        case CommandType.config:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeConfigurePresetName", []) as string :
                "${command:cmake.activeConfigurePresetName}";
            break;
        case CommandType.build:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeBuildPresetName", []) as string :
                "${command:cmake.activeBuildPresetName}";
            break;
        case CommandType.install:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeBuildPresetName", []) as string :
                "${command:cmake.activeBuildPresetName}";
            break;
        case CommandType.clean:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeBuildPresetName", []) as string :
                "${command:cmake.activeBuildPresetName}";
            break;
        case CommandType.cleanRebuild:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeBuildPresetName", []) as string :
                "${command:cmake.activeBuildPresetName}";
            break;
        case CommandType.test:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeTestPresetName", []) as string :
                "${command:cmake.activeTestPresetName}";
            break;
        case CommandType.package:
            result = resolve ? await vscode.commands.executeCommand("cmake.activePackagePresetName", []) as string :
                "${command:cmake.activePackagePresetName}";
            break;
        case CommandType.workflow:
            result = resolve ? await vscode.commands.executeCommand("cmake.activeWorkflowPresetName", []) as string :
                "${command:cmake.activeWorkflowPresetName}";
            break;
        default:
            return undefined;
    }
    return result;
}

export class CMakeTaskProvider implements vscode.TaskProvider {
    static CMakeScriptType: string = 'cmake';
    static CMakeSourceStr: string = "CMake";

    constructor() {
    }

    public async provideTasks(): Promise<CMakeTask[]> {
        const allProjects: CMakeProject[] | undefined = extensionManager?.getAllCMakeProjects();
        if (!allProjects) {
            return [];
        }
        const result: CMakeTask[] = [];
        for (const project of allProjects) {
            const targets: string[] | undefined = await project.getDefaultBuildTargets() || ["all"];
            result.push(await CMakeTaskProvider.provideTask(CommandType.config, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.build, project.workspaceFolder, project.useCMakePresets, targets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.install, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.test, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.package, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.workflow, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.clean, project.workspaceFolder, project.useCMakePresets));
            result.push(await CMakeTaskProvider.provideTask(CommandType.cleanRebuild, project.workspaceFolder, project.useCMakePresets, targets));
        }
        return result;
    }

    public static async provideTask(commandType: CommandType, workspaceFolder: vscode.WorkspaceFolder, useCMakePresets?: boolean, targets?: string[], presetName?: string): Promise<CMakeTask> {
        const taskName: string = localizeCommandType(commandType);
        const project = await extensionManager?.getProjectForFolder(workspaceFolder);
        if (!project) {
            log.error(localize("project.not.found", 'Project not found.'));
        }
        let buildTargets: string[] | undefined;
        let preset: string | undefined;
        if (commandType === CommandType.build || commandType === CommandType.cleanRebuild) {
            buildTargets = targets;
        }
        if (presetName) {
            preset = presetName;
        } else if (useCMakePresets) {
            preset = getDefaultPresetNameForProject(project, commandType);
        }

        const definition: CMakeTaskDefinition = {
            type: CMakeTaskProvider.CMakeScriptType,
            label: CMakeTaskProvider.CMakeSourceStr + ": " + taskName,
            command: commandType,
            targets: buildTargets,
            preset: preset
        };
        // Add the workspace folder name to the task label if it is defined. This is to differentiate between tasks with the same name in different workspaces.
        if (workspaceFolder !== undefined) {
            definition.label = `${workspaceFolder.name}: ${definition.label}`;
        }
        const task = new vscode.Task(definition, workspaceFolder, taskName, CMakeTaskProvider.CMakeSourceStr,
            new vscode.CustomExecution(async (resolvedDefinition: vscode.TaskDefinition): Promise<vscode.Pseudoterminal> =>
                // When the task is executed, this callback will run. Here, we setup for running the task.
                new CustomBuildTaskTerminal(resolvedDefinition.command, resolvedDefinition.targets, workspaceFolder, resolvedDefinition.preset, {})
            ), []);
        task.group = (commandType === CommandType.build || commandType === CommandType.cleanRebuild) ? vscode.TaskGroup.Build : undefined;
        task.detail = localize('cmake.template.task', 'CMake template {0} task', taskName);
        return task;
    }

    public async resolveTask(task: CMakeTask): Promise<CMakeTask | undefined> {
        const execution: any = task.execution;
        if (!execution) {
            const definition: CMakeTaskDefinition = <any>task.definition;
            // task.scope can be a WorkspaceFolder, TaskScope.Global, or TaskScope.Workspace.
            // Only use it as a WorkspaceFolder if it's an object (not a number or null).
            const workspaceFolder: vscode.WorkspaceFolder | undefined = (task.scope && typeof task.scope === 'object') ? task.scope as vscode.WorkspaceFolder : undefined;
            const resolvedTask: CMakeTask = new vscode.Task(definition, workspaceFolder ?? vscode.TaskScope.Workspace, definition.label, CMakeTaskProvider.CMakeSourceStr,
                new vscode.CustomExecution(async (resolvedDefinition: vscode.TaskDefinition): Promise<vscode.Pseudoterminal> =>
                    new CustomBuildTaskTerminal(resolvedDefinition.command, resolvedDefinition.targets, workspaceFolder, resolvedDefinition.preset, resolvedDefinition.options)
                ), []);
            return resolvedTask;
        }
        return undefined;
    }

    public static async resolveInternalTask(task: CMakeTask): Promise<{ task: CMakeTask; exitCodePromise?: Promise<number | null> } | undefined> {
        const execution: any = task.execution;
        if (!execution) {
            const definition: CMakeTaskDefinition = <any>task.definition;
            // task.scope can be a WorkspaceFolder, TaskScope.Global, or TaskScope.Workspace.
            // Only use it as a WorkspaceFolder if it's an object (not a number or null).
            const workspaceFolder: vscode.WorkspaceFolder | undefined = (task.scope && typeof task.scope === 'object') ? task.scope as vscode.WorkspaceFolder : undefined;
            let exitCodeResolve!: (exitCode: number | null) => void;
            const exitCodePromise = new Promise<number | null>(resolve => {
                exitCodeResolve = resolve;
            });
            const resolvedTask: CMakeTask = new vscode.Task(definition, workspaceFolder ?? vscode.TaskScope.Workspace, definition.label, CMakeTaskProvider.CMakeSourceStr,
                new vscode.CustomExecution(async (resolvedDefinition: vscode.TaskDefinition): Promise<vscode.Pseudoterminal> => {
                    const terminal = new CustomBuildTaskTerminal(resolvedDefinition.command, resolvedDefinition.targets, workspaceFolder, resolvedDefinition.preset, resolvedDefinition.options);
                    const listener = terminal.onDidClose((exitCode) => {
                        listener.dispose();
                        exitCodeResolve(exitCode);
                    });
                    return terminal;
                }), []);
            return { task: resolvedTask, exitCodePromise };
        }
        return { task };
    }

    public static async findBuildTask(workspaceFolder: string, presetName?: string, targets?: string[], expansionOptions?: expand.ExpansionOptions): Promise<CMakeTask | undefined> {
        // Fetch all CMake task from `tasks.json` files.
        const allTasks: vscode.Task[] = await vscode.tasks.fetchTasks({ type: CMakeTaskProvider.CMakeScriptType });

        // Fetch CMake task from from task provider
        const workspaceFolderObj: vscode.WorkspaceFolder | undefined = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(workspaceFolder));
        if (!workspaceFolderObj) {
            log.error(localize("workspace.folder.not.found", 'Workspace folder not found.'));
            return undefined;
        }

        const tasks: (CMakeTask | undefined)[] = await Promise.all(allTasks.map(async (task: any) => {
            if (!task.definition.label || !task.group || (task.group && task.group.id !== vscode.TaskGroup.Build.id)) {
                return undefined;
            }

            let taskTargets: string[];
            if (expansionOptions && task.definition.targets) {
                taskTargets = await expand.expandStrings(task.definition.targets, expansionOptions);
                if (task.definition.options?.cwd) {
                    task.definition.options.cwd = await expand.expandString(task.definition.options.cwd, expansionOptions);
                }
            } else {
                taskTargets = task.definition.targets;
            }

            const definition: CMakeTaskDefinition = {
                type: task.definition.type,
                label: task.definition.label,
                command: task.definition.command,
                targets: taskTargets || targets,
                preset: task.definition.preset,
                options: task.definition.options
            };

            const buildTask: CMakeTask = new vscode.Task(definition, workspaceFolderObj, task.definition.label, CMakeTaskProvider.CMakeSourceStr);
            buildTask.detail = task.detail;
            if (task.group.isDefault) {
                buildTask.isDefault = true;
            }
            return buildTask;
        }));

        const buildTasks: CMakeTask[] = tasks.filter((task) => task !== undefined) as CMakeTask[];

        // No CMake Task is found.
        if (buildTasks.length === 0) {
            return undefined;
        }

        // Find tasks with a target that matches the input preset's target or the input targets
        let matchingTargetTasks: CMakeTask[];

        if (presetName) {
            matchingTargetTasks = buildTasks.filter(task => task.definition.preset === presetName
                || task.definition.preset === "${command:cmake.activeBuildPresetName}");
        } else {
            matchingTargetTasks = buildTasks.filter(task => {
                const taskTargets: string[] = task.definition.targets || [];
                const inputTargets: string[] = targets || [];
                return taskTargets.length === inputTargets.length && taskTargets.every((item, index) => item === inputTargets[index]);
            });
        }

        if (matchingTargetTasks.length > 0) {
            // One task is found.
            if (matchingTargetTasks.length === 1) {
                return matchingTargetTasks[0];
            } else {
                // Search for the matching default task.
                const defaultTask: CMakeTask[] = matchingTargetTasks.filter(task => task.isDefault);
                if (defaultTask.length >= 1) {
                    return defaultTask[0];
                } else {
                    // If there are two tasks, both of them are templates, either build or clean rebuild, select the build one - the first one
                    if (matchingTargetTasks.length === 2) {
                        return matchingTargetTasks[0];
                    }
                    // If there is no default task, matchingTargetTasks is a mixture of template and defined tasks.
                    // If there is only one task, that task is a template, so return the template.
                    // If there are three tasks, the first two are always templates, and the third one is the defined task that we are searching for.
                    // But if there are more than three tasks, it means that there are multiple defiend tasks and none are set as default. So ask the user to choose one later.
                    if (matchingTargetTasks.length === 1 || matchingTargetTasks.length === 3) {
                        return matchingTargetTasks[matchingTargetTasks.length - 1];
                    }
                }
            }
        }

        matchingTargetTasks.push(await CMakeTaskProvider.provideTask(CommandType.build, workspaceFolderObj, undefined, targets, presetName));
        const items: TaskMenu[] = matchingTargetTasks.map<TaskMenu>(task => ({ label: task.name, task: task, description: task.detail }));
        // Ask the user to pick a task.
        const selection = await vscode.window.showQuickPick(items, { placeHolder: localize('select.build.task', 'Select a build task') });
        return selection?.task;
    }
}

export class CustomBuildTaskTerminal extends proc.CommandConsumer implements vscode.Pseudoterminal {
    private writeEmitter = new vscode.EventEmitter<string>();
    private closeEmitter = new vscode.EventEmitter<number>();
    public get onDidWrite(): vscode.Event<string> {
        return this.writeEmitter.event;
    }
    public get onDidClose(): vscode.Event<number> {
        return this.closeEmitter.event;
    }

    constructor(private command: string, private targets: string[], private workspaceFolder?: vscode.WorkspaceFolder, private preset?: string, private options?: { cwd?: string; environment?: Environment }) {
        super();
    }

    // These two override methods are used to write output and error messages to the terminal, as well
    // as call the parent class's output and error methods, which store the stdout and stderr messages for returning that info later.
    override output(line: string): void {
        this.writeEmitter.fire(line + endOfLine);
        super.output(line);
    }

    override error(error: string): void {
        this.writeEmitter.fire(error + endOfLine);
        super.error(error);
    }

    async open(_initialDimensions: vscode.TerminalDimensions | undefined): Promise<void> {
        // At this point we can start using the terminal.
        switch (this.command) {
            case CommandType.config:
                await this.runConfigTask();
                break;
            case CommandType.build:
                await this.runBuildTask(CommandType.build);
                break;
            case CommandType.install:
                await this.runInstallTask();
                break;
            case CommandType.test:
                await this.runTestTask();
                break;
            case CommandType.package:
                await this.runPackageTask();
                break;
            case CommandType.workflow:
                await this.runWorkflowTask();
                break;
            case CommandType.clean:
                await this.runBuildTask(CommandType.clean);
                break;
            case CommandType.cleanRebuild:
                await this.runCleanRebuildTask();
                break;
            default:
                this.writeEmitter.fire(localize("command.not.recognized", '{0} is not a recognized command.', `"${this.command}"`) + endOfLine);
                this.closeEmitter.fire(-1);
                return;
        }
    }

    private _process: proc.Subprocess | undefined = undefined;
    async close(): Promise<void> {
        if (this._process) {
            if (this._process.child) {
                await util.termProc(this._process.child);
            }
            this._process = undefined;
        }
    }

    private async correctTargets(project: CMakeProject, commandType: CommandType): Promise<string[]> {
        let targets: string[] = this.targets;
        const targetIsDefined: boolean = this.targets && this.targets.length > 0;
        const shouldIgnore: boolean = commandType !== CommandType.build;

        if (shouldIgnore && targetIsDefined) {
            this.writeEmitter.fire(localize("target.is.ignored", "The defined targets in this task are being ignored.") + endOfLine);
        }

        if (commandType === CommandType.clean) {
            targets = ['clean'];
        } else if (!shouldIgnore && !targetIsDefined && !project.useCMakePresets) {
            targets = [await project.buildTargetName() || await project.allTargetName];
        }
        return targets;
    }

    private async isTaskCompatibleWithPresets(project: CMakeProject): Promise<boolean> {
        const useCMakePresets: boolean = project.useCMakePresets;
        const presetDefined: boolean = this.preset !== undefined && this.preset !== null;
        const isNotCompatible = !useCMakePresets && presetDefined;
        if (!isNotCompatible) {
            return true;
        }
        const change: string = localize('enable.cmake.presets', "Enable CMakePresets");
        const ignore: string = localize('dismiss', "Dismiss");
        /** We don't want to await on this error message,
         * because if the user decides to change the settings, the task needs to re-run for the new settings to be effective.
         **/
        void vscode.window.showErrorMessage(
            localize('task.not.compatible.with.preset.setting', 'The selected task requests a CMakePreset, but the workspace is not configured for CMakePresets'),
            change, ignore).then((selection) => {
            if (selection === change) {
                const config: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration();
                if (config) {
                    const newValue: UseCMakePresets = (presetDefined) ? 'always' : 'never';
                    void config.update("cmake.useCMakePresets", newValue);
                }
            }
        });
        this.writeEmitter.fire(localize('task.not.compatible.with.preset.setting', 'The selected task is not compatible with preset setting.') + endOfLine);
        this.closeEmitter.fire(-1);
        return false;
    }

    private async resolvePresetName(preset: string | undefined, useCMakePresets: boolean, commandType: CommandType): Promise<string | undefined> {
        if (preset !== undefined) {
            return preset;
        }
        return useCMakePresets ? getDefaultPresetNameForActiveProject(commandType, true) : undefined;
    }

    /**
     *
     * @returns The CMake project for the current workspace folder if the workspace folder is defined, otherwise the active project.
     */
    private async getProject(): Promise<CMakeProject | undefined> {
        let project: CMakeProject | undefined = getActiveProject();
        if (this.workspaceFolder !== undefined) {
            this.writeEmitter.fire(localize("workspace.is", "Workspace is {0}", this.workspaceFolder.uri.path + endOfLine));
            project = await extensionManager?.getProjectForFolder(this.workspaceFolder);
        }
        if (!project) {
            log.debug(localize("cmake.tools.not.found", 'CMake Tools not found.'));
            this.writeEmitter.fire(localize("task.failed", "Task failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
        return project;
    }

    private async runConfigTask(): Promise<any> {
        this.writeEmitter.fire(localize("config.started", "Config task started...") + endOfLine);
        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "configure", useCMakePresets: String(project.useCMakePresets) });
        await this.correctTargets(project, CommandType.config);
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;

        if (cmakeDriver) {
            if (project.useCMakePresets && cmakeDriver.config.configureOnEdit) {
                log.debug(localize("configure.on.edit", 'When running configure tasks using presets, setting configureOnEdit to true can potentially overwrite the task configurations.'));
            }

            this.preset = await this.resolvePresetName(this.preset, project.useCMakePresets, CommandType.config);
            const configPreset: preset.ConfigurePreset | undefined = await project?.expandConfigPresetbyName(this.preset);
            const result = await cmakeDriver.configure(ConfigureTrigger.taskProvider, [], this, undefined, undefined, false, false, configPreset, this.options);
            if (result === undefined || result === null) {
                this.writeEmitter.fire(localize('configure.terminated', 'Configure was terminated') + endOfLine);
                this.closeEmitter.fire(-1);
            } else {
                this.writeEmitter.fire(localize('configure.finished.with.code', 'Configure finished with return code {0}', result.exitCode) + endOfLine);
                this.closeEmitter.fire(result.exitCode);
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("configure.failed", "Configure failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
    }

    private async runBuildTask(commandType: CommandType, doCloseEmitter: boolean = true, generateLog: boolean = true, project?: CMakeProject): Promise<number> {
        let targets = this.targets;
        const taskName: string = localizeCommandType(commandType);
        let fullCommand: proc.BuildCommand | null;
        let args: string[] = [];

        if (!project) {
            project = await this.getProject();
            if (!project || !await this.isTaskCompatibleWithPresets(project)) {
                return -1;
            }
        }
        if (generateLog) {
            telemetry.logEvent("task", { taskType: commandType, useCMakePresets: String(project.useCMakePresets) });
        }
        targets = await this.correctTargets(project, commandType);
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;
        let cmakePath: string;
        if (cmakeDriver) {
            cmakePath = cmakeDriver.getCMakeCommand();

            if (!this.options) {
                this.options = {};
            }
            this.preset = await this.resolvePresetName(this.preset, project.useCMakePresets, CommandType.build);
            if (this.preset) {
                const buildPreset: preset.BuildPreset | undefined = await project?.expandBuildPresetbyName(this.preset);
                if (!buildPreset) {
                    log.debug(localize("build.preset.not.found", 'Build preset not found.'));
                    this.writeEmitter.fire(localize("build.no.preset.failed", "Build preset {0} not found. {1} failed.", this.preset, taskName) + endOfLine);
                    if (doCloseEmitter) {
                        this.closeEmitter.fire(-1);
                    }
                    return -1;
                }
                fullCommand = await cmakeDriver.generateBuildCommandFromPreset(buildPreset, targets);
                if (fullCommand) {
                    cmakePath = fullCommand.command;
                    args = fullCommand.args || [];
                    this.options.environment = EnvironmentUtils.merge([fullCommand.build_env, this.options.environment], { preserveNull: true });
                }
            } else {
                fullCommand = await cmakeDriver.generateBuildCommandFromSettings(targets);
                if (fullCommand) {
                    cmakePath = fullCommand.command;
                    args = fullCommand.args ? fullCommand.args : [];
                    this.options.environment = EnvironmentUtils.merge([fullCommand.build_env, this.options.environment]);
                }
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("build.failed", "{0} failed.", taskName) + endOfLine);
            if (doCloseEmitter) {
                this.closeEmitter.fire(-1);
            }
            return -1;
        }
        this.writeEmitter.fire(localize("build.started", "{0} task started....", taskName) + endOfLine);
        this.writeEmitter.fire(proc.buildCmdStr(cmakePath, args) + endOfLine);
        try {
            // On Windows, command-type-specific detection takes precedence over config.shell
            const commandShell = process.platform === 'win32' ? proc.determineShell(cmakePath) : false;
            const shell = (commandShell || undefined) ?? cmakeDriver.config.shell ?? undefined;
            this._process = proc.execute(cmakePath, args, this, { ...this.options, shell });
            const result: proc.ExecutionResult = await this._process.result;
            this._process = undefined;
            if (result.retc) {
                this.writeEmitter.fire(localize("build.finished.with.error", "{0} finished with error(s).", taskName) + endOfLine);
            } else if (result.stderr || (result.stdout && result.stdout.includes(": warning"))) {
                this.writeEmitter.fire(localize("build.finished.with.warnings", "{0} finished with warning(s).", taskName) + endOfLine);
            } else {
                this.writeEmitter.fire(localize("build.finished.successfully", "{0} finished successfully.", taskName) + endOfLine);
            }
            if (doCloseEmitter) {
                this.closeEmitter.fire(result.retc ?? 0);
            }
            return result.retc ?? 0;
        } catch {
            this.writeEmitter.fire(localize("build.finished.with.error", "{0} finished with error(s).", taskName) + endOfLine);
            if (doCloseEmitter) {
                this.closeEmitter.fire(-1);
            }
            return -1;
        }
    }

    private async runInstallTask(): Promise<any> {
        this.writeEmitter.fire(localize("install.started", "Install task started...") + endOfLine);

        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "install", useCMakePresets: String(project.useCMakePresets) });
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;

        if (cmakeDriver) {
            const installCmd = cmakeDriver.getCMakeInstallCommand();
            if (installCmd) {
                this.writeEmitter.fire(proc.buildCmdStr(installCmd.command, installCmd.args) + endOfLine);
            }
            const result: number | null = await cmakeDriver.install(this, /* isBuildCommand */ false);
            if (result === null || result === undefined) {
                this.writeEmitter.fire(localize('install.terminated', 'Install was terminated') + endOfLine);
                this.closeEmitter.fire(-1);
            } else if (result !== 0) {
                this.writeEmitter.fire(localize("install.finished.with.error", "Install finished with error(s).") + endOfLine);
                this.closeEmitter.fire(result);
            } else {
                this.writeEmitter.fire(localize('install.finished', 'Install finished successfully') + endOfLine);
                this.closeEmitter.fire(0);
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("install.failed", "Install failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
    }

    private async runTestTask(): Promise<any> {
        this.writeEmitter.fire(localize("test.started", "Test task started...") + endOfLine);

        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "test", useCMakePresets: String(project.useCMakePresets) });
        await this.correctTargets(project, CommandType.test);
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;

        if (cmakeDriver) {
            let testPreset: preset.TestPreset | undefined;
            this.preset = await this.resolvePresetName(this.preset, project.useCMakePresets, CommandType.test);
            if (this.preset) {
                testPreset = await project?.expandTestPresetbyName(this.preset);
                if (!testPreset) {
                    log.debug(localize("test.preset.not.found", 'Test preset not found.'));
                    this.writeEmitter.fire(localize("ctest.failed", "Test preset {0} not found. Test failed.", this.preset) + endOfLine);
                    this.closeEmitter.fire(-1);
                    return;
                }
            }
            const result: CommandResult | undefined = cmakeDriver ? await project?.runCTestCustomized(cmakeDriver, testPreset, this) : undefined;
            if (result === undefined) {
                this.writeEmitter.fire(localize('ctest.run.terminated', 'CTest run was terminated') + endOfLine);
                this.closeEmitter.fire(-1);
            } else {
                this.writeEmitter.fire(localize('ctest.finished', 'CTest finished') + endOfLine);
                this.closeEmitter.fire(0);
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("test.failed", "CTest run failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
    }

    private async runPackageTask(): Promise<any> {
        this.writeEmitter.fire(localize("package.started", "Package task started...") + endOfLine);

        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "package", useCMakePresets: String(project.useCMakePresets) });
        await this.correctTargets(project, CommandType.package);
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;

        if (cmakeDriver) {
            let packagePreset: preset.PackagePreset | undefined;
            this.preset = await this.resolvePresetName(this.preset, project.useCMakePresets, CommandType.package);
            if (this.preset) {
                packagePreset = await project?.expandPackagePresetbyName(this.preset);
                if (!packagePreset) {
                    log.debug(localize("package.preset.not.found", 'Package preset not found.'));
                    this.writeEmitter.fire(localize("cpack.failed", "Package preset {0} not found. CPack failed.", this.preset) + endOfLine);
                    this.closeEmitter.fire(-1);
                    return;
                }
            }
            const result: number | undefined = cmakeDriver ? await project?.runCPack(cmakeDriver, packagePreset, this) : undefined;
            if (result === undefined) {
                this.writeEmitter.fire(localize('cpack.run.terminated', 'CPack run was terminated') + endOfLine);
                this.closeEmitter.fire(-1);
            } else {
                this.writeEmitter.fire(localize('cpack.finished', 'CPack finished') + endOfLine);
                this.closeEmitter.fire(0);
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("cpack.failed", "CPack run failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
    }

    private async runWorkflowTask(): Promise<any> {
        this.writeEmitter.fire(localize("workflow.started", "Workflow task started...") + endOfLine);

        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "workflow", useCMakePresets: String(project.useCMakePresets) });
        await this.correctTargets(project, CommandType.workflow); // ?????
        const cmakeDriver: CMakeDriver | undefined = (await project?.getCMakeDriverInstance()) || undefined;

        if (cmakeDriver) {
            let workflowPreset: preset.WorkflowPreset | undefined;
            this.preset = await this.resolvePresetName(this.preset, project.useCMakePresets, CommandType.workflow);
            if (this.preset) {
                workflowPreset = await project?.expandWorkflowPresetbyName(this.preset);
                if (!workflowPreset) {
                    log.debug(localize("workflow.preset.not.found", 'Workflow preset not found.'));
                    this.writeEmitter.fire(localize("workflow.failed", "Workflow preset {0} not found. Workflow failed.", this.preset) + endOfLine);
                    this.closeEmitter.fire(-1);
                    return;
                }
            }
            const result: number | undefined = cmakeDriver ? await project?.runWorkflow(cmakeDriver, workflowPreset, this) : undefined;
            if (result === undefined) {
                this.writeEmitter.fire(localize('workflow.run.terminated', 'Workflow run was terminated') + endOfLine);
                this.closeEmitter.fire(-1);
            } else {
                this.writeEmitter.fire(localize('workflow.finished', 'Workflow finished') + endOfLine);
                this.closeEmitter.fire(0);
            }
        } else {
            log.debug(localize("cmake.driver.not.found", 'CMake driver not found.'));
            this.writeEmitter.fire(localize("workflow.failed", "Workflow run failed.") + endOfLine);
            this.closeEmitter.fire(-1);
        }
    }

    private async runCleanRebuildTask(): Promise<any> {
        const project: CMakeProject | undefined = await this.getProject();
        if (!project || !await this.isTaskCompatibleWithPresets(project)) {
            return;
        }
        telemetry.logEvent("task", { taskType: "cleanRebuild", useCMakePresets: String(project.useCMakePresets) });
        const cleanResult = await this.runBuildTask(CommandType.clean, false, false, project);
        if (cleanResult === 0) {
            await this.runBuildTask(CommandType.build, true, false, project);
        } else {
            this.closeEmitter.fire(cleanResult);
        }
    }
}

export const cmakeTaskProvider: CMakeTaskProvider = new CMakeTaskProvider();