feat: scan kits from a folder (#4191)

* feat: scan kits from a folder

* updating based on requests in PR review

* missed a string

---------

Co-authored-by: Garrett Campbell <[email protected]>
Co-authored-by: Garrett Campbell <[email protected]>

Author: std-microblock

CHANGELOG.md

@@ -5,12 +5,14 @@
 Features:
 
 - Add support for Presets v9, which enables more macro expansion for the `include` field. [#3946](https://github.com/microsoft/vscode-cmake-tools/issues/3946)
+- Add support to configure default folder in workspace setting. [#1078](https://github.com/microsoft/vscode-cmake-tools/issues/1078)
 - Add support to configure default folder in workspace setting. [#1078](https://github.com/microsoft/vscode-cmake-tools/issues/1078) [@sanore](https://github.com/sanore)
 - Add support for processing LCOV based coverage info files when tests are
   executed. This adds test execution type, "Run with coverage", on the `ctest`
   section of the Testing tab.
   [#4040](https://github.com/microsoft/vscode-cmake-tools/issues/4040)
 - Add basic CMake language services: quick hover and completions for CMake built-ins. [PR #4204](https://github.com/microsoft/vscode-cmake-tools/pull/4204)
+- Add an option to scan kits from a folder. [#4191](https://github.com/microsoft/vscode-cmake-tools/pull/4191) [@std-microblock](https://github.com/std-microblock)
 
 Improvements:
 

src/kits/kit.ts

@@ -34,7 +34,8 @@ const log = logging.createLogger('kit');
  */
 export enum SpecialKits {
     ScanForKits = '__scanforkits__',
-    Unspecified = '__unspec__'
+    Unspecified = '__unspec__',
+    ScanSpecificDir = '__scan_specific_dir__',
 }
 export const SpecialKitsCount: number = 2;
 export type UnspecifiedKit = SpecialKits.Unspecified;
@@ -1030,7 +1031,7 @@ export async function effectiveKitEnvironment(kit: Kit, opts?: expand.ExpansionO
     } else {
         const vs_vars = await getVSKitEnvironment(kit);
         env = EnvironmentUtils.merge([env, vs_vars]);
-        const expandOptions: expand.ExpansionOptions = opts ? {...opts, envOverride: env, penvOverride: env } : {
+        const expandOptions: expand.ExpansionOptions = opts ? { ...opts, envOverride: env, penvOverride: env } : {
             vars: {} as expand.KitContextVars,
             envOverride: env,
             penvOverride: env
@@ -1071,6 +1072,7 @@ export async function findCLCompilerPath(env?: Environment): Promise<string | nu
 export interface KitScanOptions {
     ignorePath?: boolean;
     scanDirs?: string[];
+    useDefaultScanDirs?: boolean;
 }
 
 /**
@@ -1094,6 +1096,9 @@ export async function scanForKits(cmakePath?: string, opt?: KitScanOptions) {
         // Maps paths to booleans indicating if the path is trusted.
         const scan_paths = new Map<string, boolean>();
         function addScanPath(path: string, trusted: boolean, paths?: Map<string, boolean>) {
+            if (opt?.useDefaultScanDirs === false && !opt.scanDirs?.includes(path)) {
+                return;
+            }
             const normalizedPath = util.lightNormalizePath(path);
             const map = paths ?? scan_paths;
             map.set(normalizedPath, map.get(normalizedPath) || trusted);
@@ -1140,6 +1145,12 @@ export async function scanForKits(cmakePath?: string, opt?: KitScanOptions) {
 
             // PATH environment variable locations
             scan_paths.forEach((isTrusted, path) => addScanPath(path, isTrusted, clang_paths));
+
+            // Paths provided by the user
+            for (const path of opt?.scanDirs ?? []) {
+                addScanPath(path, true, clang_paths);
+            }
+
             // LLVM bundled in VS locations
             const vs_installs = await vsInstallations();
             const bundled_clang_paths: string[] = [];
@@ -1251,7 +1262,14 @@ export async function descriptionForKit(kit: Kit, shortVsName: boolean = false):
     if (kit.name === SpecialKits.ScanForKits) {
         return localize('search.for.compilers', 'Search for compilers on this computer');
     }
-    return localize('unspecified.let.cmake.guess', 'Unspecified (Let CMake guess what compilers and environment to use)');
+    if (kit.name === SpecialKits.Unspecified) {
+        return localize('unspecified.let.cmake.guess', 'Unspecified (Let CMake guess what compilers and environment to use)');
+    }
+    if (kit.name === SpecialKits.ScanSpecificDir) {
+        return localize('search.for.compilers.in.dir', 'Search recursively for compilers in a specific directory (max depth: 5)');
+    }
+
+    return '';
 }
 
 export async function readKitsFile(filePath: string, workspaceFolder?: string, expansionOptions?: expand.ExpansionOptions): Promise<Kit[]> {

src/kits/kitsController.ts

@@ -119,6 +119,8 @@ export class KitsController {
         KitsController.specialKits = [
             // Spcial __scanforkits__ kit used for invoking the "Scan for kits"
             { name: SpecialKits.ScanForKits, isTrusted: true },
+            // Special __scanSpecificDir__ kit for invoking the "Scan for kits in specific directories"
+            { name: SpecialKits.ScanSpecificDir, isTrusted: true },
             // Special __unspec__ kit for opting-out of kits
             { name: SpecialKits.Unspecified, isTrusted: true }
         ];
@@ -249,6 +251,8 @@ export class KitsController {
             switch (kit.name) {
                 case SpecialKits.ScanForKits as string:
                     return `[${localize('scan.for.kits.button', 'Scan for kits')}]`;
+                case SpecialKits.ScanSpecificDir as string:
+                    return `[${localize('scan.for.kits.in.specific.dir.button', 'Scan recursively for kits in specific directories (max depth: 5)')}]`;
                 case SpecialKits.Unspecified as string:
                     return `[${localize('unspecified.kit.name', 'Unspecified')}]`;
                 default:
@@ -276,6 +280,9 @@ export class KitsController {
             if (chosen_kit.kit.name === SpecialKits.ScanForKits) {
                 await KitsController.scanForKits(await this.project.getCMakePathofProject());
                 return false;
+            } else if (chosen_kit.kit.name === SpecialKits.ScanSpecificDir) {
+                await KitsController.scanForKitsInSpecificFolder(this.project);
+                return false;
             } else {
                 log.debug(localize('user.selected.kit', 'User selected kit {0}', JSON.stringify(chosen_kit)));
                 const kitChanged = chosen_kit.kit !== this.project.activeKit;
@@ -423,7 +430,7 @@ export class KitsController {
 
         // Remove the special kits
         const stripped_kits = kits.filter(kit => ((kit.name !== SpecialKits.ScanForKits) &&
-            (kit.name !== SpecialKits.Unspecified)));
+            (kit.name !== SpecialKits.Unspecified) && (kit.name !== SpecialKits.ScanSpecificDir)));
 
         // Sort the kits by name so they always appear in order in the file.
         const sorted_kits = stripped_kits.sort((a, b) => {
@@ -489,11 +496,14 @@ export class KitsController {
      *
      * @returns if any duplicate vs kits are removed.
      */
-    static async scanForKits(cmakePath: string) {
+    static async scanForKits(cmakePath: string, directoriesToScan?: string[]) {
         log.debug(localize('rescanning.for.kits', 'Rescanning for kits'));
 
         // Do the scan:
-        const discovered_kits = await scanForKits(cmakePath, { scanDirs: KitsController.additionalCompilerSearchDirs });
+        const discovered_kits = await scanForKits(cmakePath, !!directoriesToScan ? {
+            scanDirs: directoriesToScan,
+            useDefaultScanDirs: false
+        } : { scanDirs: KitsController.additionalCompilerSearchDirs });
 
         // The list with the new definition user kits starts with the non VS ones,
         // which do not have any variations in the way they can be defined.
@@ -558,6 +568,55 @@ export class KitsController {
         return duplicateRemoved;
     }
 
+    static async scanForKitsInSpecificFolder(project: CMakeProject) {
+        const dir = await vscode.window.showOpenDialog({
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            openLabel: localize('select.folder', 'Select Folder')
+        });
+        const dirPathWithDepth = async (folder: string, progress: ProgressHandle, cancel: vscode.CancellationToken, depth: number = 5): Promise<string[]> => {
+            if (cancel.isCancellationRequested) {
+                return [];
+            }
+
+            const dir = await fs.readdir(folder);
+            const files: string[] = [];
+            progress.report({ message: folder });
+            for (const file of dir) {
+                const filePath = path.join(folder, file);
+                if (depth > 0 && (await fs.stat(filePath)).isDirectory()) {
+                    files.push(...await dirPathWithDepth(filePath, progress, cancel, depth - 1));
+                    files.push(filePath);
+                }
+            }
+
+            return files;
+        };
+
+        if (!dir || dir.length === 0) {
+            return;
+        }
+
+        const accumulatedDirs: string[] = [];
+        await vscode.window.withProgress(
+            {
+                location: vscode.ProgressLocation.Notification,
+                title: localize('accumulating.folders', 'Recursively accumulating folders to scan'),
+                cancellable: true
+            },
+            async (progress, cancel) => {
+                accumulatedDirs.push(dir[0].fsPath);
+                accumulatedDirs.push(...(await dirPathWithDepth(dir[0].fsPath, progress, cancel)));
+            }
+        );
+
+        await KitsController.scanForKits(
+            await project.getCMakePathofProject(),
+            accumulatedDirs
+        );
+    }
+
     static isBetterMatch(newKit: Kit, existingKit?: Kit): boolean {
         if (KitsController.isBetterClangCLDefinition(newKit, existingKit)) {
             return true;
@@ -574,7 +633,7 @@ export class KitsController {
         return false;
     }
 
-    static isBetterCompilerMatch(newCompilers?: {[lang: string]: string}, existingCompilers?: {[lang: string]: string}): boolean {
+    static isBetterCompilerMatch(newCompilers?: { [lang: string]: string }, existingCompilers?: { [lang: string]: string }): boolean {
         // Try to keep the best match (e.g. compilers for C and CXX exist)
         if (!existingCompilers) {
             return true;

src/presets/presetsController.ts

@@ -282,6 +282,8 @@ export class PresetsController implements vscode.Disposable {
                         } else if (kit.visualStudio && !kit.compilers) {
                             const hostTargetArch = getHostTargetArchString(kit.visualStudioArchitecture!, kit.preferredGenerator?.platform);
                             return `${(kit.preferredGenerator?.name || 'Visual Studio')} ${hostTargetArch}`;
+                        } else if (kit.name === SpecialKits.ScanSpecificDir) {
+                            return `[${localize('scan.for.compilers.in.dir', 'Scan recursively for compilers in directory (max depth: 5)')}]`;
                         } else {
                             return kit.name;
                         }
@@ -304,6 +306,9 @@ export class PresetsController implements vscode.Disposable {
                         if (chosen_kit.kit.name === SpecialKits.ScanForKits) {
                             await KitsController.scanForKits(await this.project.getCMakePathofProject());
                             return false;
+                        } else if (chosen_kit.kit.name === SpecialKits.ScanSpecificDir) {
+                            await KitsController.scanForKitsInSpecificFolder(this.project);
+                            return false;
                         } else {
                             log.debug(localize('user.selected.compiler', 'User selected compiler {0}', JSON.stringify(chosen_kit)));
                             const generator = chosen_kit.kit.preferredGenerator?.name;
@@ -709,8 +714,10 @@ export class PresetsController implements vscode.Disposable {
                     const presets = preset.allConfigurePresets(this.folderPath);
                     const configurePreset = await this.selectNonHiddenPreset(presets, presets, { placeHolder });
                     if (configurePreset) {
-                        newPreset = { name: '__placeholder__', description: '', displayName: '',
-                            steps: [{type: "configure", name: configurePreset}] };
+                        newPreset = {
+                            name: '__placeholder__', description: '', displayName: '',
+                            steps: [{ type: "configure", name: configurePreset }]
+                        };
                     }
 
                     break;
@@ -720,11 +727,11 @@ export class PresetsController implements vscode.Disposable {
                     const presets = preset.allWorkflowPresets(this.folderPath);
                     const workflowBasePresetName = await this.selectNonHiddenPreset(presets, presets, { placeHolder, canPickMany: false });
                     const workflowBasePreset = presets.find(pr => pr.name === workflowBasePresetName);
-                    newPreset = { name: '__placeholder__', description: '', displayName: '', steps: workflowBasePreset?.steps || [{type: "configure", name: "_placeholder_"}] };
+                    newPreset = { name: '__placeholder__', description: '', displayName: '', steps: workflowBasePreset?.steps || [{ type: "configure", name: "_placeholder_" }] };
                     break;
                 }
                 case SpecialOptions.Custom: {
-                    newPreset = { name: '__placeholder__', description: '', displayName: '', steps: [{type: "configure", name: "_placeholder_"}] };
+                    newPreset = { name: '__placeholder__', description: '', displayName: '', steps: [{ type: "configure", name: "_placeholder_" }] };
                     break;
                 }
                 default:
@@ -842,7 +849,7 @@ export class PresetsController implements vscode.Disposable {
                 await this.setConfigurePreset(chosenPreset);
             }
 
-            if (this.project.workspaceContext.config.automaticReconfigure  && !quickStart) {
+            if (this.project.workspaceContext.config.automaticReconfigure && !quickStart) {
                 await this.project.configureInternal(ConfigureTrigger.selectConfigurePreset, [], ConfigureType.Normal);
             }
             return !addPreset || allPresets.length === 0;
@@ -1150,8 +1157,7 @@ export class PresetsController implements vscode.Disposable {
         }
     }
 
-    private checkCompatibility(configurePreset: preset.ConfigurePreset | null, buildPreset?: preset.BuildPreset | null, testPreset?: preset.TestPreset | null, packagePreset?: preset.PackagePreset | null, workflowPreset?: preset.WorkflowPreset | null):
-    {buildPresetCompatible: boolean; testPresetCompatible: boolean; packagePresetCompatible: boolean; workflowPresetCompatible: boolean} {
+    private checkCompatibility(configurePreset: preset.ConfigurePreset | null, buildPreset?: preset.BuildPreset | null, testPreset?: preset.TestPreset | null, packagePreset?: preset.PackagePreset | null, workflowPreset?: preset.WorkflowPreset | null): { buildPresetCompatible: boolean; testPresetCompatible: boolean; packagePresetCompatible: boolean; workflowPresetCompatible: boolean } {
         let testPresetCompatible = true;
         let buildPresetCompatible = true;
         let packagePresetCompatible = true;
@@ -1215,7 +1221,7 @@ export class PresetsController implements vscode.Disposable {
             workflowPresetCompatible = (temp === undefined);
         }
 
-        return {buildPresetCompatible, testPresetCompatible, packagePresetCompatible, workflowPresetCompatible};
+        return { buildPresetCompatible, testPresetCompatible, packagePresetCompatible, workflowPresetCompatible };
     }
 
     async selectTestPreset(): Promise<boolean> {