cmakeDriver.ts

/**
 * Defines base class for CMake drivers
 */ /** */

import * as path from 'path';
import * as vscode from 'vscode';
import * as lodash from "lodash";

import { CMakeExecutable } from '@cmt/cmakeExecutable';
import * as codepages from '@cmt/codePageTable';
import { ConfigureCancelInformation, ConfigureTrigger, DiagnosticsConfiguration } from "@cmt/cmakeProject";
import { CompileCommand } from '@cmt/compilationDatabase';
import { ConfigurationReader, checkBuildOverridesPresent, checkConfigureOverridesPresent, checkTestOverridesPresent, checkPackageOverridesPresent, defaultNumJobs } from '@cmt/config';
import { CMakeBuildConsumer, CompileOutputConsumer } from '@cmt/diagnostics/build';
import { CMakeOutputConsumer } from '@cmt/diagnostics/cmake';
import { RawDiagnosticParser } from '@cmt/diagnostics/util';
import { ProgressMessage } from '@cmt/drivers/drivers';
import * as expand from '@cmt/expand';
import { CMakeGenerator, effectiveKitEnvironment, Kit, kitChangeNeedsClean, KitDetect, getKitDetect, getVSKitEnvironment, getVsKitPreferredGenerator } from '@cmt/kits/kit';
import * as logging from '@cmt/logging';
import paths from '@cmt/paths';
import { fs } from '@cmt/pr';
import * as proc from '@cmt/proc';
import rollbar from '@cmt/rollbar';
import * as telemetry from '@cmt/telemetry';
import * as util from '@cmt/util';
import { ConfigureArguments, VariantOption } from '@cmt/kits/variant';
import * as nls from 'vscode-nls';
import { majorVersionSemver, minorVersionSemver, parseTargetTriple, TargetTriple } from '@cmt/triple';
import * as preset from '@cmt/presets/preset';
import * as codeModel from '@cmt/drivers/codeModel';
import { Environment, EnvironmentUtils } from '@cmt/environmentVariables';
import { CMakeTask, CMakeTaskProvider, CustomBuildTaskTerminal } from '@cmt/cmakeTaskProvider';
import { getValue } from '@cmt/presets/preset';
import { CacheEntry, CMakeCache } from '@cmt/cache';
import { CMakeBuildRunner } from '@cmt/cmakeBuildRunner';
import { DebuggerInformation } from '@cmt/debug/cmakeDebugger/debuggerConfigureDriver';
import { onBuildSettingsChange, onTestSettingsChange, onPackageSettingsChange } from '@cmt/ui/util';
import { CodeModelKind } from '@cmt/drivers/cmakeFileApi';
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('driver');

export class NoGeneratorError extends Error {
    message: string = localize('no.usable.generator.found', 'No usable generator found.');
}

export enum CMakePreconditionProblems {
    ConfigureIsAlreadyRunning,
    BuildIsAlreadyRunning,
    NoSourceDirectoryFound,
    MissingCMakeListsFile
}

interface CompilerInfo {
    name: string;
    version: string;
}

export enum ConfigureResultType {
    NormalOperation,
    ForcedCancel,
    ConfigureInProgress,
    BuildInProgress,
    NoCache,
    NoConfigurePreset,
    Other
}

export interface ConfigureResult extends CommandResult {
    resultType: ConfigureResultType;
}

export type CMakePreconditionProblemSolver = (e: CMakePreconditionProblems, config?: ConfigurationReader) => Promise<boolean>;

function nullableValueToString(arg: any | null | undefined): string {
    return arg === null ? 'empty' : arg;
}

/**
 * Description of an executable CMake target, defined via `add_executable()`.
 */
export interface ExecutableTarget {
    /**
     * The name of the target.
     */
    name: string;
    /**
     * The absolute path to the build output.
     */
    path: string;
    /**
     * The install locations of the target.
     */
    isInstallTarget?: boolean;
    /**
     * The working directory for the debugger, from the DEBUGGER_WORKING_DIRECTORY target property.
     */
    debuggerWorkingDirectory?: string;
}

/**
 * A target with a name, but no output. Only used for targets that have a
 * folder property.
 */
export interface FolderTarget {
    type: 'folder';
    name: string;
}

/**
 * A target with a name, but no output. This may be created via `add_custom_command()`.
 */
export interface NamedTarget {
    type: 'named';
    name: string;
}

/**
 * A target with a name, path, type and folder.
 */
export interface RichTarget {
    type: 'rich';
    name: string;
    filepath: string;
    targetType: string;
    folder?: CodeModelKind.TargetObject;
    installPaths?: InstallPath[];
    debuggerWorkingDirectory?: string;
}

export type Target = NamedTarget | RichTarget;

export interface InstallPath {
    path: string;
    subPath: string;
}

/**
 * Base class for CMake drivers.
 *
 * CMake drivers are separated because different CMake version warrant different
 * communication methods. Older CMake versions need to be driven by the command
 * line, but newer versions may be controlled via CMake server, which provides
 * a much richer interface.
 *
 * This class defines the basis for what a driver must implement to work.
 */
/**
 * Compare a new generator name against a cached CMAKE_GENERATOR value.
 * Returns true when both are defined and differ (i.e. a mismatch that needs cleaning).
 * Pure function — no I/O — exported for direct unit testing.
 */
export function generatorMismatch(newGeneratorName: string | undefined, cachedGeneratorValue: string | undefined): boolean {
    if (!newGeneratorName || !cachedGeneratorValue) {
        return false;
    }
    return cachedGeneratorValue !== newGeneratorName;
}

export abstract class CMakeDriver implements vscode.Disposable {
    /**
     * Do the configuration process for the current project.
     *
     * @returns The exit code from CMake
     */
    protected abstract doConfigure(extra_args: string[], trigger?: ConfigureTrigger, consumer?: proc.OutputConsumer, showCommandOnly?: boolean, defaultConfigurePresetName?: string, configurePreset?: preset.ConfigurePreset | null, options?: proc.ExecutionOptions, debuggerInformation?: DebuggerInformation): Promise<number>;
    protected abstract doCacheConfigure(): Promise<number>;

    private _isConfiguredAtLeastOnce = false;
    protected get isConfiguredAtLeastOnce(): boolean {
        return this._isConfiguredAtLeastOnce;
    }

    protected _needsReconfigure = true;
    /**
     * Check if we need to reconfigure, such as if an important file has changed
     */
    public async checkNeedsReconfigure(): Promise<boolean> {
        return this._needsReconfigure;
    }

    protected async doPreCleanConfigure(): Promise<void> {
        return Promise.resolve();
    }

    protected doPreBuild(): Promise<boolean> {
        return Promise.resolve(true);
    }

    protected doPostBuild(): Promise<boolean> {
        return Promise.resolve(true);
    }

    /**
     * Check if using cached configuration is supported.
     */
    protected abstract get isCacheConfigSupported(): boolean;

    /**
     * Event registration for code model updates
     *
     * This event is fired after update of the code model, like after cmake configuration.
     */
    abstract onCodeModelChanged: vscode.Event<codeModel.CodeModelContent | null>;

    /**
     * List of targets known to CMake
     */
    abstract get targets(): Target[];

    abstract get codeModelContent(): codeModel.CodeModelContent | null;

    /**
     * List of executable targets known to CMake
     */
    abstract get executableTargets(): ExecutableTarget[];

    /**
     * List of unique targets known to CMake
     */
    abstract get uniqueTargets(): Target[];

    /**
     * List of all files (CMakeLists.txt and included .cmake files) used by CMake
     * during configuration
     */
    abstract get cmakeFiles(): string[];

    /**
     * Do any necessary disposal for the driver. For the CMake Server driver,
     * this entails shutting down the server process and closing the open pipes.
     *
     * The reason this is separate from the regular `dispose()` is so that the
     * driver shutdown may be `await`ed on to ensure full shutdown.
     */
    abstract asyncDispose(): Promise<void>;

    /**
     * Construct the driver. Concrete instances should provide their own creation
     * routines.
     */
    protected constructor(public cmake: CMakeExecutable,
        readonly config: ConfigurationReader,
        protected sourceDirUnexpanded: string, // The un-expanded original source directory path, where the CMakeLists.txt exists.
        private readonly isMultiProject: boolean,
        private readonly __workspaceFolder: string,
        readonly preconditionHandler: CMakePreconditionProblemSolver,
        private readonly usingFileApi: boolean = false
    ) {
        this.sourceDir = this.sourceDirUnexpanded;
    }

    /**
     * The source directory, where the root CMakeLists.txt lives.
     *
     * @note This is distinct from the config values, since we do variable
     * substitution.
     */
    protected __sourceDir = '';

    get sourceDir(): string {
        return this.__sourceDir;
    }

    protected set sourceDir(value: string) {
        this.__sourceDir = value;
    }

    /**
     * Dispose the driver. This disposes some things synchronously, but also
     * calls the `asyncDispose()` method to start any asynchronous shutdown.
     */
    dispose() {
        log.debug(localize('disposing.base.cmakedriver', 'Disposing base CMakeDriver'));
        for (const sub of [this._settingsSub, this._argsSub, this._envSub, this._buildArgsSub, this._buildEnvSub, this._testArgsSub, this._testEnvSub, this._packEnvSub, this._packArgsSub, this._generalEnvSub]) {
            sub.dispose();
        }
        rollbar.invokeAsync(localize('async.disposing.cmake.driver', 'Async disposing CMake driver'), () => this.asyncDispose());
    }

    /**
     * The environment variables required by the current kit
     */
    private _kitEnvironmentVariables = EnvironmentUtils.create();

    /**
     * Compute the environment variables that apply with substitutions by expansionOptions
     */
    async computeExpandedEnvironment(toExpand: Environment, expanded: Environment): Promise<Environment> {
        const env = EnvironmentUtils.create();
        const opts = this.expansionOptions;

        for (const entry of Object.entries(toExpand)) {
            env[entry[0]] = await expand.expandString(entry[1], { ...opts, envOverride: expanded });
        }

        return env;
    }

    /**
     * Get the environment variables that should be set at CMake-configure time.
     */
    async getConfigureEnvironment(configurePreset?: preset.ConfigurePreset | null, extraEnvironmentVariables?: Environment): Promise<Environment> {
        let envs;
        if (this.useCMakePresets) {
            envs = EnvironmentUtils.create(configurePreset ? configurePreset.environment : this._configurePreset?.environment);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.configureEnvironment, envs)]);
        } else {
            envs = this._kitEnvironmentVariables;
            /* NOTE: By mergeEnvironment one by one to enable expanding self containd variable such as PATH properly */
            /* If configureEnvironment and environment both configured different PATH, doing this will preserve them all */
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.configureEnvironment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this._variantEnv, envs)]);
        }
        if (extraEnvironmentVariables) {
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(extraEnvironmentVariables, envs)]);
        }
        return envs;
    }

    /**
     * Get the environment variables that should be set at CMake-build time.
     */
    async getCMakeBuildCommandEnvironment(in_env?: Environment): Promise<Environment> {
        if (this.useCMakePresets) {
            let envs = EnvironmentUtils.merge([in_env, this._buildPreset?.environment]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.buildEnvironment, envs)]);
            return envs;
        } else {
            let envs = EnvironmentUtils.merge([in_env, this._kitEnvironmentVariables]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.buildEnvironment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this._variantEnv, envs)]);
            return envs;
        }
    }

    /**
     * Get the environment variables that should be set at CTest and running program time.
     */
    async getCTestCommandEnvironment(): Promise<Environment> {
        if (this.useCMakePresets) {
            let envs = EnvironmentUtils.create(this._testPreset?.environment);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.testEnvironment, envs)]);

            if (this.useCMakePresets && this.testPreset !== null && checkTestOverridesPresent(this.config)) {
                log.info(localize('test.with.overrides', 'NOTE: You are testing with preset {0}, but there are some overrides being applied from your VS Code settings.', this.testPreset.displayName ?? this.testPreset.name));
            }

            return envs;
        } else {
            let envs = this._kitEnvironmentVariables;
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.testEnvironment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this._variantEnv, envs)]);
            return envs;
        }
    }

    /**
     * Get the environment variables that should be set at CPack and packaging time.
     */
    async getCPackCommandEnvironment(): Promise<Environment> {
        if (this.useCMakePresets) {
            let envs = EnvironmentUtils.create(this._packagePreset?.environment);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.cpackEnvironment, envs)]);

            if (this.useCMakePresets && this.packagePreset !== null && checkPackageOverridesPresent(this.config)) {
                log.info(localize('package.with.overrides', 'NOTE: You are packaging with preset {0}, but there are some overrides being applied from your VS Code settings.', this.packagePreset.displayName ?? this.packagePreset.name));
            }

            return envs;
        } else {
            let envs = this._kitEnvironmentVariables;
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.environment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this.config.cpackEnvironment, envs)]);
            envs = EnvironmentUtils.merge([envs, await this.computeExpandedEnvironment(this._variantEnv, envs)]);
            return envs;
        }
    }

    get onProgress(): vscode.Event<ProgressMessage> {
        return (_cb: (ev: ProgressMessage) => any) => new util.DummyDisposable();
    }

    /**
     * The current Kit. Starts out `null`, but once set, is never `null` again.
     * We do some separation here to protect ourselves: The `_baseKit` property
     * is `private`, so derived classes cannot change it, except via
     * `_setBaseKit`, which only allows non-null kits. This prevents the derived
     * classes from resetting the kit back to `null`.
     */
    private _kit: Kit | null = null;

    get kit(): Kit | null {
        return this._kit;
    }

    private _kitDetect: KitDetect | null = null;

    private _useCMakePresets: boolean = true;

    get useCMakePresets(): boolean {
        return this._useCMakePresets;
    }

    get configurePresetArchitecture(): string | preset.ValueStrategy | undefined {
        return this._configurePreset?.architecture;
    }

    get configurePresetToolset(): string | preset.ValueStrategy | undefined {
        return this._configurePreset?.toolset;
    }

    private _configurePreset: preset.ConfigurePreset | null = null;

    private _buildPreset: preset.BuildPreset | null = null;

    private _testPreset: preset.TestPreset | null = null;

    get testPreset(): preset.TestPreset | null {
        return this._testPreset;
    }

    private _packagePreset: preset.PackagePreset | null = null;

    get packagePreset(): preset.PackagePreset | null {
        return this._packagePreset;
    }

    private _workflowPreset: preset.WorkflowPreset | null = null;

    get workflowPreset(): preset.WorkflowPreset | null {
        return this._workflowPreset;
    }

    /**
     * Get the vscode root workspace folder.
     *
     * @returns Returns the vscode root workspace folder. Returns `null` if no folder is open or the folder uri is not a
     * `file://` scheme.
     */
    get workspaceFolder() {
        return this.__workspaceFolder;
    }

    protected variantKeywordSettings: Map<string, string> | null = null;

    /**
     * The options that will be passed to `expand.expandString` for this driver.
     */
    get expansionOptions(): expand.ExpansionOptions {
        const ws_root = util.lightNormalizePath(this.workspaceFolder || '.');
        const target: Partial<TargetTriple> = parseTargetTriple(this._kitDetect?.triple ?? '') ?? {};
        const version = this._kitDetect?.version ?? '0.0';

        // Fill in default replacements
        const vars: expand.KitContextVars = {
            buildKit: this._kit ? this._kit.name : '__unknownkit__',
            buildType: this.currentBuildType,
            generator: this.generatorName || 'null',
            workspaceFolder: ws_root,
            workspaceFolderBasename: path.basename(ws_root),
            workspaceHash: util.makeHashString(ws_root),
            workspaceRoot: ws_root,
            workspaceRootFolderName: path.basename(ws_root),
            userHome: paths.userHome,
            buildKitVendor: this._kitDetect?.vendor ?? '__unknown_vendor__',
            buildKitTriple: this._kitDetect?.triple ?? '__unknown_triple__',
            buildKitVersion: version,
            buildKitHostOs: process.platform,
            buildKitTargetOs: target.targetOs ?? '__unknown_target_os__',
            buildKitTargetArch: target.targetArch ?? '__unknown_target_arch__',
            buildKitVersionMajor: majorVersionSemver(version),
            buildKitVersionMinor: minorVersionSemver(version),
            sourceDir: this.sourceDir,
            // DEPRECATED EXPANSION: Remove this in the future:
            projectName: 'ProjectName'
        };

        // Update Variant replacements
        const variantVars: { [key: string]: string } = {};
        if (this.variantKeywordSettings) {
            // allows to expansion of variant option keyword and replace it by the variant option short name
            this.variantKeywordSettings.forEach((value: string, key: string) => variantVars[key] = value);
        }

        return { vars, variantVars };
    }

    static sourceDirExpansionOptions(workspaceFolderFspath: string | null): expand.ExpansionOptions {
        const ws_root = util.lightNormalizePath(workspaceFolderFspath || '.');

        // Fill in default replacements
        const vars: expand.MinimalPresetContextVars = {
            generator: 'generator',
            workspaceFolder: ws_root,
            workspaceFolderBasename: path.basename(ws_root),
            sourceDir: '${sourceDir}',
            workspaceHash: util.makeHashString(ws_root),
            workspaceRoot: ws_root,
            workspaceRootFolderName: path.basename(ws_root),
            userHome: paths.userHome
        };

        return { vars };
    }

    getEffectiveSubprocessEnvironment(opts?: proc.ExecutionOptions): Environment {
        const cur_env = process.env;
        const kit_env = (this.config.ignoreKitEnv) ? EnvironmentUtils.create() : this._kitEnvironmentVariables;
        const cmakeToolsEnv = EnvironmentUtils.create({ VSCODE_CMAKE_TOOLS: "1" });
        return EnvironmentUtils.merge([cur_env, kit_env, cmakeToolsEnv, opts?.environment]);
    }

    executeCommand(command: string, args?: string[], consumer?: proc.OutputConsumer, options?: proc.ExecutionOptions): proc.Subprocess {
        const environment = this.getEffectiveSubprocessEnvironment(options);
        // On Windows, command-type-specific detection (e.g. .cmd → cmd, .ps1 → powershell)
        // must take precedence over config.shell to avoid routing commands through
        // an incompatible shell (e.g. .cmd files through Git Bash).
        const commandShell = process.platform === 'win32' ? proc.determineShell(command) : false;
        const shell = options?.shell ?? (commandShell || undefined) ?? this.config.shell ?? undefined;
        const exec_options = { ...options, environment, shell };
        return proc.execute(command, args, consumer, exec_options);
    }

    /**
     * Launch the given compilation command in an embedded terminal.
     * @param cmd The compilation command from a compilation database to run
     */
    async runCompileCommand(cmd: CompileCommand): Promise<vscode.Terminal> {
        const env = await this.getCMakeBuildCommandEnvironment();

        if (this.useCMakePresets && this._buildPreset && checkBuildOverridesPresent(this.config)) {
            log.info(localize('compile.with.overrides',
                'NOTE: You are compiling with preset {0}, but there are some overrides being applied from your VS Code settings.',
                this._buildPreset.displayName ?? this._buildPreset.name));
        }

        const args = cmd.arguments;
        if (!args || args.length === 0) {
            // Fallback: no structured args available — send the raw command string via terminal.
            // This path should never be reached because CompilationDatabase always populates arguments.
            const term = vscode.window.createTerminal({
                name: localize('file.compilation', 'File Compilation'),
                cwd: cmd.directory,
                env
            });
            term.show();
            term.sendText(cmd.command, true);
            return term;
        }

        // Spawn the compiler directly via proc.execute() to avoid the PTY 4096-byte
        // input-buffer truncation bug (https://github.com/microsoft/vscode-cmake-tools/issues/4836).
        // We open a Pseudoterminal so output appears in the Terminal panel without any
        // shell intermediary — args are passed as an array straight to child_process.spawn.
        const writeEmitter = new vscode.EventEmitter<string>();
        const closeEmitter = new vscode.EventEmitter<number>();
        let activeProcess: proc.Subprocess | undefined;
        let processExitCode: number | undefined;

        const pty: vscode.Pseudoterminal = {
            onDidWrite: writeEmitter.event,
            onDidClose: closeEmitter.event,
            open: () => {
                const executable = args[0];
                const execArgs = args.slice(1);
                writeEmitter.fire(proc.buildCmdStr(executable, execArgs) + '\r\n');
                activeProcess = proc.execute(executable, execArgs, {
                    output: (line: string) => writeEmitter.fire(line + '\r\n'),
                    error: (line: string) => writeEmitter.fire(line + '\r\n')
                }, { cwd: cmd.directory, environment: env });
                activeProcess.result.then(result => {
                    activeProcess = undefined;
                    const retc = result.retc ?? 0;
                    processExitCode = retc;
                    if (retc !== 0) {
                        writeEmitter.fire(localize('compile.finished.with.error',
                            'Compilation finished with error(s).') + '\r\n');
                    } else {
                        writeEmitter.fire(localize('compile.finished.successfully',
                            'Compilation finished successfully.') + '\r\n');
                    }
                    // Keep terminal open so user can see the output. Only close when
                    // user presses a key or closes the terminal manually.
                    // See https://github.com/microsoft/vscode-cmake-tools/issues/4896
                    writeEmitter.fire(localize('press.any.key.to.close',
                        'Press any key to close the terminal...') + '\r\n');
                }, (e: any) => {
                    activeProcess = undefined;
                    // Use positive exit code per VS Code PTY API convention
                    processExitCode = 1;
                    writeEmitter.fire((e?.message ?? String(e)) + '\r\n');
                    writeEmitter.fire(localize('press.any.key.to.close',
                        'Press any key to close the terminal...') + '\r\n');
                });
            },
            close: () => {
                // Terminate the compiler process if the user closes the terminal
                // while compilation is still running, to avoid orphaned processes.
                if (activeProcess?.child) {
                    void util.termProc(activeProcess.child);
                    activeProcess = undefined;
                }
            },
            handleInput: (_data: string) => {
                // Close the terminal when the user presses any key after the
                // process has finished. If the process is still running, ignore input.
                if (processExitCode !== undefined) {
                    closeEmitter.fire(processExitCode);
                }
            }
        };

        const term = vscode.window.createTerminal({
            name: localize('file.compilation', 'File Compilation'),
            pty
        });
        term.show();
        return term;
    }

    /**
     * Remove the prior CMake configuration files.
     */
    protected async _cleanPriorConfiguration() {
        const build_dir = this.binaryDir;
        const cache = this.cachePath;
        const cmake_files = this.config.deleteBuildDirOnCleanConfigure ? build_dir : path.join(build_dir, 'CMakeFiles');
        if (await fs.exists(cache)) {
            log.info(localize('removing', 'Removing {0}', encodeURI(cache)));
            try {
                await fs.unlink(cache);
            } catch {
                log.error(localize('unlink.failed', 'Failed to remove cache file {0}', this.cachePath));
            }
        }
        if (await fs.exists(cmake_files)) {
            log.info(localize('removing', 'Removing {0}', encodeURI(cmake_files)));
            await fs.rmdir(cmake_files);
        }
    }

    /**
     * Check if the generator to be used differs from what is cached in CMakeCache.txt.
     */
    protected async _hasGeneratorChanged(newGeneratorName: string | undefined): Promise<boolean> {
        if (!newGeneratorName) {
            return false;
        }
        const cachePath = this.cachePath;
        if (!await fs.exists(cachePath)) {
            return false;
        }
        const cache = await CMakeCache.fromPath(cachePath);
        const cachedGenerator = cache.get('CMAKE_GENERATOR');
        if (generatorMismatch(newGeneratorName, cachedGenerator?.value)) {
            log.info(localize('generator.changed', 'Generator changed from {0} to {1}; cleaning prior configuration', cachedGenerator!.value, newGeneratorName));
            return true;
        }
        return false;
    }

    /**
     * Remove the entire build directory.
     */
    protected async _cleanBuildDirectory() {
        const build_dir = this.binaryDir;
        if (await fs.exists(build_dir)) {
            log.info(localize('removing', 'Removing {0}', encodeURI(build_dir)));
            await fs.rmdir(build_dir);
        }
    }

    /**
     * Change the current configure preset. This lets the driver reload, if necessary.
     * @param configurePreset The new configure preset
     */
    async setConfigurePreset(configurePreset: preset.ConfigurePreset | null): Promise<void> {
        if (configurePreset) {
            log.info(localize('switching.to.config.preset', 'Switching to configure preset: {0}', configurePreset.name));

            // Skip the full doSetConfigurePreset (which unconditionally sets
            // _needsReconfigure = true) when the expanded preset hasn't changed
            // and the CMake cache still exists on disk.
            // This avoids unnecessary reconfigures when reapplyPresets() is called
            // but preset files on disk are identical (see #4502).
            if (this._configurePreset && lodash.isEqual(configurePreset, this._configurePreset) && await fs.exists(this.cachePath)) {
                return;
            }

            const newBinaryDir = configurePreset.binaryDir;
            const needs_clean = this.binaryDir === newBinaryDir && preset.configurePresetChangeNeedsClean(configurePreset, this._configurePreset);
            await this.doSetConfigurePreset(needs_clean, async () => {
                await this._setConfigurePreset(configurePreset);
            });
        } else {
            log.info(localize('unsetting.config.preset', 'Unsetting configure preset'));

            await this.doSetConfigurePreset(false, async () => {
                await this._setConfigurePreset(configurePreset);
            });
        }
    }

    private async _setConfigurePreset(configurePreset: preset.ConfigurePreset | null): Promise<void> {
        this._configurePreset = configurePreset;
        log.debug(localize('cmakedriver.config.preset.set.to', 'CMakeDriver configure preset set to {0}', configurePreset?.name || null));

        this._binaryDir = configurePreset?.binaryDir || '';

        if (configurePreset) {
            if (configurePreset.generator) {
                this._generator = {
                    name: configurePreset.generator,
                    platform: configurePreset.architecture ? getValue(configurePreset.architecture) : undefined,
                    toolset: configurePreset.toolset ? getValue(configurePreset.toolset) : undefined
                };
            } else {
                log.debug(localize('no.generator', 'No generator specified'));
            }
        } else {
            this._generator = null;
        }
    }

    /**
     * Change the current build preset
     * @param buildPreset The new build preset
     */
    async setBuildPreset(buildPreset: preset.BuildPreset | null): Promise<void> {
        if (buildPreset) {
            log.info(localize('switching.to.build.preset', 'Switching to build preset: {0}', buildPreset.name));
        } else {
            log.info(localize('unsetting.build.preset', 'Unsetting build preset'));
        }

        await this.doSetBuildPreset(async () => {
            await this._setBuildPreset(buildPreset);
        });
    }

    private async _setBuildPreset(buildPreset: preset.BuildPreset | null): Promise<void> {
        this._buildPreset = buildPreset;
        log.debug(localize('cmakedriver.build.preset.set.to', 'CMakeDriver build preset set to {0}', buildPreset?.name || null));
    }

    /**
     * Change the current test preset
     * @param testPreset The new test preset
     */
    async setTestPreset(testPreset: preset.TestPreset | null): Promise<void> {
        if (testPreset) {
            log.info(localize('switching.to.test.preset', 'Switching to test preset: {0}', testPreset.name));
        } else {
            log.info(localize('unsetting.test.preset', 'Unsetting test preset'));
        }

        await this.doSetTestPreset(async () => {
            await this._setTestPreset(testPreset);
        });
    }

    private async _setTestPreset(testPreset: preset.TestPreset | null): Promise<void> {
        this._testPreset = testPreset;
        log.debug(localize('cmakedriver.test.preset.set.to', 'CMakeDriver test preset set to {0}', testPreset?.name || null));
    }

    /**
     * Change the current package preset
     * @param packagePreset The new package preset
     */
    async setPackagePreset(packagePreset: preset.PackagePreset | null): Promise<void> {
        if (packagePreset) {
            log.info(localize('switching.to.package.preset', 'Switching to package preset: {0}', packagePreset.name));
        } else {
            log.info(localize('unsetting.package.preset', 'Unsetting package preset'));
        }

        await this.doSetPackagePreset(async () => {
            await this._setPackagePreset(packagePreset);
        });
    }

    private async _setPackagePreset(packagePreset: preset.PackagePreset | null): Promise<void> {
        this._packagePreset = packagePreset;
        log.debug(localize('cmakedriver.package.preset.set.to', 'CMakeDriver package preset set to {0}', packagePreset?.name || null));
    }

    /**
     * Change the current workflow preset
     * @param workflowPreset The new workflow preset
     */
    async setWorkflowPreset(workflowPreset: preset.WorkflowPreset | null): Promise<void> {
        if (workflowPreset) {
            log.info(localize('switching.to.workflow.preset', 'Switching to workflow preset: {0}', workflowPreset.name));
        } else {
            log.info(localize('unsetting.workflow.preset', 'Unsetting workflow preset'));
        }

        await this.doSetWorkflowPreset(async () => {
            await this._setWorkflowPreset(workflowPreset);
        });
    }

    private async _setWorkflowPreset(workflowPreset: preset.WorkflowPreset | null): Promise<void> {
        this._workflowPreset = workflowPreset;
        log.debug(localize('cmakedriver.workflow.preset.set.to', 'CMakeDriver workflow preset set to {0}', workflowPreset?.name || null));
    }

    /**
     * Ensure that variables are up to date (e.g. sourceDirectory, buildDirectory, env, installDirectory)
     */
    async refreshSettings() {
        await this._refreshExpansions();
    }

    /**
     * Change the current kit. This lets the driver reload, if necessary.
     * @param kit The new kit
     */
    async setKit(kit: Kit, preferredGenerators: CMakeGenerator[]): Promise<void> {
        if (this.useCMakePresets) {
            log.info(localize('skip.set.kit', 'Using preset, skip setting kit: {0}', kit.name));
            return;
        }

        let switch_to_kit_info = localize('switching.to.kit', 'Switching to kit: {0}', kit.name);
        if (Array.isArray(kit.visualStudioArguments)) {
            switch_to_kit_info += ` visualStudioArguments: ${JSON.stringify(kit.visualStudioArguments)}`;
        }
        log.info(switch_to_kit_info);

        const oldBinaryDir = this.binaryDir;
        const needsCleanIfKitChange = kitChangeNeedsClean(kit, this._kit);
        await this.doSetKit(async () => {
            await this._setKit(kit, preferredGenerators);
            await this._refreshExpansions();
            const scope = this.workspaceFolder ? vscode.Uri.file(this.workspaceFolder) : undefined;
            const newBinaryDir = util.lightNormalizePath(await expand.expandString(this.config.buildDirectory(this.isMultiProject, scope), this.expansionOptions));
            const generatorChanged = await this._hasGeneratorChanged(this._generator?.name);
            if ((needsCleanIfKitChange || generatorChanged) && (newBinaryDir === oldBinaryDir)) {
                await this._cleanPriorConfiguration();
            }
        });
    }

    private async _setKit(kit: Kit, preferredGenerators: CMakeGenerator[]): Promise<void> {
        this._kit = Object.seal({ ...kit });
        this._kitDetect = await getKitDetect(this._kit);
        log.debug(localize('cmakedriver.kit.set.to', 'CMakeDriver Kit set to {0}', kit.name));
        this._kitEnvironmentVariables = await effectiveKitEnvironment(kit, this.expansionOptions);

        // Place a kit preferred generator at the front of the list.
        if (kit.preferredGenerator) {
            preferredGenerators.unshift(kit.preferredGenerator);
        }

        // If no preferred generator is defined by the current kit or the user settings,
        // it's time to consider the defaults.
        if (preferredGenerators.length === 0
            && !(this.usingFileApi
                && (this.cmake.version && util.versionGreaterOrEquals(this.cmake.version, this.cmake.minimalDefaultGeneratorVersion))
                && kit.name === "__unspec__")
        ) {
            preferredGenerators.push({ name: "Ninja" });
            preferredGenerators.push({ name: "Unix Makefiles" });
        }

        // For VS kits that don't have preferredGenerator (e.g., scanned before
        // a VS version was added), derive the VS generator as a last-resort
        // fallback so it is tried only after Ninja / Unix Makefiles.
        if (!kit.preferredGenerator && kit.visualStudio) {
            const derived = await getVsKitPreferredGenerator(kit);
            if (derived) {
                preferredGenerators.push(derived);
            }
        }

        // Use the "best generator" logic only if the user did not define a particular
        // generator to be used via the `cmake.generator` setting.
        if (this.config.generator) {
            this._generator = {
                name: this.config.generator,
                platform: this.config.platform || undefined,
                toolset: this.config.toolset || undefined
            };
        } else {
            this._generator = await this.findBestGenerator(preferredGenerators);
        }
    }

    protected abstract doSetConfigurePreset(needsClean: boolean, cb: () => Promise<void>): Promise<void>;
    protected abstract doSetBuildPreset(cb: () => Promise<void>): Promise<void>;
    protected abstract doSetTestPreset(cb: () => Promise<void>): Promise<void>;
    protected abstract doSetPackagePreset(cb: () => Promise<void>): Promise<void>;
    protected abstract doSetWorkflowPreset(cb: () => Promise<void>): Promise<void>;

    protected abstract doSetKit(cb: () => Promise<void>): Promise<void>;

    protected get generator(): CMakeGenerator | null {
        return this._generator;
    }
    protected _generator: CMakeGenerator | null = null;
    /**
     * The CMAKE_BUILD_TYPE to use
     */
    private _variantBuildType: string = 'Debug';

    /**
     * The arguments to pass to CMake during a configuration according to the current variant
     */
    private _variantConfigureSettings: ConfigureArguments = {};

    /**
     * Determine if we set BUILD_SHARED_LIBS to TRUE or FALSE
     */
    private _variantLinkage: ('static' | 'shared' | null) = null;

    /**
     * Environment variables defined by the current variant
     */
    private _variantEnv: Environment = EnvironmentUtils.create();

    /**
     * Change the current options from the variant.
     * @param opts The new options
     * @param keywordSetting Variant Keywords for identification of a variant option
     */
    async setVariant(opts: VariantOption, keywordSetting: Map<string, string> | null) {
        log.debug(localize('setting.new.variant', 'Setting new variant {0}', opts.short || '(Unnamed)'));
        this._variantBuildType = opts.buildType || this._variantBuildType;
        this._variantConfigureSettings = opts.settings || this._variantConfigureSettings;
        this._variantLinkage = opts.linkage || null;
        this._variantEnv = EnvironmentUtils.create(opts.env);
        this.variantKeywordSettings = keywordSetting || null;
        await this._refreshExpansions();
    }

    protected doRefreshExpansions(cb: () => Promise<void>): Promise<void> {
        return cb();
    }

    private async _refreshExpansions(configurePreset?: preset.ConfigurePreset | null) {
        return this.doRefreshExpansions(async () => {
            this.sourceDir = await util.normalizeAndVerifySourceDir(this.sourceDirUnexpanded, CMakeDriver.sourceDirExpansionOptions(this.workspaceFolder));

            const opts = this.expansionOptions;
            opts.envOverride = await this.getConfigureEnvironment(configurePreset);

            const installPrefix = this.config.installPrefix;
            if (installPrefix) {
                this._installDir = util.lightNormalizePath(await expand.expandString(installPrefix, opts));
            }

            if (!this.useCMakePresets) {
                const scope = this.workspaceFolder ? vscode.Uri.file(this.workspaceFolder) : undefined;
                this._binaryDir = util.lightNormalizePath(await expand.expandString(this.config.buildDirectory(this.isMultiProject, scope), opts));
            }
        });
    }

    /**
     * Path to where the root CMakeLists.txt file should be
     */
    get mainListFile(): string {
        const file = path.join(this.sourceDir, 'CMakeLists.txt');
        return util.lightNormalizePath(file);
    }

    /**
     * Directory where build output is stored.
     */
    get binaryDir(): string {
        return this._binaryDir;
    }
    private _binaryDir = '';

    /**
     * Directory where the targets will be installed.
     */
    private get installDir(): string | null {
        return this._installDir;
    }
    private _installDir: string | null = null;

    /**
     * @brief Get the path to the CMakeCache file in the build directory
     */
    get cachePath(): string {
        // TODO: Cache path can change if build dir changes at runtime
        const file = path.join(this.binaryDir, 'CMakeCache.txt');
        return util.lightNormalizePath(file);
    }

    /**
     * Get the current build type, according to the current selected preset or variant.
     *
     * This is the value passed to CMAKE_BUILD_TYPE or --config for multiconf
     */
    get currentBuildType(): string {
        if (this.useCMakePresets) {
            if ((this.isMultiConfig || this.isMultiConfFast) && this._buildPreset?.configuration) {
                return this._buildPreset.configuration;
            }
            const buildType = this._configurePreset?.cacheVariables?.['CMAKE_BUILD_TYPE'];
            if (util.isString(buildType)) {
                return buildType;
            } else if (buildType && typeof buildType === 'object' && util.isString(buildType.value)) {
                return buildType.value;
            }
            return 'Debug'; // Default to debug
        } else {
            return this._variantBuildType;
        }
    }

    private _isMultiConfig: boolean = false;
    get isMultiConfig(): boolean {
        return this._isMultiConfig;
    }
    set isMultiConfig(v: boolean) {
        this._isMultiConfig = v;
    }

    get isMultiConfFast(): boolean {
        return this.generatorName ? util.isMultiConfGeneratorFast(this.generatorName) : false;
    }

    /**
     * Get the name of the current CMake generator, or `null` if we have not yet
     * configured the project.
     */
    abstract get generatorName(): string | null;

    get allTargetName(): string {
        const gen = this.generatorName;
        if (gen && (gen.includes('Visual Studio') || gen.toLowerCase().includes('xcode'))) {
            return 'ALL_BUILD';
        } else {
            return 'all';
        }
    }

    /**
     * The ID of the current compiler, as best we can tell
     */
    get compilerID(): string | null {
        const entries = this.cmakeCacheEntries;
        const languages = ['CXX', 'C', 'CUDA'];
        for (const lang of languages) {
            const entry = entries.get(`CMAKE_${lang}_COMPILER`);
            if (!entry) {
                continue;
            }
            const compiler = entry.value as string;
            if (compiler.endsWith('cl.exe')) {
                return 'MSVC';
            } else if (/g(cc|\+\+)/.test(compiler)) {
                return 'GNU';
            } else if (/clang(\+\+)?[^/]*/.test(compiler)) {
                return 'Clang';
            }
        }
        return null;
    }

    get linkerID(): string | null {
        const entries = this.cmakeCacheEntries;
        const entry = entries.get('CMAKE_LINKER');
        if (!entry) {
            return null;
        }
        const linker = entry.value as string;
        if (linker.endsWith('link.exe')) {
            return 'MSVC';
        } else if (linker.endsWith('ld')) {
            return 'GNU';
        }
        return null;
    }

    get cmakePathFromPreset(): string | undefined {
        if (!this.useCMakePresets) {
            return;
        }
        return this._configurePreset?.cmakeExecutable;
    }

    public async testHaveCommand(program: string, args: string[] = ['--version']): Promise<boolean> {
        const child = this.executeCommand(program, args, undefined, { silent: true });
        try {
            const result = await child.result;
            log.trace(localize('command.version.test.return.code', '{0} returned code {1}', `"${program} ${args.join(' ')}"`, nullableValueToString(result.retc)));
            return result.retc === 0;
        } catch (e: any) {
            const e2: NodeJS.ErrnoException = e;
            log.debug(localize('command.version.test.return.code', '{0} returned code {1}', `"${program} ${args.join(' ')}"`, nullableValueToString(e2.code)));
            if (e2.code === 'ENOENT') {
                return false;
            }
            throw e;
        }
    }

    isCommonGenerator(genName: string): boolean {
        return genName === 'Ninja' || genName === 'Ninja Multi-Config' ||
            genName === 'MinGW Makefiles' || genName === 'NMake Makefiles' ||
            genName === 'Unix Makefiles' || genName === 'MSYS Makefiles' ||
            genName === 'FASTBuild';
    }

    /**
     * Picks the best generator to use on the current system
     */
    async findBestGenerator(preferredGenerators: CMakeGenerator[]): Promise<CMakeGenerator | null> {
        log.debug(localize('trying.to.detect.generator', 'Trying to detect generator supported by system'));
        const platform = process.platform;

        for (const gen of preferredGenerators) {
            const gen_name = gen.name;
            const generator_present = await (async (): Promise<boolean> => {
                if (gen_name === 'Ninja' || gen_name === 'Ninja Multi-Config') {
                    return await this.testHaveCommand('ninja') || this.testHaveCommand('ninja-build');
                }
                if (gen_name === 'FASTBuild') {
                    return this.testHaveCommand('fbuild');
                }
                if (gen_name === 'MinGW Makefiles') {
                    return platform === 'win32' && this.testHaveCommand('mingw32-make');
                }
                if (gen_name === 'NMake Makefiles') {
                    return platform === 'win32' && this.testHaveCommand('nmake', ['/?']);
                }
                if (gen_name === 'Unix Makefiles') {
                    return this.testHaveCommand('make');
                }
                if (gen_name === 'MSYS Makefiles') {
                    return platform === 'win32' && this.testHaveCommand('make');
                }
                return false;
            })();
            if (!generator_present) {
                const vsMatch = /^(Visual Studio \d{2} \d{4})($|\sWin64$|\sARM$)/.exec(gen_name);
                if (platform === 'win32' && vsMatch) {
                    let possibleArchitecture = vsMatch[2].trim();
                    if (possibleArchitecture && possibleArchitecture === "Win64") {
                        possibleArchitecture = "x64";
                    }
                    return {
                        name: vsMatch[1],
                        platform: gen.platform || possibleArchitecture,
                        toolset: gen.toolset
                    };
                }
                if (gen_name.toLowerCase().startsWith('xcode') && platform === 'darwin') {
                    return gen;
                }

                // If it is not a common generator that we can find, but it is a known cmake generator (cmakeGenerators), return it.
                // The only caveat is that we should not return a Visual Studio generator on non-Windows platforms.
                if (this.cmakeGenerators.indexOf(gen_name) >= 0 && !this.isCommonGenerator(gen_name) && !(gen_name.startsWith("Visual Studio") && platform !== "win32")) {
                    return gen;
                }
                continue;
            } else {
                return gen;
            }
        }
        return null;
    }

    private isConfigInProgress: boolean = false;

    public configOrBuildInProgress(): boolean {
        return this.configInProgress() || this.cmakeBuildRunner.isBuildInProgress();
    }

    public configInProgress(): boolean {
        return this.isConfigInProgress;
    }

    /**
     * Perform a clean configure. Deletes cached files before running the config
     * @param consumer The output consumer
     */
    public async cleanConfigure(trigger: ConfigureTrigger, extra_args: string[], consumer?: proc.OutputConsumer, cancelInformation?: ConfigureCancelInformation, debuggerInformation?: DebuggerInformation): Promise<ConfigureResult> {
        if (this.isConfigInProgress) {
            await this.preconditionHandler(CMakePreconditionProblems.ConfigureIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.ForcedCancel };
        }
        if (this.cmakeBuildRunner.isBuildInProgress()) {
            await this.preconditionHandler(CMakePreconditionProblems.BuildIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.ConfigureInProgress };
        }
        this.isConfigInProgress = true;
        await this.doPreCleanConfigure();
        this.isConfigInProgress = false;

        return this.configure(trigger, extra_args, consumer, cancelInformation, debuggerInformation);
    }

    /**
     * Perform a full clean configure. Deletes the entire build directory before running the config.
     * @param consumer The output consumer
     */
    public async fullCleanConfigure(trigger: ConfigureTrigger, extra_args: string[], consumer?: proc.OutputConsumer, cancelInformation?: ConfigureCancelInformation): Promise<ConfigureResult> {
        if (this.isConfigInProgress) {
            await this.preconditionHandler(CMakePreconditionProblems.ConfigureIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.ForcedCancel };
        }
        if (this.cmakeBuildRunner.isBuildInProgress()) {
            await this.preconditionHandler(CMakePreconditionProblems.BuildIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.ConfigureInProgress };
        }
        this.isConfigInProgress = true;
        await this._cleanBuildDirectory();
        this.isConfigInProgress = false;

        return this.configure(trigger, extra_args, consumer, cancelInformation);
    }

    async testCompilerVersion(program: string, cwd: string, arg: string | undefined, regexp: RegExp, captureGroup: number): Promise<string | undefined> {
        const args = [];
        if (arg) {
            args.push(arg);
        }
        const child = this.executeCommand(program, args, undefined, { silent: true, cwd });
        try {
            const result = await child.result;
            log.trace(localize('command.version.test.return.code', '{0} returned code {1}', `"${program} ${arg}"`, nullableValueToString(result.retc)));
            // Various compilers will output into stdout, others in stderr.
            // It's safe to concat them into one string to search in, since it's enough to analyze
            // the first match (stderr can't print a different version than stdout).
            const versionLine = result.stderr.concat(result.stdout);
            const match = regexp.exec(versionLine);
            // Make sure that all the regexp in compilerAllowList are written in a way that match[2] is the indeed the version.
            // This number may change in future as we add more cases and index 2 might be difficult to ensure for all of them.
            return match ? match[captureGroup] : "error";
        } catch (e: any) {
            const e2: NodeJS.ErrnoException = e;
            log.debug(localize('compiler.version.return.code', '{0} returned code {1}', `"${program} ${arg}"`, nullableValueToString(e2.code)));
            return "error";
        }
    }

    private readonly compilerAllowList = [
        // Most common version output (gcc and family):
        //     gcc -v: gcc version 9.3.0 (Ubuntu 9.3.0-17ubuntu1~20.04)
        {
            name: "gcc",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "cc",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "chesscc",
            versionSwitch: "--version",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "g++",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "cpp",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "c++",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "dcc",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "eccp",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "edgcpfe",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "mcc",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "tcc",
            versionSwitch: "-v",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        // cl does not have a version switch but it outputs the compiler version on stderr
        // when no source files arguments are given
        {
            name: "cl",
            versionSwitch: undefined,
            versionOutputRegexp: ".* Compiler Version (.*) for .*",
            captureGroup: 1
        },
        // gpp --version: gpp 2.25
        {
            name: "gpp",
            versionSwitch: "--version",
            versionOutputRegexp: "gpp ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "icc",
            versionSwitch: "-V",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "kcc",
            versionSwitch: "-V",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "pgc++",
            versionSwitch: "-V",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "aCC",
            versionSwitch: "-V",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "armcc",
            versionSwitch: "--version_number",
            versionOutputRegexp: ".*",
            captureGroup: 1
        },
        {
            name: "bcc32",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        {
            name: "bcc32c",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        {
            name: "bcc64",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        {
            name: "bcca",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        {
            name: "bccios",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        {
            name: "bccosx",
            versionSwitch: "--version",
            versionOutputRegexp: ".* C\\+\\+ ([^\\s]+) for .*",
            captureGroup: 1
        },
        // clang -v: clang version 10.0.0-4ubuntu1
        // or        clang version 5.0.0 (tags/RELEASE_500/final)
        {
            name: "clang",
            versionSwitch: "-v",
            versionOutputRegexp: "(Apple LLVM|clang) version ([^\\s-]+)",
            captureGroup: 2
        },
        {
            name: "clang-cl",
            versionSwitch: "-v",
            versionOutputRegexp: "(Apple LLVM|clang) version ([^\\s-]+)",
            captureGroup: 2
        },
        {
            name: "clang++",
            versionSwitch: "-v",
            versionOutputRegexp: "(Apple LLVM|clang) version ([^\\s-]+)",
            captureGroup: 2
        },
        {
            name: "armclang",
            versionSwitch: "-v",
            versionOutputRegexp: "(Apple LLVM|clang) version ([^\\s-]+)",
            captureGroup: 2
        },
        {
            name: "openCC",
            versionSwitch: "--version",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        {
            name: "pathCC",
            versionSwitch: "--version",
            versionOutputRegexp: "version ([^\\s]+)",
            captureGroup: 1
        },
        // We don't know of version switches for the following compilers so define only the compiler name
        {
            name: "dmc",
            versionSwitch: undefined,
            versionOutputRegexp: undefined
        },
        {
            name: "tpp",
            versionSwitch: undefined,
            versionOutputRegexp: undefined
        },
        {
            name: "vac++",
            versionSwitch: undefined,
            versionOutputRegexp: undefined
        },
        {
            name: "xlc++",
            versionSwitch: undefined,
            versionOutputRegexp: undefined
        }
    ];

    async getCompilerVersion(compilerPath: string): Promise<CompilerInfo> {
        // Compiler name and path as coming from the kit.
        const compilerName = path.parse(compilerPath).name;
        const compilerDir = path.parse(compilerPath).dir;

        // Find an equivalent in the compilers allowed list.
        // To avoid finding "cl" instead of "clang" or "g++" instead of "clang++",
        // sort the array from lengthier to shorter, so that the find operation
        // would return the most precise match.
        // The find condition must be "includes" instead of "equals"
        // (which wouldn't otherwise need the sort) to avoid implementing separate handling
        // for compiler file name prefixes and suffixes related to targeted architecture.
        const sortedCompilerAllowList = this.compilerAllowList.sort((a, b) => b.name.length - a.name.length);
        const compiler = sortedCompilerAllowList.find(comp => compilerName.includes(comp.name));

        // Mask any unrecognized compiler as "other" to hide private information
        let allowedCompilerName = compiler ? compiler.name : "other";

        // If we recognize the compiler or not, we can still include information about triplet names cross compilers
        if (compilerName.includes("aarch64")) {
            allowedCompilerName += "-aarch64";
        } else if (compilerName.includes("arm64")) {
            allowedCompilerName += "-arm64";
        } else if (compilerName.includes("arm")) {
            allowedCompilerName += "-arm";
        }
        if (compilerName.includes("eabi")) {
            allowedCompilerName += "-eabi";
        }

        // If we don't have a regexp, we can't obtain the compiler version information.
        // With an undefined switch we still can get the version information (if regexp is defined),
        // since some compilers can output their version without a specific switch.
        let version;
        if (compiler?.versionOutputRegexp) {
            version = await this.testCompilerVersion(compilerPath, compilerDir, compiler?.versionSwitch, RegExp(compiler.versionOutputRegexp, "mgi"), compiler.captureGroup) || "unknown";
        } else {
            version = "unknown";
        }

        return { name: allowedCompilerName, version };
    }

    /**
     * The list of generators CMake supports as of 3.21
     */
    private readonly cmakeGenerators = [
        "Visual Studio 18 2026",
        "Visual Studio 17 2022",
        "Visual Studio 16 2019",
        "Visual Studio 15 2017",
        "Visual Studio 14 2015",
        "Visual Studio 12 2013",
        "Visual Studio 11 2012",
        "Visual Studio 10 2010",
        "Visual Studio 9 2008",
        "Borland Makefiles",
        "NMake Makefiles",
        "NMake Makefiles JOM",
        "MSYS Makefiles",
        "MinGW Makefiles",
        "Green Hills MULTI",
        "Unix Makefiles",
        "Ninja",
        "Ninja Multi-Config",
        "FASTBuild",
        "Watcom WMake",
        "CodeBlocks - MinGW Makefiles",
        "CodeBlocks - NMake Makefiles",
        "CodeBlocks - NMake Makefiles JOM",
        "CodeBlocks - Ninja",
        "CodeBlocks - Unix Makefiles",
        "CodeLite - MinGW Makefiles",
        "CodeLite - NMake Makefiles",
        "CodeLite - Ninja",
        "CodeLite - Unix Makefiles",
        "Eclipse CDT4 - NMake Makefiles",
        "Eclipse CDT4 - MinGW Makefiles",
        "Eclipse CDT4 - Ninja",
        "Eclipse CDT4 - Unix Makefiles",
        "Kate - MinGW Makefiles",
        "Kate - NMake Makefiles",
        "Kate - Ninja",
        "Kate - Unix Makefiles",
        "Sublime Text 2 - MinGW Makefiles",
        "Sublime Text 2 - NMake Makefiles",
        "Sublime Text 2 - Ninja",
        "Sublime Text 2 - Unix Makefiles"
    ];

    private getGeneratorNameForTelemetry(generator: string | null = this.generatorName): string {
        if (generator) {
            return this.cmakeGenerators.find(g => generator.startsWith(g)) ?? 'other';
        }
        return 'other';
    }

    private countHiddenPresets(presets: preset.Preset[]): number {
        let count = 0;
        for (const p of presets) {
            if (p.hidden) {
                count++;
            }
        }
        return count;
    }

    public shouldUseCachedConfiguration(trigger: ConfigureTrigger): boolean {
        return (this.isCacheConfigSupported && !this.isConfiguredAtLeastOnce &&
            trigger === ConfigureTrigger.configureWithCache && !this.config.configureOnOpen) ?
            true : false;
    }

    public async generateConfigArgsFromPreset(configPreset: preset.ConfigurePreset): Promise<string[]> {
        // Cache flags will construct the command line for cmake.
        const init_cache_flags = await this.generateInitCacheFlags();
        // Make sure that we expand the config.configureArgs. Right now, preset args are expanded upon switching to the preset.
        const expandedConfigureArgs = await Promise.all(this.config.configureArgs.map(async (value) => expand.expandString(value, { ...this.expansionOptions, envOverride: await this.getConfigureEnvironment()})));
        const expandedArgs = init_cache_flags.concat(preset.configureArgs(configPreset), expandedConfigureArgs);
        const configurationScope = this.workspaceFolder ? vscode.Uri.file(this.workspaceFolder) : null;
        const config = vscode.workspace.getConfiguration("cmake", configurationScope);
        const exportCompileCommandsSetting = config.get<boolean>("exportCompileCommandsFile");
        const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
        const presetCacheVariables = configPreset.cacheVariables ?? {};
        const hasExportCompileCommands = Object.prototype.hasOwnProperty.call(presetCacheVariables, 'CMAKE_EXPORT_COMPILE_COMMANDS')
            || expandedArgs.some(arg => arg.startsWith('-DCMAKE_EXPORT_COMPILE_COMMANDS'));
        if (!hasExportCompileCommands && exportCompileCommandsFile) {
            const exportCompileCommandsValue = util.cmakeify(exportCompileCommandsFile);
            expandedArgs.push(`-DCMAKE_EXPORT_COMPILE_COMMANDS:${exportCompileCommandsValue.type}=${exportCompileCommandsValue.value}`);
        }
        // Only use the installPrefix config if the user didn't
        // provide one via the preset or configureArgs
        const hasInstallPrefix = Object.prototype.hasOwnProperty.call(presetCacheVariables, 'CMAKE_INSTALL_PREFIX')
            || expandedArgs.some(arg => arg.startsWith('-DCMAKE_INSTALL_PREFIX'));
        if (!hasInstallPrefix && this.installDir) {
            const installPrefixValue = util.cmakeify(this.installDir);
            expandedArgs.push(`-DCMAKE_INSTALL_PREFIX:${installPrefixValue.type}=${installPrefixValue.value}`);
        }
        return expandedArgs;
    }

    public async generateConfigArgsFromSettings(extra_args: string[] = [], withoutCmakeSettings: boolean = false): Promise<string[]> {
        // Cache flags will construct the command line for cmake.
        const init_cache_flags = await this.generateInitCacheFlags();
        const initial_common_flags = extra_args.concat(this.config.configureArgs);
        const common_flags = initial_common_flags.includes("--warn-unused-cli") ? initial_common_flags.filter(f => f !== "--warn-unused-cli") : initial_common_flags.concat("--no-warn-unused-cli");
        const define_flags = withoutCmakeSettings ? [] : this.generateCMakeSettingsFlags();
        const final_flags = define_flags.concat(common_flags, init_cache_flags);

        // Get expanded configure environment
        const expanded_configure_env = await this.getConfigureEnvironment();

        // Expand all flags
        const opts = this.expansionOptions;
        const expanded_flags_promises = final_flags.map(
            async (value: string) => expand.expandString(value, { ...opts, envOverride: expanded_configure_env }));
        return Promise.all(expanded_flags_promises);
    }

    // The `cancelInformation` parameter is an object that allows for passing the `cancelled` field to be modified by reference. This allows us to better understand if a user
    // manually cancelled the configure process.
    async configure(trigger: ConfigureTrigger, extra_args: string[], consumer?: proc.OutputConsumer, cancelInformation?: ConfigureCancelInformation, debuggerInformation?: DebuggerInformation, withoutCmakeSettings: boolean = false, showCommandOnly?: boolean, presetOverride?: preset.ConfigurePreset, options?: proc.ExecutionOptions): Promise<ConfigureResult> {
        // Check if the configuration is using cache in the first configuration and adjust the logging messages based on that.
        const shouldUseCachedConfiguration: boolean = this.shouldUseCachedConfiguration(trigger);

        if (trigger === ConfigureTrigger.configureWithCache && !shouldUseCachedConfiguration) {
            log.debug(localize('no.cached.config', "No cached config could be used for IntelliSense"));
            return { exitCode: -2, resultType: ConfigureResultType.NoCache };
        }
        if (this.isConfigInProgress) {
            await this.preconditionHandler(CMakePreconditionProblems.ConfigureIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.ConfigureInProgress };
        }
        if (this.cmakeBuildRunner.isBuildInProgress()) {
            await this.preconditionHandler(CMakePreconditionProblems.BuildIsAlreadyRunning);
            return { exitCode: -1, resultType: ConfigureResultType.BuildInProgress };
        }
        this.isConfigInProgress = true;
        try {
            // _beforeConfigureOrBuild needs to refresh expansions early because it reads various settings
            // (example: cmake.sourceDirectory).
            await this._refreshExpansions(presetOverride);
            if (!showCommandOnly) {
                if (!shouldUseCachedConfiguration) {
                    log.debug(localize('start.configure', 'Start configure'), extra_args);
                } else {
                    log.debug(localize('use.cached.configuration', 'Use cached configuration'), extra_args);
                }
            }

            const pre_check_ok = await this._beforeConfigureOrBuild(showCommandOnly);
            if (!pre_check_ok) {
                return { exitCode: -2, resultType: ConfigureResultType.Other };
            }

            // Safety net for the kits/variants path: if a setting change
            // (cmake.generator / cmake.preferredGenerators) reloaded the driver
            // without going through setKit(), the cached CMAKE_GENERATOR may
            // differ from this._generator. Clean the prior configuration here
            // so CMake doesn't fail with a "generator changed" error.
            // Presets handle this in setConfigurePreset via configurePresetChangeNeedsClean.
            if (!this.useCMakePresets
                && !showCommandOnly
                && !shouldUseCachedConfiguration
                && trigger !== ConfigureTrigger.configureWithCache
                && await this._hasGeneratorChanged(this._generator?.name)) {
                await this._cleanPriorConfiguration();
            }

            let expanded_flags: string[];
            let defaultPresetName: string | undefined;
            if (this.useCMakePresets) {
                defaultPresetName = this._configurePreset?.name;
                const configurePreset: preset.ConfigurePreset | undefined | null = (trigger === ConfigureTrigger.taskProvider) ? presetOverride : this._configurePreset;
                if (!configurePreset) {
                    log.debug(localize('no.config.Preset', 'No configure preset selected'));
                    return { exitCode: -3, resultType: ConfigureResultType.NoConfigurePreset };
                }
                // For now, fields in presets are expanded when the preset is selected
                expanded_flags = await this.generateConfigArgsFromPreset(configurePreset);

                if (!showCommandOnly && !shouldUseCachedConfiguration && checkConfigureOverridesPresent(this.config)) {
                    log.info(localize('configure.with.overrides', 'NOTE: You are configuring with preset {0}, but there are some overrides being applied from your VS Code settings.', configurePreset.displayName ?? configurePreset.name));
                }
            } else {
                expanded_flags = await this.generateConfigArgsFromSettings(extra_args, withoutCmakeSettings);
            }
            if (!shouldUseCachedConfiguration) {
                log.trace(localize('cmake.flags.are', 'CMake flags are {0}', JSON.stringify(expanded_flags)));
            }

            // A more complete round of expansions
            await this._refreshExpansions(presetOverride);

            const timeStart: number = new Date().getTime();
            let retc: number;
            if (shouldUseCachedConfiguration) {
                retc = await this.doCacheConfigure();
                this._isConfiguredAtLeastOnce = true;
                return { exitCode: retc, resultType: ConfigureResultType.NormalOperation };
            } else {
                retc = await this.doConfigure(expanded_flags, trigger, consumer, showCommandOnly, defaultPresetName, presetOverride, options, debuggerInformation);
                this._isConfiguredAtLeastOnce = true;
            }
            const timeEnd: number = new Date().getTime();

            const cmakeVersion = this.cmake.version;
            let telemetryProperties: telemetry.Properties;
            if (this.useCMakePresets) {
                telemetryProperties = {
                    CMakeExecutableVersion: cmakeVersion ? util.versionToString(cmakeVersion) : '',
                    CMakeGenerator: this.getGeneratorNameForTelemetry(presetOverride?.generator || this.generatorName),
                    Preset: this.useCMakePresets ? 'true' : 'false',
                    Trigger: trigger,
                    ShowCommandOnly: showCommandOnly ? 'true' : 'false'
                };
            } else {
                telemetryProperties = {
                    CMakeExecutableVersion: cmakeVersion ? util.versionToString(cmakeVersion) : '',
                    CMakeGenerator: this.getGeneratorNameForTelemetry(),
                    ConfigType: this.isMultiConfFast ? 'MultiConf' : this.currentBuildType || '',
                    Toolchain: this._kit?.toolchainFile ? 'true' : 'false', // UseToolchain?
                    Trigger: trigger,
                    ShowCommandOnly: showCommandOnly ? 'true' : 'false'
                };
            }

            if (this._kit?.compilers) {
                let cCompilerVersion;
                let cppCompilerVersion;
                if (this._kit.compilers["C"]) {
                    cCompilerVersion = await this.getCompilerVersion(this._kit.compilers["C"]);
                }

                if (this._kit.compilers["CXX"]) {
                    cppCompilerVersion = await this.getCompilerVersion(this._kit.compilers["CXX"]);
                }

                if (cCompilerVersion) {
                    telemetryProperties.CCompilerName = cCompilerVersion.name;
                    telemetryProperties.CCompilerVersion = cCompilerVersion.version;
                }

                if (cppCompilerVersion) {
                    telemetryProperties.CppCompilerName = cppCompilerVersion.name;
                    telemetryProperties.CppCompilerVersion = cppCompilerVersion.version;
                }
            } else if (this._kit?.visualStudio && this._kit.visualStudioArchitecture) {
                const env = await getVSKitEnvironment(this._kit);
                const dirs = env?.['Path']?.split(';') ?? [];
                let compilerPath = '';
                for (const dir of dirs) {
                    if (dir.indexOf('MSVC') > 0) {
                        compilerPath = path.join(dir, 'cl.exe');
                        break;
                    }
                }
                if (compilerPath) {
                    const compiler = await this.getCompilerVersion(compilerPath);
                    telemetryProperties.CCompilerVersion = compiler.version;
                    telemetryProperties.CppCompilerVersion = compiler.version;
                } else {
                    telemetryProperties.CCompilerVersion = 'unknown';
                    telemetryProperties.CppCompilerVersion = 'unknown';
                }
                telemetryProperties.CCompilerName = 'cl';
                telemetryProperties.CppCompilerName = 'cl';
            }

            if (this.useCMakePresets) {
                const arch = presetOverride ? presetOverride.__developerEnvironmentArchitecture : this._configurePreset ? this._configurePreset.__developerEnvironmentArchitecture : undefined;
                if (arch) {
                    telemetryProperties.VisualStudioArchitecture = arch;
                }
            } else {
                if (this._kit?.visualStudioArchitecture) {
                    telemetryProperties.VisualStudioArchitecture =
                        this._kit?.visualStudioArchitecture;
                }
                if (Array.isArray(this._kit?.visualStudioArguments)) {
                    telemetryProperties.VisualStudioArguments = JSON.stringify(this._kit?.visualStudioArguments);
                }
            }

            const telemetryMeasures: telemetry.Measures = {
                Duration: timeEnd - timeStart
            };
            if (this.useCMakePresets && this.workspaceFolder) {
                const configurePresets = preset.configurePresets(this.workspaceFolder);
                const userConfigurePresets = lodash.differenceWith(preset.userConfigurePresets(this.workspaceFolder), configurePresets, (a, b) => a.name === b.name);
                const buildPresets = preset.buildPresets(this.workspaceFolder);
                const userBuildPresets = lodash.differenceWith(preset.userBuildPresets(this.workspaceFolder), buildPresets, (a, b) => a.name === b.name);
                const testPresets = preset.testPresets(this.workspaceFolder);
                const userTestPresets = lodash.differenceWith(preset.userTestPresets(this.workspaceFolder), testPresets, (a, b) => a.name === b.name);
                const packagePresets = preset.packagePresets(this.workspaceFolder);
                const userPackagePresets = lodash.differenceWith(preset.userPackagePresets(this.workspaceFolder), packagePresets, (a, b) => a.name === b.name);
                const workflowPresets = preset.workflowPresets(this.workspaceFolder);
                const userWorkflowPresets = lodash.differenceWith(preset.userWorkflowPresets(this.workspaceFolder), workflowPresets, (a, b) => a.name === b.name);
                telemetryMeasures['ConfigurePresets'] = configurePresets.length;
                telemetryMeasures['HiddenConfigurePresets'] = this.countHiddenPresets(configurePresets);
                telemetryMeasures['UserConfigurePresets'] = userConfigurePresets.length;
                telemetryMeasures['HiddenUserConfigurePresets'] = this.countHiddenPresets(userConfigurePresets);
                telemetryMeasures['BuildPresets'] = buildPresets.length;
                telemetryMeasures['HiddenBuildPresets'] = this.countHiddenPresets(buildPresets);
                telemetryMeasures['UserBuildPresets'] = userBuildPresets.length;
                telemetryMeasures['HiddenUserBuildPresets'] = this.countHiddenPresets(userBuildPresets);
                telemetryMeasures['TestPresets'] = testPresets.length;
                telemetryMeasures['HiddenTestPresets'] = this.countHiddenPresets(testPresets);
                telemetryMeasures['UserTestPresets'] = userTestPresets.length;
                telemetryMeasures['HiddenUserTestPresets'] = this.countHiddenPresets(userTestPresets);
                telemetryMeasures['PackagePresets'] = packagePresets.length;
                telemetryMeasures['HiddenPackagePresets'] = this.countHiddenPresets(packagePresets);
                telemetryMeasures['UserPackagePresets'] = userPackagePresets.length;
                telemetryMeasures['HiddenUserPackagePresets'] = this.countHiddenPresets(userPackagePresets);
                telemetryMeasures['WorkflowPresets'] = workflowPresets.length;
                telemetryMeasures['HiddenWorkflowPresets'] = this.countHiddenPresets(workflowPresets);
                telemetryMeasures['UserWorkflowPresets'] = userWorkflowPresets.length;
                telemetryMeasures['HiddenUserWorkflowPresets'] = this.countHiddenPresets(userWorkflowPresets);
            }
            if (consumer) {
                if (consumer instanceof CMakeOutputConsumer) {
                    let errorCount: number = 0;
                    let warningCount: number = 0;
                    consumer.diagnostics.forEach(v => {
                        if (v.diag.severity === 0) {
                            errorCount++;
                        } else if (v.diag.severity === 1) {
                            warningCount++;
                        }
                    });
                    telemetryMeasures['ErrorCount'] = errorCount;
                    telemetryMeasures['WarningCount'] = warningCount;
                } else if (!(consumer instanceof CustomBuildTaskTerminal)) {
                    // Wrong type: shouldn't get here, just in case
                    rollbar.error('Wrong build result type.');
                    telemetryMeasures['ErrorCount'] = retc ? 1 : 0;
                }
            }

            telemetryProperties.Canceled = cancelInformation?.canceled ? "true" : "false";
            telemetry.logEvent('configure', telemetryProperties, telemetryMeasures);

            return { exitCode: retc, resultType: ConfigureResultType.NormalOperation };
        } catch {
            log.info(localize('configure.failed', 'Failed to configure project'));
            return { exitCode: -1, resultType: ConfigureResultType.NormalOperation };
        } finally {
            this.isConfigInProgress = false;
        }
    }

    private async generateInitCacheFlags(): Promise<string[]> {
        const cache_init_conf = this.config.cacheInit;
        let cache_init: string[] = [];
        if (cache_init_conf === null) {
            // Do nothing
        } else if (util.isString(cache_init_conf)) {
            cache_init = [cache_init_conf];
        } else {
            cache_init = cache_init_conf;
        }

        const flags: string[] = [];
        const envOverride = await this.getConfigureEnvironment();
        for (let init of cache_init) {
            init = await expand.expandString(init, { ...this.expansionOptions, envOverride });
            if (!path.isAbsolute(init)) {
                init = path.join(this.sourceDir, init);
            }
            flags.push('-C', init);
        }
        return flags;
    }

    private generateCMakeSettingsFlags(): string[] {
        const settingMap: { [key: string]: util.CMakeValue } = {};

        if (this._variantLinkage !== null) {
            settingMap.BUILD_SHARED_LIBS = util.cmakeify(this._variantLinkage === 'shared');
        }

        const configurationScope = this.workspaceFolder ? vscode.Uri.file(this.workspaceFolder) : null;
        const config = vscode.workspace.getConfiguration("cmake", configurationScope);

        const allowBuildTypeOnMultiConfig = config.get<boolean>("setBuildTypeOnMultiConfig") || false;

        if ((!this.isMultiConfFast || (this.isMultiConfFast && allowBuildTypeOnMultiConfig)) && (this.currentBuildType !== "Unspecified")) {
            // Mutliconf generators do not need the CMAKE_BUILD_TYPE property.
            // Also, do not set CMAKE_BUILD_TYPE when the user has not
            // specified the build type.
            settingMap.CMAKE_BUILD_TYPE = util.cmakeify(this.currentBuildType);
        }

        // Only use the installPrefix config if the user didn't
        // provide one via configureSettings
        if (!settingMap.CMAKE_INSTALL_PREFIX && this.installDir) {
            settingMap.CMAKE_INSTALL_PREFIX = util.cmakeify(this.installDir);
        }

        try {
            util.objectPairs(this.config.configureSettings).forEach(([key, value]) => settingMap[key] = util.cmakeify(value));
        } catch (e: any) {
            log.error(e.message);
            throw e;
        }
        util.objectPairs(this._variantConfigureSettings).forEach(([key, value]) => settingMap[key] = util.cmakeify(value as string));

        // Export compile_commands.json
        const exportCompileCommandsSetting = config.get<boolean>("exportCompileCommandsFile");
        const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
        if (exportCompileCommandsFile) {
            settingMap.CMAKE_EXPORT_COMPILE_COMMANDS = util.cmakeify(exportCompileCommandsFile);
        }

        console.assert(!!this._kit);
        if (!this._kit) {
            throw new Error(localize('no.kit.is.set', 'No kit is set!'));
        }
        if (this._kit.compilers) {
            log.debug(localize('using.compilers.in.for.configure', 'Using compilers in {0} for configure', this._kit.name));
            for (const lang in this._kit.compilers) {
                const compiler = this._kit.compilers[lang];
                settingMap[`CMAKE_${lang}_COMPILER`] = { type: 'FILEPATH', value: compiler };
            }
        }
        if (this._kit.toolchainFile) {
            log.debug(localize('using.cmake.toolchain.for.configure', 'Using CMake toolchain {0} for configuring', this._kit.name));
            settingMap.CMAKE_TOOLCHAIN_FILE = { type: 'FILEPATH', value: this._kit.toolchainFile };
        }
        if (this._kit.cmakeSettings) {
            util.objectPairs(this._kit.cmakeSettings)
                .forEach(([key, value]) => settingMap[key] = util.cmakeify(value));
        }

        return util.objectPairs(settingMap).map(([key, value]) => {
            switch (value.type) {
                case 'UNKNOWN':
                case '':
                    return `-D${key}=${value.value}`;
                default:
                    return `-D${key}:${value.type}=${value.value}`;
            }
        });
    }

    async build(targets?: string[], consumer?: proc.OutputConsumer, isBuildCommand?: boolean): Promise<number | null> {
        log.debug(localize('start.build', 'Start build'), targets?.join(', ') || '');
        if (this.isConfigInProgress) {
            await this.preconditionHandler(CMakePreconditionProblems.ConfigureIsAlreadyRunning);
            return -1;
        }
        if (this.cmakeBuildRunner.isBuildInProgress()) {
            await this.preconditionHandler(CMakePreconditionProblems.BuildIsAlreadyRunning);
            return -1;
        }
        this.cmakeBuildRunner.setBuildInProgress(true);

        const pre_build_ok = await this.doPreBuild();
        if (!pre_build_ok) {
            this.cmakeBuildRunner.setBuildInProgress(false);
            return -1;
        }
        const timeStart: number = new Date().getTime();
        const child = await this._doCMakeBuild(targets, consumer, isBuildCommand);
        const timeEnd: number = new Date().getTime();
        const duration: number = timeEnd - timeStart;
        log.info(localize('build.duration', 'Build completed: {0}', util.msToString(duration)));
        const telemetryProperties: telemetry.Properties | undefined = this.useCMakePresets ? undefined : {
            ConfigType: this.isMultiConfFast ? 'MultiConf' : this.currentBuildType || ''
        };
        const telemetryMeasures: telemetry.Measures = {
            Duration: duration
        };
        if (child) {
            if (consumer) {
                if (consumer instanceof CMakeBuildConsumer &&
                    consumer.compileConsumer instanceof CompileOutputConsumer) {
                    let errorCount: number = 0;
                    let warningCount: number = 0;
                    for (const compiler in consumer.compileConsumer.compilers) {
                        const parser: RawDiagnosticParser = consumer.compileConsumer.compilers[compiler];
                        parser.diagnostics.forEach(v => {
                            if (v.severity === 'error' || v.severity === 'fatal error') {
                                errorCount++;
                            } else if (v.severity === 'warning') {
                                warningCount++;
                            }
                        });
                    }
                    telemetryMeasures['ErrorCount'] = errorCount;
                    telemetryMeasures['WarningCount'] = warningCount;
                } else if (!(consumer instanceof CustomBuildTaskTerminal)) {
                    // Wrong type: shouldn't get here, just in case
                    rollbar.error('Wrong build result type.');
                    telemetryMeasures['ErrorCount'] = (await child.result).retc ? 1 : 0;
                }
            }
            telemetry.logEvent('build', telemetryProperties, telemetryMeasures);
        } else {
            // Not sure what happened but there's an error...
            telemetryMeasures['ErrorCount'] = 1;
            telemetry.logEvent('build', telemetryProperties, telemetryMeasures);
            this.cmakeBuildRunner.setBuildInProgress(false);
            return -1;
        }
        if (!this.m_stop_process) {
            const post_build_ok = await this.doPostBuild();
            if (!post_build_ok) {
                this.cmakeBuildRunner.setBuildInProgress(false);
                return -1;
            }
        }
        if (!this.m_stop_process) {
            await this._refreshExpansions();
        }

        return (await child.result.finally(() => {
            this.cmakeBuildRunner.setBuildInProgress(false);
        })).retc;
    }

    /**
     * Execute pre-configure/build tasks to check if we are ready to run a full
     * configure. This should be called by a derived driver before any
     * configuration tasks are run
     */
    private async _beforeConfigureOrBuild(showCommandOnly?: boolean): Promise<boolean> {
        if (!showCommandOnly) {
            log.debug(localize('running.pre-configure.checks', 'Running pre-configure checks and steps'));
        }

        if (!this.sourceDir) {
            log.debug(localize('source.directory.not.set', 'Source directory not set'), this.sourceDir);
            await this.preconditionHandler(CMakePreconditionProblems.NoSourceDirectoryFound);
            return false;
        }

        const cmake_list = this.mainListFile;
        if (!await fs.exists(cmake_list)) {
            log.debug(localize('not.configuring', 'Not configuring: There is no {0}', cmake_list));
            await this.preconditionHandler(CMakePreconditionProblems.MissingCMakeListsFile, this.config);
            return false;
        }

        return true;
    }

    protected abstract doConfigureSettingsChange(): Promise<void>;

    /**g
     * Subscribe to changes that affect the CMake configuration
     */
    private readonly _settingsSub = this.config.onChange('configureSettings', async () => this.doConfigureSettingsChange());
    private readonly _argsSub = this.config.onChange('configureArgs', async () => this.doConfigureSettingsChange());
    private readonly _envSub = this.config.onChange('configureEnvironment', async () => this.doConfigureSettingsChange());
    private readonly _buildArgsSub = this.config.onChange('buildArgs', async () => {
        await onBuildSettingsChange();
    });
    private readonly _buildEnvSub = this.config.onChange('buildEnvironment', async () => {
        await onBuildSettingsChange();
    });
    private readonly _testArgsSub = this.config.onChange('ctestArgs', async () => {
        await onTestSettingsChange();
    });
    private readonly _testEnvSub = this.config.onChange('testEnvironment', async () => {
        await onTestSettingsChange();
    });
    private readonly _packEnvSub = this.config.onChange('cpackEnvironment', async () => {
        await onPackageSettingsChange();
    });
    private readonly _packArgsSub = this.config.onChange('cpackArgs', async () => {
        await onPackageSettingsChange();
    });
    private readonly _generalEnvSub = this.config.onChange('environment', async () => {
        await this.doConfigureSettingsChange();
        await onBuildSettingsChange();
        await onTestSettingsChange();
    });
    private cmakeBuildRunner: CMakeBuildRunner = new CMakeBuildRunner();
    protected configureProcess: proc.Subprocess | null = null;

    private correctAllTargetName(targetnames: string[]) {
        for (let i = 0; i < targetnames.length; i++) {
            if (targetnames[i] === 'all' || targetnames[i] === 'ALL_BUILD') {
                targetnames[i] = this.allTargetName;
            }
        }
        return targetnames;
    }

    getCMakeCommand(): string {
        return this.cmake.path ? this.cmake.path : "cmake";
    }

    // Create a command for a given build preset.
    async generateBuildCommandFromPreset(buildPreset: preset.BuildPreset, targets?: string[]): Promise<proc.BuildCommand | null> {
        if (targets && targets.length > 0) {
            buildPreset.__targets = targets;
        } else {
            buildPreset.__targets = buildPreset.targets;
        }
        const args = preset.buildArgs(buildPreset, this.config.buildArgs, this.config.buildToolArgs, this.config.numJobsForPreset);
        const initialEnvironment = EnvironmentUtils.create(buildPreset.environment);
        const build_env = await this.getCMakeBuildCommandEnvironment(initialEnvironment);
        const expanded_args_promises = args.map(async (value: string) => expand.expandString(value, { ...this.expansionOptions, envOverride: build_env }));
        const expanded_args = await Promise.all(expanded_args_promises) as string[];
        log.trace(localize('cmake.build.args.are', 'CMake build args are: {0}', JSON.stringify(args)));

        if (checkBuildOverridesPresent(this.config)) {
            log.info(localize('build.with.overrides', 'NOTE: You are building with preset {0}, but there are some overrides being applied from your VS Code settings.', buildPreset.displayName ?? buildPreset.name));
        }

        return { command: this.cmake.path, args: expanded_args, build_env};
    }

    async generateBuildCommandFromSettings(targets?: string[]): Promise<proc.BuildCommand | null> {
        if (!targets || targets.length === 0) {
            return null;
        }

        const gen = this.generatorName;
        targets = this.correctAllTargetName(targets);

        const buildArgs: string[] = this.config.buildArgs.slice(0);
        const buildToolArgs: string[] = ['--'].concat(this.config.buildToolArgs);

        const configurationScope = this.workspaceFolder ? vscode.Uri.file(this.workspaceFolder) : null;
        const parallelJobsSetting = vscode.workspace.getConfiguration("cmake", configurationScope).inspect<number | undefined>('parallelJobs');
        let numJobs: number | undefined = (parallelJobsSetting?.workspaceFolderLanguageValue || parallelJobsSetting?.workspaceFolderValue || parallelJobsSetting?.globalValue);
        // for Ninja generator, don't '-j' argument if user didn't define number of jobs
        // let numJobs: number | undefined = this.config.numJobs;
        if (numJobs === undefined && gen && !/Ninja/.test(gen)) {
            numJobs = defaultNumJobs();
        }
        // for msbuild generators, only add '-j' argument if parallelJobs > 1
        if (numJobs && ((gen && !/Visual Studio/.test(gen)) || numJobs > 1)) {
            // Prefer using CMake's build options to set parallelism over tool-specific switches.
            // The feature is not available until version 3.14.
            if (this.cmake.version && util.versionGreaterOrEquals(this.cmake.version, util.parseVersion('3.14.0'))) {
                buildArgs.push('-j');
                if (numJobs) {
                    buildArgs.push(numJobs.toString());
                }
            } else {
                if (gen) {
                    if (/(Unix|MinGW) Makefiles|Ninja/.test(gen) && targets.length === 1 && targets[0] !== 'clean') {
                        buildToolArgs.push('-j', numJobs.toString());
                    } else if (/Visual Studio/.test(gen) && targets.length === 1 && targets[0] !== 'clean') {
                        buildToolArgs.push('/maxcpucount:' + numJobs.toString());
                    }
                }
            }
        }

        const ninja_env = EnvironmentUtils.create();
        ninja_env['NINJA_STATUS'] = '[%s/%t %p :: %e] ';
        const build_env = await this.getCMakeBuildCommandEnvironment(ninja_env);

        const args = ['--build', this.binaryDir, '--config', this.currentBuildType, '--target', ...targets]
            .concat(buildArgs, buildToolArgs);
        const opts = this.expansionOptions;
        const expanded_args_promises = args.map(async (value: string) => expand.expandString(value, { ...opts, envOverride: build_env }));
        const expanded_args = await Promise.all(expanded_args_promises) as string[];

        log.trace(localize('cmake.build.args.are', 'CMake build args are: {0}', JSON.stringify(expanded_args)));

        return { command: this.cmake.path, args: expanded_args, build_env };
    }

    async getCMakeBuildCommand(targets?: string[]): Promise<proc.BuildCommand | null> {
        if (this.useCMakePresets) {
            if (!this._buildPreset) {
                log.debug(localize('no.build.preset', 'No build preset selected'));
                return null;
            }
            return this.generateBuildCommandFromPreset(this._buildPreset, targets);
        } else {
            return this.generateBuildCommandFromSettings(targets);
        }
    }

    private async _doCMakeBuild(targets?: string[], consumer?: proc.OutputConsumer, isBuildCommand?: boolean): Promise<proc.Subprocess | null> {
        const buildcmd = await this.getCMakeBuildCommand(targets);
        if (buildcmd) {
            let outputEnc = this.config.outputLogEncoding;
            const isAutoEncoding = outputEnc === 'auto';
            if (isAutoEncoding) {
                if (process.platform === 'win32') {
                    outputEnc = await codepages.getWindowsCodepage();
                } else {
                    outputEnc = 'utf8';
                }
            }
            const useBuildTask: boolean = this.config.buildTask && isBuildCommand === true;
            if (useBuildTask) {
                const task: CMakeTask | undefined = await CMakeTaskProvider.findBuildTask(this.workspaceFolder, this._buildPreset?.name, targets, this.expansionOptions);
                if (task) {
                    const resolved = await CMakeTaskProvider.resolveInternalTask(task);
                    if (resolved) {
                        await this.cmakeBuildRunner.setBuildProcessForTask(await vscode.tasks.executeTask(resolved.task), resolved.exitCodePromise);
                    }
                }
            } else {
                const exeOpt: proc.ExecutionOptions = { environment: buildcmd.build_env, outputEncoding: outputEnc, useAutoEncoding: isAutoEncoding };
                this.cmakeBuildRunner.setBuildProcess(this.executeCommand(buildcmd.command, buildcmd.args, consumer, exeOpt));
            }
            const result = await this.cmakeBuildRunner.getResult();
            return result ? result : null;
        } else {
            return null;
        }
    }

    /**
     * If called then the current process should be stopped.
     * This could be the configuration or the build process.
     */
    async onStop(): Promise<void> {}

    private m_stop_process = false;
    /**
     * Stops the currently running process at user request
     */
    async stopCurrentProcess(): Promise<void> {
        this.m_stop_process = true;
        if (this.configureProcess && this.configureProcess.child) {
            await util.termProc(this.configureProcess.child);
            this.configureProcess = null;
            this._needsReconfigure = true;
        }
        if (this.cmakeBuildRunner) {
            await this.cmakeBuildRunner.stop();
        }
        await this.onStop();
    }

    /**
     * The CMake cache for the driver.
     *
     * Will be automatically reloaded when the file on disk changes.
     */
    abstract get cmakeCacheEntries(): Map<string, CacheEntry>;

    private async _baseInit(useCMakePresets: boolean,
        kit: Kit | null,
        configurePreset: preset.ConfigurePreset | null,
        buildPreset: preset.BuildPreset | null,
        testPreset: preset.TestPreset | null,
        packagePreset: preset.PackagePreset | null,
        workflowPreset: preset.WorkflowPreset | null,
        preferredGenerators: CMakeGenerator[]) {
        this._useCMakePresets = useCMakePresets;
        const initBaseDriverWithPresetLoc = localize("init.driver.using.preset", "Initializing base driver using preset");
        const initBaseDriverWithKitLoc = localize("init.driver.using.kit", "Initializing base driver using kit");
        log.debug(`${useCMakePresets ? initBaseDriverWithPresetLoc : initBaseDriverWithKitLoc}`);

        // Load up kit or presets before starting any drivers.
        if (useCMakePresets) {
            if (configurePreset) {
                await this._setConfigurePreset(configurePreset);
            }
            if (buildPreset) {
                await this._setBuildPreset(buildPreset);
            }
            if (testPreset) {
                await this._setTestPreset(testPreset);
            }
            if (packagePreset) {
                await this._setPackagePreset(packagePreset);
            }
            if (workflowPreset) {
                await this._setWorkflowPreset(workflowPreset);
            }
        } else if (kit) {
            await this._setKit(kit, preferredGenerators);
        }
        await this._refreshExpansions();
        await this.doInit();
    }
    protected abstract doInit(): Promise<void>;

    /**
     * Asynchronous initialization. Should be called by base classes during
     * their initialization.
     */
    static async createDerived<T extends CMakeDriver>(inst: T,
        useCMakePresets: boolean,
        kit: Kit | null,
        configurePreset: preset.ConfigurePreset | null,
        buildPreset: preset.BuildPreset | null,
        testPreset: preset.TestPreset | null,
        packagePreset: preset.PackagePreset | null,
        workflowPreset: preset.WorkflowPreset | null,
        preferredGenerators: CMakeGenerator[]): Promise<T> {
        await inst._baseInit(useCMakePresets, kit, configurePreset, buildPreset, testPreset, packagePreset, workflowPreset, preferredGenerators);
        return inst;
    }

    public getDiagnostics(): DiagnosticsConfiguration {
        return {
            folder: this.workspaceFolder || '',
            cmakeVersion: this.cmake.version ? util.versionToString(this.cmake.version) : '',
            configured: this._isConfiguredAtLeastOnce,
            generator: this.generatorName || '',
            usesPresets: this.useCMakePresets,
            compilers: {
                C: this.cmakeCacheEntries.get('CMAKE_C_COMPILER')?.value,
                CXX: this.cmakeCacheEntries.get('CMAKE_CXX_COMPILER')?.value
            }
        };
    }
}