8952933404

Committed 04 May 2024 08:05PM UTC coverage: 88.113%. Remained the same

Build # 8952933404

Build Type

push

github

Committed by

g-arjones

Commit Message

Add missing tests

Run Details

434 of 497 branches covered (87.32%)

Branch coverage included in aggregate %.

18 of 18 new or added lines in 2 files covered. (100.0%)

9 existing lines in 2 files now uncovered.

2101 of 2380 relevant lines covered (88.28%)

234.57 hits per line

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

61.16

/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"

    private _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);

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

                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
        const compilerPath = util.platformNormalizePath(command.shift()!);
        const compilerFragments = getAsFlags(command);
        const compilerFlags = parseCompileFlags(this._cppToolsApi!.getVersion(), compilerFragments);
        const intelliSenseMode = getIntelliSenseMode(this._cppToolsApi!.getVersion(), compilerPath, compilerFlags.targetArch);
        const 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 {	3✔
28	const isGnu = canUseGnu && std.startsWith('gnu');	3!
29	if (std.endsWith('++23') \|\| std.endsWith('++2b') \|\| std.endsWith('++latest')) {	3!
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')) {	3!
36	return isGnu ? 'gnu++20' : 'c++20';	×
37	} else if (std.endsWith('++17') \|\| std.endsWith('++1z')) {	3!
38	return isGnu ? 'gnu++17' : 'c++17';	×
39	} else if (std.endsWith('++14') \|\| std.endsWith('++1y')) {	3!
40	return isGnu ? 'gnu++14' : 'c++14';	×
41	} else if (std.endsWith('++11') \|\| std.endsWith('++0x')) {	3!
42	return isGnu ? 'gnu++11' : 'c++11';	3!
43	} else if (std.endsWith('++03')) {	3!
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	}	3✔
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 {	6✔
116	const requireStandardTarget = (cptVersion < cpptools.Version.v5);	6✔
117	const canUseGnuStd = (cptVersion >= cpptools.Version.v4);	6✔
118	const canUseCxx23 = (cptVersion >= cpptools.Version.v6);	6✔
119	// No need to parse language standard for CppTools API v6 and above	6✔
120	const extractStdFlag = (cptVersion < cpptools.Version.v6);	6✔
121	const iter = args[Symbol.iterator]();	6✔
122	const extraDefinitions: string[] = [];	6✔
123	let standard: StandardVersion;	6✔
124	let targetArch: Architecture;	6✔
125	while (1) {	6✔
126	const { done, value } = iter.next();	140✔
127	if (done) {	140✔
128	break;	6✔
129	}	6✔
130	const lower = value.toLowerCase();	134✔
131	if (requireStandardTarget && (lower === '-m32' \|\| lower === '-m64')) {	140!
132	targetArch = parseTargetArch(lower);	×
133	} else if (requireStandardTarget && (lower.startsWith('-arch=') \|\| lower.startsWith('/arch:'))) {	140!
134	const target = lower.substring(6);	×
135	targetArch = parseTargetArch(target);	×
136	} else if (requireStandardTarget && lower === '-arch') {	134!
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=')) {	134!
144	const target = lower.substring(7);	×
145	targetArch = parseTargetArch(target);	×
146	} else if (requireStandardTarget && lower.startsWith('--target=')) {	134!
147	const target = lower.substring(9);	×
148	targetArch = parseTargetArch(target);	×
149	} else if (requireStandardTarget && lower === '-target') {	134!
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') {	134!
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')) {	134✔
164	const def = value.substring(2);	40✔
165	extraDefinitions.push(def);	40✔
166	} else if (extractStdFlag && (value.startsWith('-std=') \|\| lower.startsWith('-std:') \|\| lower.startsWith('/std:'))) {	134✔
167	const std = value.substring(5);	3✔
168	if (lang === 'CXX' \|\| lang === 'OBJCXX' \|\| lang === 'CUDA') {	3!
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') {	3!
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) {	3✔
183	let s = parseCppStandard(std, canUseGnuStd, canUseCxx23);	3✔
184	if (!s) {	3!
185	s = parseCStandard(std, canUseGnuStd);	×
186	}	×
187	if (!s) {	3!
188	console.warn(`Unknown standard control flag: ${value}`);	×
189	} else {	3✔
190	standard = s;	3✔
191	}	3✔
192	} else {	3!
193	console.warn(`Unknown language: ${lang}`);	×
194	}	×
195	}	3✔
196	}	140✔
197	if (!standard && requireStandardTarget && extractStdFlag) {	6!
198	standard = (lang === 'C') ? 'c11' : 'c++17';	×
199	}	×
200	return { extraDefinitions, standard, targetArch };	6✔
201	}	6✔
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) {	6✔
208	if (cptVersion >= cpptools.Version.v5 && targetArch === undefined) {	6!
209	// IntelliSenseMode is optional for CppTools v5+ and is determined by CppTools.	×
210	return undefined;	×
211	}	×
212	const canUseArm = (cptVersion >= cpptools.Version.v4);	6✔
213	const compilerName = path.basename(compilerPath \|\| "").toLocaleLowerCase();	6!
214	if (compilerName === 'cl.exe') {	6!
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) {	6!
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) {	6!
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) {	6!
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) {	6!
252	return canUseArm ? 'gcc-arm' : 'gcc-x86';	×
253	} else if (compilerName.indexOf('gcc') >= 0 \|\| compilerName.indexOf('g++') >= 0) {	6!
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 {	6✔
267	// unknown compiler; pick platform defaults.	6✔
268	if (process.platform === 'win32') {	6!
269	return 'msvc-x64';	×
270	} else if (process.platform === 'darwin') {	6!
271	return 'clang-x64';	×
272	} else {	6✔
273	return 'gcc-x64';	6✔
274	}	6✔
275	}	6✔
276	}	6✔
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	private _pathToCompilationDb: Map<string, compilationDb.CompilationDatabase>;	1✔
288	private _workspaces: autoproj.Workspaces;	1✔
289	private _cppToolsApi: cpptools.CppToolsApi \| undefined;	1✔
290		1✔
291	constructor(workspaces: autoproj.Workspaces) {	1✔
292	this._workspaces = workspaces;	21✔
293	this._pathToCompilationDb = new Map<string, compilationDb.CompilationDatabase>();	21✔
294	}	21✔
295		1✔
296	async register(): Promise<boolean> {	1✔
297	this._cppToolsApi = await getCppToolsApi(Version.v6);	18✔
298	if (this._cppToolsApi) {	18✔
299	if (this._cppToolsApi.notifyReady) {	16✔
300	this._cppToolsApi.registerCustomConfigurationProvider(this);	15✔
301	this._cppToolsApi.notifyReady(this);	15✔
302	} else {	16✔
303	this._cppToolsApi.registerCustomConfigurationProvider(this);	1✔
304	this._cppToolsApi.didChangeCustomConfiguration(this);	1✔
305	}	1✔
306	return true;	16✔
307	}	16✔
308	return false;	2✔
309	}	2✔
310		1✔
311	notifyChanges() {	1✔
312	this._removeOrphanedDbs();	2✔
313		2✔
314	if (this._cppToolsApi) {	2✔
315	this._cppToolsApi.didChangeCustomBrowseConfiguration(this);	1✔
316	this._cppToolsApi.didChangeCustomConfiguration(this);	1✔
317	}	1✔
318	}	2✔
319		1✔
320	async canProvideConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {	1✔
321	return true;	1✔
322	}	1✔
323		1✔
324	async provideConfigurations(uris: vscode.Uri[], token?: vscode.CancellationToken) {	1✔
325	this._removeOrphanedDbs();	3✔
326	if (this._workspaces.workspaces.size == 0) {	3✔
327	return [];	1✔
328	}	1✔
329		2✔
330	const itemPromises = new Array<Promise<SourceFileConfigurationItem \| undefined>>();	2✔
331	for (const uri of uris) {	3✔
332	itemPromises.push(this.getSourceFileConfigurationItem(uri));	7✔
333	}	7✔
334		2✔
335	// Process all promises concurrently	2✔
336	return util.dropNulls(await Promise.all(itemPromises));	2✔
337	}	2✔
338		1✔
339	async canProvideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
340	return false;	1✔
341	}	1✔
342		1✔
343	async provideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
344	return null;	1✔
345	}	1✔
346		1✔
347	async canProvideBrowseConfigurationsPerFolder(token?: vscode.CancellationToken) {	1✔
348	return false;	1✔
349	}	1✔
350		1✔
351	async provideFolderBrowseConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {	1✔
352	return null;	1✔
353	}	1✔
354		1✔
355	clearDbs() {	1✔
356	for (const db of this._pathToCompilationDb.values()) {	3✔
357	db.dispose();	4✔
358	}	4✔
359		3✔
360	this._pathToCompilationDb.clear();	3✔
361	}	3✔
362		1✔
363	private _removeOrphanedDbs() {	1✔
364	// TODO: Remove dbs that don't belong to any package currently	5✔
365	// in any of the workspace (sub-)folders	5✔
366	}	5✔
367		1✔
368	async getCompilationDb(path: string): Promise<compilationDb.CompilationDatabase> {	1✔
369	let db = this._pathToCompilationDb.get(path);	15✔
370	if (db) {	15✔
371	if (!db.loaded && (await db.exists())) {	4✔
372	await db.load();	1✔
373	}	1✔
374	return db;	4✔
375	} else {	15✔
376	db = new compilationDb.CompilationDatabase(path, this);	11✔
377	if (await db.exists()) {	11✔
378	await db.load();	9✔
379	}	9✔
380	this._pathToCompilationDb.set(path, db);	11✔
381	}	11✔
382	return db;	11✔
383	}	11✔
384		1✔
385	async getSourceFileConfigurationItem(uri: vscode.Uri): Promise<SourceFileConfigurationItem \| undefined> {	1✔
386	let db: compilationDb.CompilationDatabase \| undefined;	7✔
387	for (const ws of this._workspaces.workspaces.values()) {	7✔
388	let wsInfo = await ws.info();	7✔
389	let pkg = wsInfo.findPackageByPath(uri.fsPath);	7✔
390	if (pkg && pkg.builddir) {	7✔
391	let db_path = path.join(pkg.builddir, "compile_commands.json");	7✔
392	db = await this.getCompilationDb(db_path);	7✔
393		7✔
394	let info = db.get(uri.fsPath);	7✔
395	if (!info) {	7✔
396	break;	1✔
397	}	1✔
398		6✔
399	let args = info.arguments;	6✔
400	if (args && args.length > 0) {	7✔
401	return {	6✔
402	uri: uri,	6✔
403	configuration: this.getSourceFileConfiguration(args)	6✔
404	};	6✔
405	}	6✔
406	}	7✔
407	}	7✔
408	}	1✔
409		1✔
410	getSourceFileConfiguration(command: string[]): SourceFileConfiguration {	1✔
411	const getAsFlags = (fragments?: string[]) => {	6✔
412	if (!fragments) {	6!
UNCOV 413	return [];	×
UNCOV 414	}	×
415	return [...util.flatMap(fragments, fragment => shlex.split(fragment))];	6✔
416	};	6✔
417		6✔
418	command = new Array<string>(...command); // copy to avoid changing the compilation db	6✔
419	const compilerPath = util.platformNormalizePath(command.shift()!);	6✔
420	const compilerFragments = getAsFlags(command);	6✔
421	const compilerFlags = parseCompileFlags(this._cppToolsApi!.getVersion(), compilerFragments);	6✔
422	const intelliSenseMode = getIntelliSenseMode(this._cppToolsApi!.getVersion(), compilerPath, compilerFlags.targetArch);	6✔
423	const configuration: SourceFileConfiguration = {	6✔
424	compilerPath: compilerPath,	6✔
425	standard: compilerFlags.standard,	6✔
426	intelliSenseMode: intelliSenseMode as IntelliSenseMode \|\| undefined,	6!
427	includePath: [],	6✔
428	defines: [],	6✔
429	compilerFragments: compilerFragments	6✔
430	}	6✔
431	return configuration;	6✔
432	}	6✔
433		1✔
434	dispose() {	1✔
435	if (this._cppToolsApi) {	2✔
436	this._cppToolsApi.dispose();	1✔
437	}	1✔
438	this.clearDbs();	2✔
439	}	2✔
440	}	1✔

g-arjones / vscode-autoproj / 8952933404

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