hypen_parser/

error.rs

use ariadne::{Color, Label, Report, ReportKind, Source};
use chumsky::error::Rich;
use std::ops::Range;

/// Check if an expected pattern is noise that should be filtered out
fn is_noise_pattern(s: &str) -> bool {
    s.contains("whitespace")
        || s.contains("end of input")
        || s == "something else"
        || s.contains("'/'")
}

/// Find the position of the last unmatched opening delimiter
fn find_unmatched_opener(source: &str, open: char, close: char) -> Option<usize> {
    let mut stack = Vec::new();
    let mut in_string = false;

    for (i, ch) in source.char_indices() {
        if ch == '"' {
            in_string = !in_string;
        } else if !in_string {
            if ch == open {
                stack.push(i);
            } else if ch == close {
                stack.pop();
            }
        }
    }

    stack.last().copied()
}

/// Find the position of an unclosed string literal
fn find_unclosed_string(source: &str) -> Option<usize> {
    let mut in_string = false;
    let mut string_start = 0;

    for (i, ch) in source.char_indices() {
        if ch == '"' {
            if !in_string {
                in_string = true;
                string_start = i;
            } else {
                in_string = false;
            }
        }
    }

    if in_string { Some(string_start) } else { None }
}

/// Detected error with message, hint, and source location
struct DetectedError {
    message: String,
    hint: Option<String>,
    span: Option<Range<usize>>,
}

/// Find pattern in source, returning position
fn find_pattern(source: &str, pattern: &str) -> Option<usize> {
    source.find(pattern)
}

/// Analyze source to detect common error patterns
fn detect_error(source: &str) -> Option<DetectedError> {
    // Priority 1: Unclosed string
    if let Some(pos) = find_unclosed_string(source) {
        return Some(DetectedError {
            message: "unclosed string literal".into(),
            hint: Some("add a closing '\"' to complete the string".into()),
            span: Some(pos..pos + 1),
        });
    }

    // Priority 2: Unclosed parentheses
    if let Some(pos) = find_unmatched_opener(source, '(', ')') {
        return Some(DetectedError {
            message: "unclosed parentheses".into(),
            hint: Some("add a closing ')' to complete the argument list".into()),
            span: Some(pos..pos + 1),
        });
    }

    // Priority 3: Unclosed braces
    if let Some(pos) = find_unmatched_opener(source, '{', '}') {
        return Some(DetectedError {
            message: "unclosed block".into(),
            hint: Some("add a closing '}' to complete the block".into()),
            span: Some(pos..pos + 1),
        });
    }

    // Priority 4: Unclosed brackets
    if let Some(pos) = find_unmatched_opener(source, '[', ']') {
        return Some(DetectedError {
            message: "unclosed list".into(),
            hint: Some("add a closing ']' to complete the list".into()),
            span: Some(pos..pos + 1),
        });
    }

    // Priority 5: Missing value after colon (e.g., "key: ,")
    if let Some(pos) = find_pattern(source, ": ,") {
        return Some(DetectedError {
            message: "missing value after ':'".into(),
            hint: Some("add a value after the colon".into()),
            span: Some(pos..pos + 3),
        });
    }

    // Priority 6: Double comma (e.g., "a, , b")
    if let Some(pos) = find_pattern(source, ", ,") {
        return Some(DetectedError {
            message: "unexpected ','".into(),
            hint: Some("remove the extra comma or add a value".into()),
            span: Some(pos + 2..pos + 3),
        });
    }

    // Priority 7: Comma at start of arguments (e.g., "(, a)")
    if let Some(pos) = find_pattern(source, "(,") {
        return Some(DetectedError {
            message: "unexpected ',' at start of arguments".into(),
            hint: Some("remove the leading comma".into()),
            span: Some(pos + 1..pos + 2),
        });
    }

    None
}

/// Format error from Chumsky's expected tokens (fallback when we can't detect the pattern)
fn format_from_expected(found: Option<&char>, expected: &[String]) -> String {
    let useful: Vec<_> = expected
        .iter()
        .filter(|s| !is_noise_pattern(s))
        .take(3)
        .collect();

    match found {
        Some(ch) if useful.is_empty() => format!("unexpected '{}'", ch),
        Some(ch) => format!("unexpected '{}', expected {}", ch, useful.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(" or ")),
        None if useful.is_empty() => "unexpected end of input".into(),
        None => format!("unexpected end of input, expected {}", useful.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(" or ")),
    }
}

/// Pretty-print parse errors using Ariadne
pub fn print_parse_errors(filename: &str, source: &str, errors: &[Rich<char>]) {
    for error in errors {
        let default_span = error.span().into_range();

        // Try to detect the error pattern from source analysis
        let (msg, hint, span) = if let Some(detected) = detect_error(source) {
            (detected.message, detected.hint, detected.span.unwrap_or(default_span))
        } else {
            // Fallback: use Chumsky's expected tokens
            let expected: Vec<String> = error.expected().map(|e| format!("{}", e)).collect();
            (format_from_expected(error.found(), &expected), None, default_span)
        };

        let mut report = Report::build(ReportKind::Error, filename, span.start)
            .with_message("Parse error")
            .with_label(
                Label::new((filename, span))
                    .with_message(&msg)
                    .with_color(Color::Red),
            );

        if let Some(hint_msg) = hint {
            report = report.with_help(hint_msg);
        }

        report
            .finish()
            .print((filename, Source::from(source)))
            .unwrap();
    }
}

/// Format parse errors as a string without printing
pub fn format_parse_errors(filename: &str, source: &str, errors: &[Rich<char>]) -> String {
    let mut output = Vec::new();

    for error in errors {
        let default_span = error.span().into_range();

        let (msg, hint, span) = if let Some(detected) = detect_error(source) {
            (detected.message, detected.hint, detected.span.unwrap_or(default_span))
        } else {
            let expected: Vec<String> = error.expected().map(|e| format!("{}", e)).collect();
            (format_from_expected(error.found(), &expected), None, default_span)
        };

        let mut report = Report::build(ReportKind::Error, filename, span.start)
            .with_message("Parse error")
            .with_label(
                Label::new((filename, span))
                    .with_message(&msg)
                    .with_color(Color::Red),
            );

        if let Some(hint_msg) = hint {
            report = report.with_help(hint_msg);
        }

        report
            .finish()
            .write((filename, Source::from(source)), &mut output)
            .unwrap();
    }

    String::from_utf8(output).unwrap()
}

/// Simple error formatting without Ariadne (for tests and simple output)
pub fn format_error_simple(error: &Rich<char>) -> String {
    let expected: Vec<String> = error
        .expected()
        .map(|e| format!("{}", e))
        .filter(|s| !is_noise_pattern(s))
        .take(5)
        .collect();

    match error.found() {
        Some(ch) if expected.is_empty() => {
            format!("unexpected '{}' at position {}", ch, error.span().start)
        }
        Some(ch) => {
            format!("unexpected '{}' at position {}, expected {}", ch, error.span().start, expected.join(" or "))
        }
        None if expected.is_empty() => {
            format!("unexpected end of input at position {}", error.span().start)
        }
        None => {
            format!("unexpected end of input at position {}, expected {}", error.span().start, expected.join(" or "))
        }
    }
}