extension.ts

import * as vscode from 'vscode';
import * as cp from 'child_process';
import * as path from "path";
import * as xml2js from 'xml2js';

import { runScript } from './util/scripts';
import { resolvePath } from './util/path';

enum SeverityNumber {
    Info = 0,
    Warning = 1,
    Error = 2
}

// If a script generates arguments at extension activation they are saved in dynamicArgs
const dynamicArgs : Array<string> = [];

const criticalWarningTypes = [
    'cppcheckError',
    'cppcheckLimit',
    'includeNestedTooDeeply',
    'internalAstError',
    'instantiationError',
    'internalError',
    'missingFile',
    'premium-internalError',
    'premium-invalidArgument',
    'premium-invalidLicense',
    'preprocessorErrorDirective',
    'syntaxError',
    'unhandledChar',
    'unknownMacro'
];

function parseSeverity(str: string): vscode.DiagnosticSeverity {
    const lower = str.toLowerCase();
    if (lower.includes("error")) {
        return vscode.DiagnosticSeverity.Error;
    } else if (lower.includes("warning")) {
        return vscode.DiagnosticSeverity.Warning;
    } else {
        return vscode.DiagnosticSeverity.Information;
    }
}

function severityToNumber(sev: vscode.DiagnosticSeverity): SeverityNumber {
    switch (sev) {
        case vscode.DiagnosticSeverity.Error: return SeverityNumber.Error;
        case vscode.DiagnosticSeverity.Warning: return SeverityNumber.Warning;
        default: return SeverityNumber.Info;
    }
}

function parseMinSeverity(str: string): SeverityNumber {
    switch (str.toLowerCase()) {
        case "error": return SeverityNumber.Error;
        case "warning": return SeverityNumber.Warning;
        default: return SeverityNumber.Info;
    }
}

// This method is called when your extension is activated.
// Your extension is activated the very first time the command is executed.
export async function activate(context: vscode.ExtensionContext) {

    // Create a diagnostic collection.
    const diagnosticCollection = vscode.languages.createDiagnosticCollection("Cppcheck");
    context.subscriptions.push(diagnosticCollection);
    
    // If an argument requires us to run any scripts we do it here
    const config = vscode.workspace.getConfiguration();
    const args = config.get<string>("cppcheck-official.arguments", "");
    const argsWithScripts = args.split("--").filter((arg) => arg.includes('${'));
    for (const arg of argsWithScripts) {
        // argType will look like e.g. --project
        const argType = arg.split("=")[0];
        const argValue = arg.split("=")[1];
        // Remove ${ from the beginning and slice } away from the end  of argValue
        const scriptCommand = argValue.split("{")[1].split("}")[0];
        const scriptOutput = await runScript(scriptCommand);
        // We expect the script output that we are to set the argument to will be wrapped with ${}
        const scriptOutputPath = scriptOutput.split("${")[1].split("}")[0];
        dynamicArgs.push(`${argType}=${scriptOutputPath}`);
    };
    
    // set up a map of timers per document URI for debounce for continuous analysis triggers
    // I.e. document has been changed -> DEBOUNCE_MS time passed since last change -> run cppcheck
    const debounceTimers: Map<string, NodeJS.Timeout> = new Map();
    const DEBOUNCE_MS = 1000;

    async function handleDocument(document: vscode.TextDocument) {
        // Only process C/C++ files.
        if (!["c", "cpp"].includes(document.languageId)) {
            // Not a C/C++ file, skip
            return;
        }

        // Check if the document is visible in any editor
        const isVisible = vscode.window.visibleTextEditors.some(editor =>
            editor.document.uri.toString().replaceAll('\\', '/') === document.uri.toString().replaceAll('\\', '/'));
        if (!isVisible) {
            // Document is not visible, skip
            return;
        }

        const config = vscode.workspace.getConfiguration();
        const isEnabled = config.get<boolean>("cppcheck-official.enable", true);
        const extraArgs = config.get<string>("cppcheck-official.arguments", "");
        const minSevString = config.get<string>("cppcheck-official.minSeverity", "info");
        const userPath = config.get<string>("cppcheck-official.path")?.trim() || "";
        const commandPath = userPath ? resolvePath(userPath) : "cppcheck";

        // If disabled, clear any existing diagnostics for this doc.
        if (!isEnabled) {
            diagnosticCollection.delete(document.uri);
            return;
        }

        // Check if cppcheck is available
        cp.exec(`"${commandPath}" --version`, (error) => {
            if (error) {
                vscode.window.showErrorMessage(
                    `Cppcheck: Could not find or run '${commandPath}'. ` +
                    `Please install cppcheck or set 'cppcheck-official.path' correctly.`
                );
                return;
            }
        });

        await runCppcheckOnFileXML(
            document,
            commandPath,
            extraArgs,
            minSevString,
            diagnosticCollection
        );
    }

    // TODO: Reimplement continuous analysis. Requires cppcheck update (expected in 2.20)
    async function handleDocumentContinuous(e: vscode.TextDocumentChangeEvent) {
        const document : vscode.TextDocument = e.document;
        const uriKey = document.uri.toString();

        // clear any existing timer for this document
        if (debounceTimers.has(uriKey)) {
            clearTimeout(debounceTimers.get(uriKey)!);
        }

        // schedule a new run
        const timer = setTimeout(async () => {
            debounceTimers.delete(uriKey);
            await handleDocument(document);
        }, DEBOUNCE_MS);
        debounceTimers.set(uriKey, timer);
    }

    // Run cppcheck when document is changed, with debounce
    // vscode.workspace.onDidChangeTextDocument(handleDocumentContinuous, null, context.subscriptions);

    // Listen for file saves.
    vscode.workspace.onDidSaveTextDocument(handleDocument, null, context.subscriptions);

    // Run cppcheck when a file is opened
    vscode.workspace.onDidOpenTextDocument(handleDocument, null, context.subscriptions);

    // Run cppcheck for all open files when the workspace is opened
    vscode.workspace.onDidChangeWorkspaceFolders(() => {
        vscode.workspace.textDocuments.forEach(handleDocument);
    }, null, context.subscriptions);

    // Run cppcheck for all open files at activation (for already opened workspaces)
    vscode.workspace.textDocuments.forEach(handleDocument);

    // Clean up diagnostics when a file is closed
    vscode.workspace.onDidCloseTextDocument((document: vscode.TextDocument) => {
        diagnosticCollection.delete(document.uri);
    }, null, context.subscriptions);
}

async function runCppcheckOnFileXML(
    document: vscode.TextDocument,
    commandPath: string,
    extraArgs: string,
    minSevString: string,
    diagnosticCollection: vscode.DiagnosticCollection
): Promise<void> {
    // Clear existing diagnostics for this file
    diagnosticCollection.delete(document.uri);

    // Replace backslashes (used in paths in Windows environment)
    const filePath = document.fileName.replaceAll('\\', '/');
    const minSevNum = parseMinSeverity(minSevString);

    // Arguments specified with scripts are replaced with script output (dynamicArgs)
    const staticArgs = extraArgs.split("--").filter((arg) => !arg.includes("${"));
    const allArgs = staticArgs.concat(dynamicArgs);
    // Resolve paths for arguments where applicable
    const extraArgsParsed = allArgs.map((arg) => {
        if (arg.startsWith('project')) {
            const splitArg = arg.split('=');
            return `--${splitArg[0]}=${resolvePath(splitArg[1])}`;
        }
        return arg;
    });

    let proc;
    if (extraArgs.includes("--project")) {
        const args = [
            '--enable=all',
            '--inline-suppr',
            '--xml',
            '--suppress=unusedFunction',
            '--suppress=missingInclude',
            '--suppress=missingIncludeSystem',
            `--file-filter=${filePath}`,
            ...extraArgsParsed,
        ].filter(Boolean);
        proc = cp.spawn(commandPath, args, {
            cwd: path.dirname(document.fileName),
        });
    } else {
        const args = [
            '--enable=all',
            '--inline-suppr',
            '--xml',
            '--suppress=unusedFunction',
            '--suppress=missingInclude',
            '--suppress=missingIncludeSystem',
            ...extraArgsParsed,
            filePath,
        ].filter(Boolean);
        proc = cp.spawn(commandPath, args, {
            cwd: path.dirname(document.fileName),
        });
    }

    // if spawn fails (e.g. ENOENT or permission denied)
    proc.on("error", (err) => {
        console.error("Failed to start cppcheck:", err);
        vscode.window.showErrorMessage(`Cppcheck failed to start: ${err.message}`);
    });

    let xmlOutput = "";
    let out = "";
    proc.stderr.on("data", d => xmlOutput += d.toString());
    proc.stdout.on("data", d => out += d.toString());
    proc.on("close", code => {
        if (code && code > 0) {
            // Non-zero code means an error has occured
            let errorMessage = `Cppcheck failed with code ${code} (unknown error)`;
            if (out.trim().length > 0) {
                errorMessage = out.trim();
            }
            vscode.window.showErrorMessage(errorMessage);
        }
        const parser = new xml2js.Parser({ explicitArray: true });
        parser.parseString(xmlOutput, (err, result) => {
            if (err) {
                console.error("XML parse error:", err);
                return;
            }

            const errors = result.results?.errors?.[0]?.error || [];
            const diagnostics: vscode.Diagnostic[] = [];

            for (const e of errors) {
                const isCriticalError = criticalWarningTypes.includes(e.$.id);
                const locations = e.location || [];
                if (!locations.length) {
                    continue;
                }

                const mainLoc = locations[locations.length - 1].$;
                
                // If main location is not current file, then skip displaying warning unless it is critical
                if (!isCriticalError && !filePath.endsWith(mainLoc.file)) {
                    continue;
                }

                // Cppcheck line number is 1-indexed, while VS Code uses 0-indexing
                let line = Number(mainLoc.line) - 1;
                // Invalid line number usually means non-analysis output 
                if (isNaN(line) || line < 0 || line >= document.lineCount) {
                    if (isCriticalError) {
                        line = 0;
                    } else {
                        continue;
                    }
                }

                // Cppcheck col number is 1-indexed, while VS Code uses 0-indexing
                let col = Number(mainLoc.column) - 1;
                if (isNaN(col) || col < 0 || col > document.lineAt(line).text.length) {
                    col = 0;
                }

                const severity = parseSeverity(e.$.severity);
                if (!isCriticalError && severityToNumber(severity) < minSevNum) {
                    continue;
                }

                const range = new vscode.Range(line, col, line, document.lineAt(line).text.length);
                const diagnostic = new vscode.Diagnostic(range, e.$.msg, severity);
                diagnostic.source = "cppcheck";
                diagnostic.code = e.$.id;

                // Related Information
                const relatedInfos: vscode.DiagnosticRelatedInformation[] = [];
                for (let i = 1; i <= locations.length; i++) {
                    // Related information is ordered in reverse in XML object
                    const loc = locations[locations.length - i].$;
                    const msg = loc.info;
                    const lLine = Number(loc.line) - 1;
                    const lCol = Number(loc.col) - 1;

                    if (msg === null || msg === undefined || isNaN(lLine) || lLine < 0 || lLine >= document.lineCount) {
                        continue;
                    }

                    const relatedRange = new vscode.Range(
                        lLine, lCol,
                        lLine, document.lineAt(lLine).text.length
                    );

                    relatedInfos.push(
                        new vscode.DiagnosticRelatedInformation(
                            new vscode.Location(document.uri, relatedRange),
                            msg
                        )
                    );
                }
                if (relatedInfos.length > 0) {
                    diagnostic.relatedInformation = relatedInfos;
                }
                diagnostics.push(diagnostic);
            }
            diagnosticCollection.set(document.uri, diagnostics);
        });
    });
}

// This method is called when your extension is deactivated
export function deactivate() {}