8943857867

Committed 03 May 2024 07:19PM UTC coverage: 86.606% (+0.3%) from 86.353%

Build # 8943857867

Build Type

push

github

Committed by

g-arjones

Commit Message

Add missing tests

Run Details

405 of 468 branches covered (86.54%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 1 file covered. (100.0%)

11 existing lines in 1 file now uncovered.

2065 of 2384 relevant lines covered (86.62%)

110.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.89

/src/cpptools.ts

/**
 * Module for vscode-cpptools integration.
 *
 * This module uses the [vscode-cpptools API](https://www.npmjs.com/package/vscode-cpptools)
 * to provide that extension with per-file configuration information.
 */ /** */

import * as autoproj from "./autoproj";
import * as shlex from './cmt/shlex';
import * as util from './cmt/util';
import * as compilationDb from "./cmt/compilationDatabase";
import * as path from 'path';
import * as vscode from 'vscode';
import * as cpptools from 'vscode-cpptools';
import { Version, getCppToolsApi, SourceFileConfigurationItem, SourceFileConfiguration } from 'vscode-cpptools';

type Architecture = 'x86' | 'x64' | 'arm' | 'arm64' | undefined;
type StandardVersion = "c89" | "c99" | "c11" | "c17" | "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" | "gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23" | undefined;
type IntelliSenseMode = "linux-clang-x86" | "linux-clang-x64" | "linux-clang-arm" | "linux-clang-arm64" | "linux-gcc-x86" | "linux-gcc-x64" | "linux-gcc-arm" | "linux-gcc-arm64" | "macos-clang-x86" | "macos-clang-x64" | "macos-clang-arm" | "macos-clang-arm64" | "macos-gcc-x86" | "macos-gcc-x64" | "macos-gcc-arm" | "macos-gcc-arm64" | "windows-clang-x86" | "windows-clang-x64" | "windows-clang-arm" | "windows-clang-arm64" | "windows-gcc-x86" | "windows-gcc-x64" | "windows-gcc-arm" | "windows-gcc-arm64" | "windows-msvc-x86" | "windows-msvc-x64" | "windows-msvc-arm" | "windows-msvc-arm64" | "msvc-x86" | "msvc-x64" | "msvc-arm" | "msvc-arm64" | "gcc-x86" | "gcc-x64" | "gcc-arm" | "gcc-arm64" | "clang-x86" | "clang-x64" | "clang-arm" | "clang-arm64" | undefined;

interface CompileFlagInformation {
    extraDefinitions: string[];
    standard?: StandardVersion;
    targetArch: Architecture;
}

function parseCppStandard(std: string, canUseGnu: boolean, canUseCxx23: boolean): StandardVersion {
    const isGnu = canUseGnu && std.startsWith('gnu');
    if (std.endsWith('++23') || std.endsWith('++2b') || std.endsWith('++latest')) {
        if (canUseCxx23) {
            return isGnu ? 'gnu++23' : 'c++23';
        } else {
            return isGnu ? 'gnu++20' : 'c++20';
        }
    } else if (std.endsWith('++20') || std.endsWith('++2a')) {
        return isGnu ? 'gnu++20' : 'c++20';
    } else if (std.endsWith('++17') || std.endsWith('++1z')) {
        return isGnu ? 'gnu++17' : 'c++17';
    } else if (std.endsWith('++14') || std.endsWith('++1y')) {
        return isGnu ? 'gnu++14' : 'c++14';
    } else if (std.endsWith('++11') || std.endsWith('++0x')) {
        return isGnu ? 'gnu++11' : 'c++11';
    } else if (std.endsWith('++03')) {
        return isGnu ? 'gnu++03' : 'c++03';
    } else if (std.endsWith('++98')) {
        return isGnu ? 'gnu++98' : 'c++98';
    } else {
        return undefined;
    }
}

function parseCStandard(std: string, canUseGnu: boolean): StandardVersion {
    // GNU options from: https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#C-Dialect-Options
    const isGnu = canUseGnu && std.startsWith('gnu');
    if (/(c|gnu)(90|89|iso9899:(1990|199409))/.test(std)) {
        return isGnu ? 'gnu89' : 'c89';
    } else if (/(c|gnu)(99|9x|iso9899:(1999|199x))/.test(std)) {
        return isGnu ? 'gnu99' : 'c99';
    } else if (/(c|gnu)(11|1x|iso9899:2011)/.test(std)) {
        return isGnu ? 'gnu11' : 'c11';
    } else if (/(c|gnu)(17|18|2x|iso9899:(2017|2018))/.test(std)) {
        if (canUseGnu) {
            // cpptools supports 'c17' in same version it supports GNU std.
            return isGnu ? 'gnu17' : 'c17';
        } else {
            return 'c11';
        }
    } else {
        return undefined;
    }
}

function parseTargetArch(target: string): Architecture {
    // Value of target param is lowercased.
    const isArm32: (value: string) => boolean = value => {
        // ARM verions from https://en.wikipedia.org/wiki/ARM_architecture#Cores
        if (value.indexOf('armv8-r') >= 0 || value.indexOf('armv8-m') >= 0) {
            return true;
        } else {
            // Check if ARM version is 7 or earlier.
            const verStr = value.substr(5, 1);
            const verNum = +verStr;
            return verNum <= 7;
        }
    };
    switch (target) {
        case '-m32':
        case 'i686':
            return 'x86';
        case '-m64':
        case 'amd64':
        case 'x86_64':
            return 'x64';
        case 'aarch64':
        case 'arm64':
            return 'arm64';
        case 'arm':
            return 'arm';
    }
    // Check triple target value
    if (target.indexOf('aarch64') >= 0 || target.indexOf('arm64') >= 0
        || target.indexOf('armv8-a') >= 0 || target.indexOf('armv8.') >= 0) {
        return 'arm64';
    } else if (target.indexOf('arm') >= 0 || isArm32(target)) {
        return 'arm';
    } else if (target.indexOf('i686') >= 0) {
        return 'x86';
    } else if (target.indexOf('amd64') >= 0 || target.indexOf('x86_64') >= 0) {
        return 'x64';
    }
    // TODO: add an allow list of architecture values and add telemetry
    return undefined;
}

function parseCompileFlags(cptVersion: cpptools.Version, args: string[], lang?: string): CompileFlagInformation {
    const requireStandardTarget = (cptVersion < cpptools.Version.v5);
    const canUseGnuStd = (cptVersion >= cpptools.Version.v4);
    const canUseCxx23 = (cptVersion >= cpptools.Version.v6);
    // No need to parse language standard for CppTools API v6 and above
    const extractStdFlag = (cptVersion < cpptools.Version.v6);
    const iter = args[Symbol.iterator]();
    const extraDefinitions: string[] = [];
    let standard: StandardVersion;
    let targetArch: Architecture;
    while (1) {
        const { done, value } = iter.next();
        if (done) {
            break;
        }
        const lower = value.toLowerCase();
        if (requireStandardTarget && (lower === '-m32' || lower === '-m64')) {
            targetArch = parseTargetArch(lower);
        } else if (requireStandardTarget && (lower.startsWith('-arch=') || lower.startsWith('/arch:'))) {
            const target = lower.substring(6);
            targetArch = parseTargetArch(target);
        } else if (requireStandardTarget && lower === '-arch') {
            const { done, value } = iter.next();
            if (done) {
                // TODO: add an allow list of architecture values and add telemetry
                continue;
            }
            targetArch = parseTargetArch(value.toLowerCase());
        } else if (requireStandardTarget && lower.startsWith('-march=')) {
            const target = lower.substring(7);
            targetArch = parseTargetArch(target);
        } else if (requireStandardTarget && lower.startsWith('--target=')) {
            const target = lower.substring(9);
            targetArch = parseTargetArch(target);
        } else if (requireStandardTarget && lower === '-target') {
            const { done, value } = iter.next();
            if (done) {
                // TODO: add an allow list of architecture values and add telemetry
                continue;
            }
            targetArch = parseTargetArch(value.toLowerCase());
        } else if (value === '-D' || value === '/D') {
            const { done, value } = iter.next();
            if (done) {
                console.error('Unexpected end of parsing command line arguments');
                continue;
            }
            extraDefinitions.push(value);
        } else if (value.startsWith('-D') || value.startsWith('/D')) {
            const def = value.substring(2);
            extraDefinitions.push(def);
        } else if (extractStdFlag && (value.startsWith('-std=') || lower.startsWith('-std:') || lower.startsWith('/std:'))) {
            const std = value.substring(5);
            if (lang === 'CXX' || lang === 'OBJCXX' || lang === 'CUDA') {
                const s = parseCppStandard(std, canUseGnuStd, canUseCxx23);
                if (!s) {
                    console.warn(`Unknown C++ standard control flag: ${value}`);
                } else {
                    standard = s;
                }
            } else if (lang === 'C' || lang === 'OBJC') {
                const s = parseCStandard(std, canUseGnuStd);
                if (!s) {
                    console.warn('unknown.control.gflag.c', 'Unknown C standard control flag: {0}', value);
                } else {
                    standard = s;
                }
            } else if (lang === undefined) {
                let s = parseCppStandard(std, canUseGnuStd, canUseCxx23);
                if (!s) {
                    s = parseCStandard(std, canUseGnuStd);
                }
                if (!s) {
                    console.warn(`Unknown standard control flag: ${value}`);
                } else {
                    standard = s;
                }
            } else {
                console.warn(`Unknown language: ${lang}`);
            }
        }
    }
    if (!standard && requireStandardTarget && extractStdFlag) {
        standard = (lang === 'C') ? 'c11' : 'c++17';
    }
    return { extraDefinitions, standard, targetArch };
}

/**
 * Determine the IntelliSenseMode based on hints from compiler path
 * and target architecture parsed from compiler flags.
 */
function getIntelliSenseMode(cptVersion: cpptools.Version, compilerPath: string, targetArch: Architecture) {
    if (cptVersion >= cpptools.Version.v5 && targetArch === undefined) {
        // IntelliSenseMode is optional for CppTools v5+ and is determined by CppTools.
        return undefined;
    }
    const canUseArm = (cptVersion >= cpptools.Version.v4);
    const compilerName = path.basename(compilerPath || "").toLocaleLowerCase();
    if (compilerName === 'cl.exe') {
        const clArch = path.basename(path.dirname(compilerPath)).toLocaleLowerCase();
        switch (clArch) {
            case 'arm64':
                return canUseArm ? 'msvc-arm64' : 'msvc-x64';
            case 'arm':
                return canUseArm ? 'msvc-arm' : 'msvc-x86';
            case 'x86':
                return 'msvc-x86';
            case 'x64':
            default:
                return 'msvc-x64';
        }
    } else if (compilerName.indexOf('armclang') >= 0) {
        switch (targetArch) {
            case 'arm64':
                return canUseArm ? 'clang-arm64' : 'clang-x64';
            case 'arm':
            default:
                return canUseArm ? 'clang-arm' : 'clang-x86';
        }
    } else if (compilerName.indexOf('clang') >= 0) {
        switch (targetArch) {
            case 'arm64':
                return canUseArm ? 'clang-arm64' : 'clang-x64';
            case 'arm':
                return canUseArm ? 'clang-arm' : 'clang-x86';
            case 'x86':
                return 'clang-x86';
            case 'x64':
            default:
                return 'clang-x64';
        }
    } else if (compilerName.indexOf('aarch64') >= 0) {
        // Compiler with 'aarch64' in its name may also have 'arm', so check for
        // aarch64 compilers before checking for ARM specific compilers.
        return canUseArm ? 'gcc-arm64' : 'gcc-x64';
    } else if (compilerName.indexOf('arm') >= 0) {
        return canUseArm ? 'gcc-arm' : 'gcc-x86';
    } else if (compilerName.indexOf('gcc') >= 0 || compilerName.indexOf('g++') >= 0) {
        switch (targetArch) {
            case 'x86':
                return 'gcc-x86';
            case 'x64':
                return 'gcc-x64';
            case 'arm64':
                return canUseArm ? 'gcc-arm64' : 'gcc-x64';
            case 'arm':
                return canUseArm ? 'gcc-arm' : 'gcc-x86';
            default:
                return 'gcc-x64';
        }
    } else {
        // unknown compiler; pick platform defaults.
        if (process.platform === 'win32') {
            return 'msvc-x64';
        } else if (process.platform === 'darwin') {
            return 'clang-x64';
        } else {
            return 'gcc-x64';
        }
    }
}

/**
 * The actual class that provides information to the cpptools extension. See
 * the `CustomConfigurationProvider` interface for information on how this class
 * should be used.
 */
export class CppConfigurationProvider implements cpptools.CustomConfigurationProvider {
    readonly name = "Autoproj";
    readonly extensionId = "arjones.autoproj"

    public readonly pathToCompilationDb: Map<string, compilationDb.CompilationDatabase>;

    private _workspaces: autoproj.Workspaces;
    private _cppToolsApi: cpptools.CppToolsApi | undefined;

    constructor(workspaces: autoproj.Workspaces) {
        this._workspaces = workspaces;
        this.pathToCompilationDb = new Map<string, compilationDb.CompilationDatabase>();
    }

    async register(): Promise<boolean> {
        this._cppToolsApi = await getCppToolsApi(Version.v6);
        if (this._cppToolsApi) {
            if (this._cppToolsApi.notifyReady) {
                this._cppToolsApi.registerCustomConfigurationProvider(this);
                this._cppToolsApi.notifyReady(this);
            } else {
                this._cppToolsApi.registerCustomConfigurationProvider(this);
                this._cppToolsApi.didChangeCustomConfiguration(this);
            }
            return true;
        }
        return false;
    }

    notifyChanges() {
        this._removeOrphanedDbs();

        if (this._cppToolsApi) {
            this._cppToolsApi.didChangeCustomBrowseConfiguration(this);
            this._cppToolsApi.didChangeCustomConfiguration(this);
        }
    }

    async canProvideConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {
        return true;
    }

    async provideConfigurations(uris: vscode.Uri[], token?: vscode.CancellationToken) {
        this._removeOrphanedDbs();
        if (this._workspaces.workspaces.size == 0) {
            return [];
        }

        const itemPromises = new Array<Promise<SourceFileConfigurationItem | undefined>>();
        for (const uri of uris) {
            itemPromises.push(this.getSourceFileConfigurationItem(uri));
        }

        // Process all promises concurrently
        return util.dropNulls(await Promise.all(itemPromises));
    }

    async canProvideBrowseConfiguration(token?: vscode.CancellationToken) {
        return false;
    }

    async provideBrowseConfiguration(token?: vscode.CancellationToken) {
        return null;
    }

    async canProvideBrowseConfigurationsPerFolder(token?: vscode.CancellationToken) {
        return false;
    }

    async provideFolderBrowseConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {
        return null;
    }

    clearDbs() {
        for (const db of this.pathToCompilationDb.values()) {
            db.dispose();
        }

        this.pathToCompilationDb.clear();
    }

    private _removeOrphanedDbs() {
        // TODO: Remove dbs that don't belong to any package currently
        // in any of the workspace (sub-)folders
    }

    async getCompilationDb(path: string): Promise<compilationDb.CompilationDatabase> {
        let db = this.pathToCompilationDb.get(path);
        if (db) {
            if (!db.loaded && (await db.exists())) {
                await db.load();
            }
            return db;
        } else {
            db = new compilationDb.CompilationDatabase(path, this);
            if (await db.exists()) {
                await db.load();
            }
            this.pathToCompilationDb.set(path, db);
        }
        return db;
    }

    async getSourceFileConfigurationItem(uri: vscode.Uri): Promise<SourceFileConfigurationItem | undefined> {
        let db: compilationDb.CompilationDatabase | undefined;
        for (const ws of this._workspaces.workspaces.values()) {
            let wsInfo = await ws.info();
            let pkg = wsInfo.findPackageByPath(uri.fsPath);
            if (pkg && pkg.builddir) {
                let db_path = path.join(pkg.builddir, "compile_commands.json");
                db = await this.getCompilationDb(db_path);
                if (!db) {
                    return;
                }

                let info = db.get(uri.fsPath);
                if (!info) {
                    return;
                }

                let args = info.arguments;
                if (args && args.length > 0) {
                    return {
                        uri: uri,
                        configuration: this.getSourceFileConfiguration(args)
                    };
                }
            }
        }
    }

    getSourceFileConfiguration(command: string[]): SourceFileConfiguration {
        const getAsFlags = (fragments?: string[]) => {
            if (!fragments) {
                return [];
            }
            return [...util.flatMap(fragments, fragment => shlex.split(fragment))];
        };

        command = new Array<string>(...command);  // copy to avoid changing the compilation db
        let compilerPath = util.platformNormalizePath(command.shift()!);
        let compilerFragments = getAsFlags(command);
        let compilerFlags = parseCompileFlags(this._cppToolsApi!.getVersion(), compilerFragments);
        let intelliSenseMode = getIntelliSenseMode(this._cppToolsApi!.getVersion(), compilerPath, compilerFlags.targetArch);
        let configuration: SourceFileConfiguration = {
            compilerPath: compilerPath,
            standard: compilerFlags.standard,
            intelliSenseMode: intelliSenseMode as IntelliSenseMode || undefined,
            includePath: [],
            defines: [],
            compilerFragments: compilerFragments
        }
        return configuration;
    }

    dispose() {
        if (this._cppToolsApi) {
            this._cppToolsApi.dispose();
        }
        this.clearDbs();
    }
}

1	/**	1✔
2	* Module for vscode-cpptools integration.	1✔
3	*	1✔
4	* This module uses the [vscode-cpptools API](https://www.npmjs.com/package/vscode-cpptools)	1✔
5	* to provide that extension with per-file configuration information.	1✔
6	/ /* */	1✔
7		1✔
8	import * as autoproj from "./autoproj";	1✔
9	import * as shlex from './cmt/shlex';	1✔
10	import * as util from './cmt/util';	1✔
11	import * as compilationDb from "./cmt/compilationDatabase";	1✔
12	import * as path from 'path';	1✔
13	import * as vscode from 'vscode';	1✔
14	import * as cpptools from 'vscode-cpptools';	1✔
15	import { Version, getCppToolsApi, SourceFileConfigurationItem, SourceFileConfiguration } from 'vscode-cpptools';	1✔
16		1✔
17	type Architecture = 'x86' \| 'x64' \| 'arm' \| 'arm64' \| undefined;	1✔
18	type StandardVersion = "c89" \| "c99" \| "c11" \| "c17" \| "c++98" \| "c++03" \| "c++11" \| "c++14" \| "c++17" \| "c++20" \| "c++23" \| "gnu89" \| "gnu99" \| "gnu11" \| "gnu17" \| "gnu++98" \| "gnu++03" \| "gnu++11" \| "gnu++14" \| "gnu++17" \| "gnu++20" \| "gnu++23" \| undefined;	1✔
19	type IntelliSenseMode = "linux-clang-x86" \| "linux-clang-x64" \| "linux-clang-arm" \| "linux-clang-arm64" \| "linux-gcc-x86" \| "linux-gcc-x64" \| "linux-gcc-arm" \| "linux-gcc-arm64" \| "macos-clang-x86" \| "macos-clang-x64" \| "macos-clang-arm" \| "macos-clang-arm64" \| "macos-gcc-x86" \| "macos-gcc-x64" \| "macos-gcc-arm" \| "macos-gcc-arm64" \| "windows-clang-x86" \| "windows-clang-x64" \| "windows-clang-arm" \| "windows-clang-arm64" \| "windows-gcc-x86" \| "windows-gcc-x64" \| "windows-gcc-arm" \| "windows-gcc-arm64" \| "windows-msvc-x86" \| "windows-msvc-x64" \| "windows-msvc-arm" \| "windows-msvc-arm64" \| "msvc-x86" \| "msvc-x64" \| "msvc-arm" \| "msvc-arm64" \| "gcc-x86" \| "gcc-x64" \| "gcc-arm" \| "gcc-arm64" \| "clang-x86" \| "clang-x64" \| "clang-arm" \| "clang-arm64" \| undefined;	1✔
20		1✔
21	interface CompileFlagInformation {	1✔
22	extraDefinitions: string[];	1✔
23	standard?: StandardVersion;	1✔
24	targetArch: Architecture;	1✔
25	}	1✔
26		1✔
27	function parseCppStandard(std: string, canUseGnu: boolean, canUseCxx23: boolean): StandardVersion {	×
28	const isGnu = canUseGnu && std.startsWith('gnu');	×
29	if (std.endsWith('++23') \|\| std.endsWith('++2b') \|\| std.endsWith('++latest')) {	×
30	if (canUseCxx23) {	×
31	return isGnu ? 'gnu++23' : 'c++23';	×
32	} else {	×
33	return isGnu ? 'gnu++20' : 'c++20';	×
34	}	×
35	} else if (std.endsWith('++20') \|\| std.endsWith('++2a')) {	×
36	return isGnu ? 'gnu++20' : 'c++20';	×
37	} else if (std.endsWith('++17') \|\| std.endsWith('++1z')) {	×
38	return isGnu ? 'gnu++17' : 'c++17';	×
39	} else if (std.endsWith('++14') \|\| std.endsWith('++1y')) {	×
40	return isGnu ? 'gnu++14' : 'c++14';	×
41	} else if (std.endsWith('++11') \|\| std.endsWith('++0x')) {	×
42	return isGnu ? 'gnu++11' : 'c++11';	×
43	} else if (std.endsWith('++03')) {	×
44	return isGnu ? 'gnu++03' : 'c++03';	×
45	} else if (std.endsWith('++98')) {	×
46	return isGnu ? 'gnu++98' : 'c++98';	×
47	} else {	×
48	return undefined;	×
49	}	×
50	}	×
51		1✔
52	function parseCStandard(std: string, canUseGnu: boolean): StandardVersion {	×
53	// GNU options from: https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#C-Dialect-Options	×
54	const isGnu = canUseGnu && std.startsWith('gnu');	×
55	if (/(c\|gnu)(90\|89\|iso9899:(1990\|199409))/.test(std)) {	×
56	return isGnu ? 'gnu89' : 'c89';	×
57	} else if (/(c\|gnu)(99\|9x\|iso9899:(1999\|199x))/.test(std)) {	×
58	return isGnu ? 'gnu99' : 'c99';	×
59	} else if (/(c\|gnu)(11\|1x\|iso9899:2011)/.test(std)) {	×
60	return isGnu ? 'gnu11' : 'c11';	×
61	} else if (/(c\|gnu)(17\|18\|2x\|iso9899:(2017\|2018))/.test(std)) {	×
62	if (canUseGnu) {	×
63	// cpptools supports 'c17' in same version it supports GNU std.	×
64	return isGnu ? 'gnu17' : 'c17';	×
65	} else {	×
66	return 'c11';	×
67	}	×
68	} else {	×
69	return undefined;	×
70	}	×
71	}	×
72		1✔
73	function parseTargetArch(target: string): Architecture {	×
74	// Value of target param is lowercased.	×
75	const isArm32: (value: string) => boolean = value => {	×
76	// ARM verions from https://en.wikipedia.org/wiki/ARM_architecture#Cores	×
77	if (value.indexOf('armv8-r') >= 0 \|\| value.indexOf('armv8-m') >= 0) {	×
78	return true;	×
79	} else {	×
80	// Check if ARM version is 7 or earlier.	×
81	const verStr = value.substr(5, 1);	×
82	const verNum = +verStr;	×
83	return verNum <= 7;	×
84	}	×
85	};	×
86	switch (target) {	×
87	case '-m32':	×
88	case 'i686':	×
89	return 'x86';	×
90	case '-m64':	×
91	case 'amd64':	×
92	case 'x86_64':	×
93	return 'x64';	×
94	case 'aarch64':	×
95	case 'arm64':	×
96	return 'arm64';	×
97	case 'arm':	×
98	return 'arm';	×
99	}	×
100	// Check triple target value	×
101	if (target.indexOf('aarch64') >= 0 \|\| target.indexOf('arm64') >= 0	×
102	\|\| target.indexOf('armv8-a') >= 0 \|\| target.indexOf('armv8.') >= 0) {	×
103	return 'arm64';	×
104	} else if (target.indexOf('arm') >= 0 \|\| isArm32(target)) {	×
105	return 'arm';	×
106	} else if (target.indexOf('i686') >= 0) {	×
107	return 'x86';	×
108	} else if (target.indexOf('amd64') >= 0 \|\| target.indexOf('x86_64') >= 0) {	×
109	return 'x64';	×
110	}	×
111	// TODO: add an allow list of architecture values and add telemetry	×
112	return undefined;	×
113	}	×
114		1✔
115	function parseCompileFlags(cptVersion: cpptools.Version, args: string[], lang?: string): CompileFlagInformation {	3✔
116	const requireStandardTarget = (cptVersion < cpptools.Version.v5);	3✔
117	const canUseGnuStd = (cptVersion >= cpptools.Version.v4);	3✔
118	const canUseCxx23 = (cptVersion >= cpptools.Version.v6);	3✔
119	// No need to parse language standard for CppTools API v6 and above	3✔
120	const extractStdFlag = (cptVersion < cpptools.Version.v6);	3✔
121	const iter = args[Symbol.iterator]();	3✔
122	const extraDefinitions: string[] = [];	3✔
123	let standard: StandardVersion;	3✔
124	let targetArch: Architecture;	3✔
125	while (1) {	3✔
126	const { done, value } = iter.next();	70✔
127	if (done) {	70✔
128	break;	3✔
129	}	3✔
130	const lower = value.toLowerCase();	67✔
131	if (requireStandardTarget && (lower === '-m32' \|\| lower === '-m64')) {	70!
132	targetArch = parseTargetArch(lower);	×
133	} else if (requireStandardTarget && (lower.startsWith('-arch=') \|\| lower.startsWith('/arch:'))) {	70!
134	const target = lower.substring(6);	×
135	targetArch = parseTargetArch(target);	×
136	} else if (requireStandardTarget && lower === '-arch') {	67!
137	const { done, value } = iter.next();	×
138	if (done) {	×
139	// TODO: add an allow list of architecture values and add telemetry	×
140	continue;	×
141	}	×
142	targetArch = parseTargetArch(value.toLowerCase());	×
143	} else if (requireStandardTarget && lower.startsWith('-march=')) {	67!
144	const target = lower.substring(7);	×
145	targetArch = parseTargetArch(target);	×
146	} else if (requireStandardTarget && lower.startsWith('--target=')) {	67!
147	const target = lower.substring(9);	×
148	targetArch = parseTargetArch(target);	×
149	} else if (requireStandardTarget && lower === '-target') {	67!
150	const { done, value } = iter.next();	×
151	if (done) {	×
152	// TODO: add an allow list of architecture values and add telemetry	×
153	continue;	×
154	}	×
155	targetArch = parseTargetArch(value.toLowerCase());	×
156	} else if (value === '-D' \|\| value === '/D') {	67!
157	const { done, value } = iter.next();	×
158	if (done) {	×
159	console.error('Unexpected end of parsing command line arguments');	×
160	continue;	×
161	}	×
162	extraDefinitions.push(value);	×
163	} else if (value.startsWith('-D') \|\| value.startsWith('/D')) {	67✔
164	const def = value.substring(2);	20✔
165	extraDefinitions.push(def);	20✔
166	} else if (extractStdFlag && (value.startsWith('-std=') \|\| lower.startsWith('-std:') \|\| lower.startsWith('/std:'))) {	67!
167	const std = value.substring(5);	×
168	if (lang === 'CXX' \|\| lang === 'OBJCXX' \|\| lang === 'CUDA') {	×
169	const s = parseCppStandard(std, canUseGnuStd, canUseCxx23);	×
170	if (!s) {	×
171	console.warn(`Unknown C++ standard control flag: ${value}`);	×
172	} else {	×
173	standard = s;	×
174	}	×
175	} else if (lang === 'C' \|\| lang === 'OBJC') {	×
176	const s = parseCStandard(std, canUseGnuStd);	×
177	if (!s) {	×
178	console.warn('unknown.control.gflag.c', 'Unknown C standard control flag: {0}', value);	×
179	} else {	×
180	standard = s;	×
181	}	×
182	} else if (lang === undefined) {	×
183	let s = parseCppStandard(std, canUseGnuStd, canUseCxx23);	×
184	if (!s) {	×
185	s = parseCStandard(std, canUseGnuStd);	×
186	}	×
187	if (!s) {	×
188	console.warn(`Unknown standard control flag: ${value}`);	×
189	} else {	×
190	standard = s;	×
191	}	×
192	} else {	×
193	console.warn(`Unknown language: ${lang}`);	×
194	}	×
195	}	×
196	}	70✔
197	if (!standard && requireStandardTarget && extractStdFlag) {	3!
198	standard = (lang === 'C') ? 'c11' : 'c++17';	×
199	}	×
200	return { extraDefinitions, standard, targetArch };	3✔
201	}	3✔
202		1✔
203	/**	1✔
204	* Determine the IntelliSenseMode based on hints from compiler path	1✔
205	* and target architecture parsed from compiler flags.	1✔
206	*/	1✔
207	function getIntelliSenseMode(cptVersion: cpptools.Version, compilerPath: string, targetArch: Architecture) {	3✔
208	if (cptVersion >= cpptools.Version.v5 && targetArch === undefined) {	3!
209	// IntelliSenseMode is optional for CppTools v5+ and is determined by CppTools.	×
210	return undefined;	×
211	}	×
212	const canUseArm = (cptVersion >= cpptools.Version.v4);	3✔
213	const compilerName = path.basename(compilerPath \|\| "").toLocaleLowerCase();	3!
214	if (compilerName === 'cl.exe') {	3!
215	const clArch = path.basename(path.dirname(compilerPath)).toLocaleLowerCase();	×
216	switch (clArch) {	×
217	case 'arm64':	×
218	return canUseArm ? 'msvc-arm64' : 'msvc-x64';	×
219	case 'arm':	×
220	return canUseArm ? 'msvc-arm' : 'msvc-x86';	×
221	case 'x86':	×
222	return 'msvc-x86';	×
223	case 'x64':	×
224	default:	×
225	return 'msvc-x64';	×
226	}	×
227	} else if (compilerName.indexOf('armclang') >= 0) {	3!
228	switch (targetArch) {	×
229	case 'arm64':	×
230	return canUseArm ? 'clang-arm64' : 'clang-x64';	×
231	case 'arm':	×
232	default:	×
233	return canUseArm ? 'clang-arm' : 'clang-x86';	×
234	}	×
235	} else if (compilerName.indexOf('clang') >= 0) {	3!
236	switch (targetArch) {	×
237	case 'arm64':	×
238	return canUseArm ? 'clang-arm64' : 'clang-x64';	×
239	case 'arm':	×
240	return canUseArm ? 'clang-arm' : 'clang-x86';	×
241	case 'x86':	×
242	return 'clang-x86';	×
243	case 'x64':	×
244	default:	×
245	return 'clang-x64';	×
246	}	×
247	} else if (compilerName.indexOf('aarch64') >= 0) {	3!
248	// Compiler with 'aarch64' in its name may also have 'arm', so check for	×
249	// aarch64 compilers before checking for ARM specific compilers.	×
250	return canUseArm ? 'gcc-arm64' : 'gcc-x64';	×
251	} else if (compilerName.indexOf('arm') >= 0) {	3!
252	return canUseArm ? 'gcc-arm' : 'gcc-x86';	×
253	} else if (compilerName.indexOf('gcc') >= 0 \|\| compilerName.indexOf('g++') >= 0) {	3!
254	switch (targetArch) {	×
255	case 'x86':	×
256	return 'gcc-x86';	×
257	case 'x64':	×
258	return 'gcc-x64';	×
259	case 'arm64':	×
260	return canUseArm ? 'gcc-arm64' : 'gcc-x64';	×
261	case 'arm':	×
262	return canUseArm ? 'gcc-arm' : 'gcc-x86';	×
263	default:	×
264	return 'gcc-x64';	×
265	}	×
266	} else {	3✔
267	// unknown compiler; pick platform defaults.	3✔
268	if (process.platform === 'win32') {	3!
269	return 'msvc-x64';	×
270	} else if (process.platform === 'darwin') {	3!
271	return 'clang-x64';	×
272	} else {	3✔
273	return 'gcc-x64';	3✔
274	}	3✔
275	}	3✔
276	}	3✔
277		1✔
278	/**	1✔
279	* The actual class that provides information to the cpptools extension. See	1✔
280	* the `CustomConfigurationProvider` interface for information on how this class	1✔
281	* should be used.	1✔
282	*/	1✔
283	export class CppConfigurationProvider implements cpptools.CustomConfigurationProvider {	1✔
284	readonly name = "Autoproj";	1✔
285	readonly extensionId = "arjones.autoproj"	1✔
286		1✔
287	public readonly pathToCompilationDb: Map<string, compilationDb.CompilationDatabase>;	1✔
288		1✔
289	private _workspaces: autoproj.Workspaces;	1✔
290	private _cppToolsApi: cpptools.CppToolsApi \| undefined;	1✔
291		1✔
292	constructor(workspaces: autoproj.Workspaces) {	1✔
293	this._workspaces = workspaces;	15✔
294	this.pathToCompilationDb = new Map<string, compilationDb.CompilationDatabase>();	15✔
295	}	15✔
296		1✔
297	async register(): Promise<boolean> {	1✔
298	this._cppToolsApi = await getCppToolsApi(Version.v6);	12✔
299	if (this._cppToolsApi) {	12✔
300	if (this._cppToolsApi.notifyReady) {	10✔
301	this._cppToolsApi.registerCustomConfigurationProvider(this);	9✔
302	this._cppToolsApi.notifyReady(this);	9✔
303	} else {	10✔
304	this._cppToolsApi.registerCustomConfigurationProvider(this);	1✔
305	this._cppToolsApi.didChangeCustomConfiguration(this);	1✔
306	}	1✔
307	return true;	10✔
308	}	10✔
309	return false;	2✔
310	}	2✔
311		1✔
312	notifyChanges() {	1✔
313	this._removeOrphanedDbs();	2✔
314		2✔
315	if (this._cppToolsApi) {	2✔
316	this._cppToolsApi.didChangeCustomBrowseConfiguration(this);	1✔
317	this._cppToolsApi.didChangeCustomConfiguration(this);	1✔
318	}	1✔
319	}	2✔
320		1✔
321	async canProvideConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {	1✔
322	return true;	1✔
323	}	1✔
324		1✔
325	async provideConfigurations(uris: vscode.Uri[], token?: vscode.CancellationToken) {	1✔
326	this._removeOrphanedDbs();	1✔
327	if (this._workspaces.workspaces.size == 0) {	1!
UNCOV 328	return [];	×
UNCOV 329	}	×
330		1✔
331	const itemPromises = new Array<Promise<SourceFileConfigurationItem \| undefined>>();	1✔
332	for (const uri of uris) {	1✔
333	itemPromises.push(this.getSourceFileConfigurationItem(uri));	4✔
334	}	4✔
335		1✔
336	// Process all promises concurrently	1✔
337	return util.dropNulls(await Promise.all(itemPromises));	1✔
338	}	1✔
339		1✔
340	async canProvideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
341	return false;	1✔
342	}	1✔
343		1✔
344	async provideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
345	return null;	1✔
346	}	1✔
347		1✔
348	async canProvideBrowseConfigurationsPerFolder(token?: vscode.CancellationToken) {	1✔
349	return false;	1✔
350	}	1✔
351		1✔
352	async provideFolderBrowseConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {	1✔
353	return null;	1✔
354	}	1✔
355		1✔
356	clearDbs() {	1✔
357	for (const db of this.pathToCompilationDb.values()) {	3✔
358	db.dispose();	4✔
359	}	4✔
360		3✔
361	this.pathToCompilationDb.clear();	3✔
362	}	3✔
363		1✔
364	private _removeOrphanedDbs() {	1✔
365	// TODO: Remove dbs that don't belong to any package currently	3✔
366	// in any of the workspace (sub-)folders	3✔
367	}	3✔
368		1✔
369	async getCompilationDb(path: string): Promise<compilationDb.CompilationDatabase> {	1✔
370	let db = this.pathToCompilationDb.get(path);	4✔
371	if (db) {	4!
UNCOV 372	if (!db.loaded && (await db.exists())) {	×
UNCOV 373	await db.load();	×
UNCOV 374	}	×
UNCOV 375	return db;	×
376	} else {	4✔
377	db = new compilationDb.CompilationDatabase(path, this);	4✔
378	if (await db.exists()) {	4✔
379	await db.load();	4✔
380	}	4✔
381	this.pathToCompilationDb.set(path, db);	4✔
382	}	4✔
383	return db;	4✔
384	}	4✔
385		1✔
386	async getSourceFileConfigurationItem(uri: vscode.Uri): Promise<SourceFileConfigurationItem \| undefined> {	1✔
387	let db: compilationDb.CompilationDatabase \| undefined;	4✔
388	for (const ws of this._workspaces.workspaces.values()) {	4✔
389	let wsInfo = await ws.info();	4✔
390	let pkg = wsInfo.findPackageByPath(uri.fsPath);	4✔
391	if (pkg && pkg.builddir) {	4✔
392	let db_path = path.join(pkg.builddir, "compile_commands.json");	4✔
393	db = await this.getCompilationDb(db_path);	4✔
394	if (!db) {	4!
UNCOV 395	return;	×
UNCOV 396	}	×
397		4✔
398	let info = db.get(uri.fsPath);	4✔
399	if (!info) {	4✔
400	return;	1✔
401	}	1✔
402		3✔
403	let args = info.arguments;	3✔
404	if (args && args.length > 0) {	4✔
405	return {	3✔
406	uri: uri,	3✔
407	configuration: this.getSourceFileConfiguration(args)	3✔
408	};	3✔
409	}	3✔
410	}	4✔
411	}	4✔
UNCOV 412	}	×
413		1✔
414	getSourceFileConfiguration(command: string[]): SourceFileConfiguration {	1✔
415	const getAsFlags = (fragments?: string[]) => {	3✔
416	if (!fragments) {	3!
UNCOV 417	return [];	×
UNCOV 418	}	×
419	return [...util.flatMap(fragments, fragment => shlex.split(fragment))];	3✔
420	};	3✔
421		3✔
422	command = new Array<string>(...command); // copy to avoid changing the compilation db	3✔
423	let compilerPath = util.platformNormalizePath(command.shift()!);	3✔
424	let compilerFragments = getAsFlags(command);	3✔
425	let compilerFlags = parseCompileFlags(this._cppToolsApi!.getVersion(), compilerFragments);	3✔
426	let intelliSenseMode = getIntelliSenseMode(this._cppToolsApi!.getVersion(), compilerPath, compilerFlags.targetArch);	3✔
427	let configuration: SourceFileConfiguration = {	3✔
428	compilerPath: compilerPath,	3✔
429	standard: compilerFlags.standard,	3✔
430	intelliSenseMode: intelliSenseMode as IntelliSenseMode \|\| undefined,	3!
431	includePath: [],	3✔
432	defines: [],	3✔
433	compilerFragments: compilerFragments	3✔
434	}	3✔
435	return configuration;	3✔
436	}	3✔
437		1✔
438	dispose() {	1✔
439	if (this._cppToolsApi) {	1✔
440	this._cppToolsApi.dispose();	1✔
441	}	1✔
442	this.clearDbs();	1✔
443	}	1✔
444	}	1✔

g-arjones / vscode-autoproj / 8943857867

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous