logcompact-builtins 0.3.0

Deterministic compiler, linter, runtime, and test log parsers
Documentation
use crate::{Diagnostic, DiagnosticClass, Location, Severity};

use super::common::{bounded_text, normalize_path, split_u32_prefix};

pub(super) fn reduce_linker(input: &str, diagnostics: &mut Vec<Diagnostic>) {
    let mut parser = CppLinkerDiagnosticParser::default();
    for line in input.lines() {
        if let Some(diagnostic) = parser.observe_line(line) {
            diagnostics.push(diagnostic);
        }
    }
}

pub(crate) fn parse_diagnostic(line: &str) -> Option<Diagnostic> {
    let line = line
        .trim()
        .strip_prefix("ERROR: ")
        .unwrap_or_else(|| line.trim());
    let (path, line_number, column, message) =
        parse_colon_location(line).or_else(|| parse_parenthesized_location(line))?;
    if path.contains(": ") {
        return None;
    }
    let (severity, message) = parse_severity_message(message)?;
    Some(Diagnostic {
        severity,
        class: DiagnosticClass::Compiler,
        code: None,
        provenance: None,
        message: message.to_owned(),
        location: Some(Location {
            path: compact_path(path),
            line: Some(line_number),
            column,
            end_line: None,
            end_column: None,
        }),
        quality: crate::EvidenceQuality::Located,
        repetition_count: 1,
    })
}

fn parse_colon_location(line: &str) -> Option<(&str, u32, Option<u32>, &str)> {
    let path_end = path_end(line, ':')?;
    let (line_number, remainder) = split_u32_prefix(&line[path_end + 1..])?;
    let (column, message) = split_u32_prefix(remainder)
        .map_or((None, remainder), |(column, message)| {
            (Some(column), message)
        });
    Some((&line[..path_end], line_number, column, message))
}

fn parse_parenthesized_location(line: &str) -> Option<(&str, u32, Option<u32>, &str)> {
    let path_end = path_end(line, '(')?;
    let remainder = line[path_end..].strip_prefix('(')?;
    let (coordinates, message) = remainder
        .split_once("): ")
        .or_else(|| remainder.split_once("):"))?;
    let (line_number, column) = coordinates.split_once(',').map_or_else(
        || (coordinates.trim().parse::<u32>().ok(), None),
        |(line_number, column)| {
            (
                line_number.trim().parse::<u32>().ok(),
                column.trim().parse::<u32>().ok(),
            )
        },
    );
    Some((&line[..path_end], line_number?, column, message))
}

fn parse_severity_message(message: &str) -> Option<(Severity, &str)> {
    let message = message.trim();
    for (marker, severity) in [
        ("fatal error", Severity::Error),
        ("error", Severity::Error),
        ("warning", Severity::Warning),
        ("note", Severity::Note),
    ] {
        let Some(remainder) = message.strip_prefix(marker) else {
            continue;
        };
        let remainder = remainder
            .strip_prefix(':')
            .or_else(|| remainder.strip_prefix(' '))?
            .trim();
        if !remainder.is_empty() {
            return Some((severity, remainder));
        }
    }
    None
}

pub(crate) fn path_end(line: &str, delimiter: char) -> Option<usize> {
    const EXTENSIONS: [&str; 19] = [
        ".cpp", ".cxx", ".c++", ".cc", ".hpp", ".hxx", ".h++", ".hh", ".ipp", ".tpp", ".inc",
        ".cuh", ".cu", ".mm", ".m", ".C", ".H", ".c", ".h",
    ];
    EXTENSIONS
        .iter()
        .filter_map(|extension| {
            line.rmatch_indices(extension).find_map(|(index, _)| {
                let path_end = index + extension.len();
                line[path_end..].starts_with(delimiter).then_some(path_end)
            })
        })
        .max()
}

#[derive(Debug, Default)]
struct CppLinkerDiagnosticParser {
    apple_undefined_symbols: bool,
    symbols_seen: usize,
}

impl CppLinkerDiagnosticParser {
    const MAX_SYMBOLS: usize = 64;

    fn observe_line(&mut self, line: &str) -> Option<Diagnostic> {
        let line = line.trim();
        if line.starts_with("Undefined symbols for architecture ") {
            self.apple_undefined_symbols = true;
            return None;
        }
        if self.apple_undefined_symbols {
            if let Some(symbol) = parse_apple_undefined_symbol(line) {
                if self.symbols_seen >= Self::MAX_SYMBOLS {
                    return None;
                }
                self.symbols_seen = self.symbols_seen.saturating_add(1);
                return Some(linker_diagnostic(
                    format!("undefined symbol: {}", bounded_text(symbol, 1_000)),
                    None,
                ));
            }
            if line.starts_with("ld:") || line.starts_with("clang:") {
                self.apple_undefined_symbols = false;
            }
        }
        parse_linker_diagnostic(line)
    }
}

fn parse_apple_undefined_symbol(line: &str) -> Option<&str> {
    let symbol = line.strip_prefix('"')?;
    let (symbol, _) = symbol.split_once("\", referenced from:")?;
    (!symbol.is_empty()).then_some(symbol)
}

pub(crate) fn parse_linker_diagnostic(line: &str) -> Option<Diagnostic> {
    let line = line.trim();
    if let Some(index) = line.find("undefined reference to ") {
        let symbol = trim_linker_symbol(&line[index + "undefined reference to ".len()..]);
        if symbol.is_empty() {
            return None;
        }
        return Some(linker_diagnostic(
            format!("undefined reference to {symbol}"),
            parse_linker_location(&line[..index]),
        ));
    }
    if let Some(index) = line.find("undefined symbol:") {
        let symbol = trim_linker_symbol(&line[index + "undefined symbol:".len()..]);
        if symbol.is_empty() {
            return None;
        }
        return Some(linker_diagnostic(
            format!("undefined symbol: {symbol}"),
            None,
        ));
    }
    if let Some(index) = line.find("unresolved external symbol ") {
        let remainder = &line[index + "unresolved external symbol ".len()..];
        let symbol = remainder
            .split_once(" referenced in ")
            .map_or(remainder, |(symbol, _)| symbol)
            .trim();
        if symbol.is_empty() {
            return None;
        }
        return Some(linker_diagnostic(
            format!("unresolved external symbol {symbol}"),
            None,
        ));
    }
    None
}

fn parse_linker_location(prefix: &str) -> Option<Location> {
    let path_end = path_end(prefix, ':')?;
    let (line_number, _) = split_u32_prefix(&prefix[path_end + 1..])?;
    let path = prefix[..path_end]
        .rsplit_once(": ")
        .map_or(&prefix[..path_end], |(_, path)| path);
    Some(Location {
        path: compact_path(path),
        line: Some(line_number),
        column: None,
        end_line: None,
        end_column: None,
    })
}

fn trim_linker_symbol(symbol: &str) -> &str {
    symbol
        .trim()
        .trim_end_matches(':')
        .trim_matches(|character| matches!(character, '`' | '\'' | '"'))
}

fn linker_diagnostic(message: String, location: Option<Location>) -> Diagnostic {
    Diagnostic {
        severity: Severity::Error,
        class: DiagnosticClass::Compiler,
        code: None,
        provenance: None,
        message,
        location,
        quality: crate::EvidenceQuality::Structured,
        repetition_count: 1,
    }
}

fn compact_path(path: &str) -> String {
    normalize_path(path)
}