8943098337

Committed 03 May 2024 06:09PM UTC coverage: 79.107%. Remained the same

Build # 8943098337

Build Type

push

github

Committed by

g-arjones

Commit Message

Add missing tests

Run Details

362 of 382 branches covered (94.76%)

Branch coverage included in aggregate %.

7 of 10 new or added lines in 1 file covered. (70.0%)

64 existing lines in 1 file now uncovered.

1853 of 2418 relevant lines covered (76.63%)

9.22 hits per line

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

30.62

/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
        const items: SourceFileConfigurationItem[] = []
        for (const item of (await Promise.all(itemPromises))) {
            if (item) {
                items.push(item);
            }
        }
        return items;
    }

    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 {	×
116	const requireStandardTarget = (cptVersion < cpptools.Version.v5);	×
117	const canUseGnuStd = (cptVersion >= cpptools.Version.v4);	×
118	const canUseCxx23 = (cptVersion >= cpptools.Version.v6);	×
119	// No need to parse language standard for CppTools API v6 and above	×
120	const extractStdFlag = (cptVersion < cpptools.Version.v6);	×
121	const iter = args[Symbol.iterator]();	×
122	const extraDefinitions: string[] = [];	×
123	let standard: StandardVersion;	×
124	let targetArch: Architecture;	×
125	while (1) {	×
126	const { done, value } = iter.next();	×
127	if (done) {	×
128	break;	×
129	}	×
130	const lower = value.toLowerCase();	×
131	if (requireStandardTarget && (lower === '-m32' \|\| lower === '-m64')) {	×
132	targetArch = parseTargetArch(lower);	×
133	} else if (requireStandardTarget && (lower.startsWith('-arch=') \|\| lower.startsWith('/arch:'))) {	×
134	const target = lower.substring(6);	×
135	targetArch = parseTargetArch(target);	×
136	} else if (requireStandardTarget && lower === '-arch') {	×
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=')) {	×
144	const target = lower.substring(7);	×
145	targetArch = parseTargetArch(target);	×
146	} else if (requireStandardTarget && lower.startsWith('--target=')) {	×
147	const target = lower.substring(9);	×
148	targetArch = parseTargetArch(target);	×
149	} else if (requireStandardTarget && lower === '-target') {	×
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') {	×
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')) {	×
164	const def = value.substring(2);	×
165	extraDefinitions.push(def);	×
166	} else if (extractStdFlag && (value.startsWith('-std=') \|\| lower.startsWith('-std:') \|\| lower.startsWith('/std:'))) {	×
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	}	×
197	if (!standard && requireStandardTarget && extractStdFlag) {	×
198	standard = (lang === 'C') ? 'c11' : 'c++17';	×
199	}	×
200	return { extraDefinitions, standard, targetArch };	×
201	}	×
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) {	×
208	if (cptVersion >= cpptools.Version.v5 && targetArch === undefined) {	×
209	// IntelliSenseMode is optional for CppTools v5+ and is determined by CppTools.	×
210	return undefined;	×
211	}	×
212	const canUseArm = (cptVersion >= cpptools.Version.v4);	×
213	const compilerName = path.basename(compilerPath \|\| "").toLocaleLowerCase();	×
214	if (compilerName === 'cl.exe') {	×
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) {	×
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) {	×
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) {	×
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) {	×
252	return canUseArm ? 'gcc-arm' : 'gcc-x86';	×
253	} else if (compilerName.indexOf('gcc') >= 0 \|\| compilerName.indexOf('g++') >= 0) {	×
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 {	×
267	// unknown compiler; pick platform defaults.	×
268	if (process.platform === 'win32') {	×
269	return 'msvc-x64';	×
270	} else if (process.platform === 'darwin') {	×
271	return 'clang-x64';	×
272	} else {	×
273	return 'gcc-x64';	×
274	}	×
275	}	×
276	}	×
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;	14✔
294	this.pathToCompilationDb = new Map<string, compilationDb.CompilationDatabase>();	14✔
295	}	14✔
296		1✔
297	async register(): Promise<boolean> {	1✔
298	this._cppToolsApi = await getCppToolsApi(Version.v6);	11✔
299	if (this._cppToolsApi) {	11✔
300	if (this._cppToolsApi.notifyReady) {	9✔
301	this._cppToolsApi.registerCustomConfigurationProvider(this);	8✔
302	this._cppToolsApi.notifyReady(this);	8✔
303	} else {	9✔
304	this._cppToolsApi.registerCustomConfigurationProvider(this);	1✔
305	this._cppToolsApi.didChangeCustomConfiguration(this);	1✔
306	}	1✔
307	return true;	9✔
308	}	9✔
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✔
NEW 326	this._removeOrphanedDbs();	×
UNCOV 327	if (this._workspaces.workspaces.size == 0) {	×
UNCOV 328	return [];	×
UNCOV 329	}	×
UNCOV 330		×
UNCOV 331	const itemPromises = new Array<Promise<SourceFileConfigurationItem \| undefined>>();	×
UNCOV 332	for (const uri of uris) {	×
UNCOV 333	itemPromises.push(this.getSourceFileConfigurationItem(uri));	×
UNCOV 334	}	×
UNCOV 335		×
UNCOV 336	// Process all promises concurrently	×
UNCOV 337	const items: SourceFileConfigurationItem[] = []	×
UNCOV 338	for (const item of (await Promise.all(itemPromises))) {	×
UNCOV 339	if (item) {	×
UNCOV 340	items.push(item);	×
UNCOV 341	}	×
UNCOV 342	}	×
UNCOV 343	return items;	×
UNCOV 344	}	×
345		1✔
346	async canProvideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
347	return false;	1✔
348	}	1✔
349		1✔
350	async provideBrowseConfiguration(token?: vscode.CancellationToken) {	1✔
351	return null;	1✔
352	}	1✔
353		1✔
354	async canProvideBrowseConfigurationsPerFolder(token?: vscode.CancellationToken) {	1✔
355	return false;	1✔
356	}	1✔
357		1✔
358	async provideFolderBrowseConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken) {	1✔
359	return null;	1✔
360	}	1✔
361		1✔
362	clearDbs() {	1✔
363	for (const db of this.pathToCompilationDb.values()) {	3✔
364	db.dispose();	4✔
365	}	4✔
366		3✔
367	this.pathToCompilationDb.clear();	3✔
368	}	3✔
369		1✔
370	private _removeOrphanedDbs() {	1✔
371	// TODO: Remove dbs that don't belong to any package currently	2✔
372	// in any of the workspace (sub-)folders	2✔
373	}	2✔
374		1✔
375	async getCompilationDb(path: string): Promise<compilationDb.CompilationDatabase> {	1✔
NEW 376	let db = this.pathToCompilationDb.get(path);	×
377	if (db) {	×
378	if (!db.loaded && (await db.exists())) {	×
379	await db.load();	×
380	}	×
381	return db;	×
382	} else {	×
383	db = new compilationDb.CompilationDatabase(path, this);	×
384	if (await db.exists()) {	×
385	await db.load();	×
386	}	×
NEW 387	this.pathToCompilationDb.set(path, db);	×
388	}	×
389	return db;	×
390	}	×
391		1✔
392	async getSourceFileConfigurationItem(uri: vscode.Uri): Promise<SourceFileConfigurationItem \| undefined> {	1✔
393	let db: compilationDb.CompilationDatabase \| undefined;	×
394	for (const ws of this._workspaces.workspaces.values()) {	×
UNCOV 395	let wsInfo = await ws.info();	×
UNCOV 396	let pkg = wsInfo.findPackageByPath(uri.fsPath);	×
UNCOV 397	if (pkg && pkg.builddir) {	×
UNCOV 398	let db_path = path.join(pkg.builddir, "compile_commands.json");	×
UNCOV 399	db = await this.getCompilationDb(db_path);	×
UNCOV 400	if (!db) {	×
UNCOV 401	return;	×
UNCOV 402	}	×
UNCOV 403		×
UNCOV 404	let info = db.get(uri.fsPath);	×
UNCOV 405	if (!info) {	×
UNCOV 406	return;	×
UNCOV 407	}	×
UNCOV 408		×
UNCOV 409	let args = info.arguments;	×
UNCOV 410	if (args && args.length > 0) {	×
UNCOV 411	return {	×
UNCOV 412	uri: uri,	×
UNCOV 413	configuration: this.getSourceFileConfiguration(args)	×
UNCOV 414	};	×
UNCOV 415	}	×
UNCOV 416	}	×
UNCOV 417	}	×
UNCOV 418	}	×
419		1✔
420	getSourceFileConfiguration(command: string[]): SourceFileConfiguration {	1✔
UNCOV 421	const getAsFlags = (fragments?: string[]) => {	×
UNCOV 422	if (!fragments) {	×
UNCOV 423	return [];	×
UNCOV 424	}	×
UNCOV 425	return [...util.flatMap(fragments, fragment => shlex.split(fragment))];	×
UNCOV 426	};	×
UNCOV 427		×
UNCOV 428	command = new Array<string>(...command); // copy to avoid changing the compilation db	×
UNCOV 429	let compilerPath = util.platformNormalizePath(command.shift()!);	×
UNCOV 430	let compilerFragments = getAsFlags(command);	×
UNCOV 431	let compilerFlags = parseCompileFlags(this._cppToolsApi!.getVersion(), compilerFragments);	×
UNCOV 432	let intelliSenseMode = getIntelliSenseMode(this._cppToolsApi!.getVersion(), compilerPath, compilerFlags.targetArch);	×
UNCOV 433	let configuration: SourceFileConfiguration = {	×
UNCOV 434	compilerPath: compilerPath,	×
UNCOV 435	standard: compilerFlags.standard,	×
UNCOV 436	intelliSenseMode: intelliSenseMode as IntelliSenseMode \|\| undefined,	×
UNCOV 437	includePath: [],	×
UNCOV 438	defines: [],	×
UNCOV 439	compilerFragments: compilerFragments	×
UNCOV 440	}	×
UNCOV 441	return configuration;	×
UNCOV 442	}	×
443		1✔
444	dispose() {	1✔
445	if (this._cppToolsApi) {	1✔
446	this._cppToolsApi.dispose();	1✔
447	}	1✔
448	this.clearDbs();	1✔
449	}	1✔
450	}	1✔

g-arjones / vscode-autoproj / 8943098337

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