logcompact-builtins 0.4.0

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

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

pub(crate) fn reduce(input: &str, diagnostics: &mut Vec<Diagnostic>) {
    diagnostics.extend(parse_diagnostics(input));
}

fn parse_diagnostics(input: &str) -> Vec<Diagnostic> {
    const MAX_CONTEXT_LINES: usize = 8;
    let lines = input.lines().collect::<Vec<_>>();
    let mut diagnostics = Vec::new();
    for (index, line) in lines.iter().enumerate() {
        let Some(mut diagnostic) = parse_diagnostic(line) else {
            continue;
        };
        if diagnostic
            .message
            .eq_ignore_ascii_case("cannot find symbol")
        {
            for context in lines.iter().skip(index + 1).take(MAX_CONTEXT_LINES) {
                if parse_diagnostic(context).is_some() || context.trim_start().starts_with("ERROR:")
                {
                    break;
                }
                if let Some(symbol) = context.trim().strip_prefix("symbol:") {
                    diagnostic.message = format!(
                        "cannot find symbol: {}",
                        symbol.split_whitespace().collect::<Vec<_>>().join(" ")
                    );
                    break;
                }
            }
        }
        diagnostics.push(diagnostic);
    }
    diagnostics
}

pub(crate) fn parse_diagnostic(line: &str) -> Option<Diagnostic> {
    let marker = line.rfind(".java:")?;
    let path_end = marker + ".java".len();
    let path = line[..path_end]
        .trim()
        .strip_prefix("ERROR: ")
        .unwrap_or_else(|| line[..path_end].trim());
    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)
        });
    let message = message.trim();
    let (severity, message) = if let Some(message) = message.strip_prefix("error:") {
        (Severity::Error, message.trim())
    } else {
        let message = message.strip_prefix("warning:")?;
        (Severity::Warning, message.trim())
    };
    if message.is_empty() {
        return None;
    }
    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 compact_path(path: &str) -> String {
    normalize_path(path)
}