litnik 0.1.0

A Rust-native, libtest-mimic integrated runner for LLVM/MLIR-style lit tests.
Documentation
use std::collections::{HashMap, HashSet};
use std::path::Path;

use crate::boolean_expression;
use crate::substitution::{CommandDirective, ScriptDirective, SubstitutionDirective};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ParserKind {
    Command,
    BooleanExpr,
    Integer,
    Tag,
    Define,
    Redefine,
}

#[derive(Debug, Clone)]
struct ParserState {
    kind: ParserKind,
    values: Vec<String>,
}

impl ParserState {
    fn new(kind: ParserKind) -> Self {
        Self {
            kind,
            values: Vec::new(),
        }
    }

    fn append<I>(&mut self, items: I)
    where
        I: IntoIterator<Item = String>,
    {
        self.values.extend(items);
    }
}

#[derive(Debug, Clone)]
pub struct ParsedIntegrated {
    pub directives: Vec<ScriptDirective>,
    pub xfails: Vec<String>,
    pub requires: Vec<String>,
    pub unsupported: Vec<String>,
    pub allow_retries: usize,
}

pub fn parse_integrated_test_script(path: &Path) -> Result<ParsedIntegrated, String> {
    let data = match std::fs::read(path) {
        Ok(bytes) => String::from_utf8_lossy(&bytes).to_string(),
        Err(error) => return Err(error.to_string()),
    };

    let keywords = [
        "RUN:",
        "XFAIL:",
        "REQUIRES:",
        "UNSUPPORTED:",
        "ALLOW_RETRIES:",
        "END.",
        "DEFINE:",
        "REDEFINE:",
    ];

    let mut parsers: HashMap<&str, ParserState> = HashMap::from([
        ("RUN:", ParserState::new(ParserKind::Command)),
        ("XFAIL:", ParserState::new(ParserKind::BooleanExpr)),
        ("REQUIRES:", ParserState::new(ParserKind::BooleanExpr)),
        ("UNSUPPORTED:", ParserState::new(ParserKind::BooleanExpr)),
        ("ALLOW_RETRIES:", ParserState::new(ParserKind::Integer)),
        ("END.", ParserState::new(ParserKind::Tag)),
        ("DEFINE:", ParserState::new(ParserKind::Define)),
        ("REDEFINE:", ParserState::new(ParserKind::Redefine)),
    ]);

    let mut directives = Vec::new();
    let mut end_reached = false;

    for (line_no, raw_line) in data.lines().enumerate() {
        let line = raw_line.trim_end_matches('\r');
        let mut cursor = 0usize;
        let line_number = line_no + 1;

        while let Some((offset, keyword)) = find_next_keyword(&line[cursor..], &keywords) {
            let absolute_offset = cursor + offset;
            let line_tail = &line[absolute_offset + keyword.len()..];

            let parser = parsers
                .get_mut(keyword)
                .ok_or_else(|| format!("unknown keyword '{keyword}' in parsed line"))?;

            match parser.kind {
                ParserKind::Command => {
                    let body = substitute_line_numbers(line_number, line_tail);
                    if !directives.is_empty() {
                        if let Some(ScriptDirective::Command(prev)) = directives.last_mut() {
                            if prev.add_continuation(line_number, keyword, &body) {
                                cursor = absolute_offset + keyword.len() + line_tail.len();
                                continue;
                            }
                        }
                    }
                    directives.push(ScriptDirective::Command(CommandDirective {
                        start_line: line_number,
                        end_line: line_number,
                        keyword: keyword.to_string(),
                        command: body,
                    }));
                }
                ParserKind::Define | ParserKind::Redefine => {
                    let body = substitute_line_numbers(line_number, line_tail);
                    if !directives.is_empty() {
                        if let Some(ScriptDirective::Substitution(prev)) = directives.last_mut() {
                            if prev.add_continuation(line_number, keyword, &body) {
                                cursor = absolute_offset + keyword.len() + line_tail.len();
                                continue;
                            }
                        }
                    }
                    let new_subst = matches!(parser.kind, ParserKind::Define);
                    let directive =
                        SubstitutionDirective::new(line_number, keyword, new_subst, &body)?;
                    directives.push(ScriptDirective::Substitution(directive));
                }
                ParserKind::BooleanExpr => {
                    let mut values = parse_comma_list(line_tail)
                        .into_iter()
                        .map(|value| value.trim().to_string())
                        .filter(|value| !value.is_empty())
                        .collect::<Vec<_>>();

                    if parser
                        .values
                        .last()
                        .is_some_and(|prev| prev.ends_with('\\'))
                    {
                        let mut merged = parser.values.pop().unwrap_or_default();
                        merged = merged.trim_end_matches('\\').to_string();
                        if let Some(first) = values.first_mut() {
                            let mut merged_line = merged.clone();
                            merged_line.push_str(first);
                            *first = merged_line;
                        }
                    }

                    for value in &values {
                        if value == "*" || value.ends_with('\\') {
                            continue;
                        }
                        boolean_expression::evaluate(value, &HashSet::new()).map_err(|err| {
                            format!(
                                "invalid boolean expression in {} directive on line {}: {err}",
                                keyword, line_number
                            )
                        })?;
                    }

                    parser.append(values);
                }
                ParserKind::Integer => {
                    if !parser.values.is_empty() {
                        return Err(format!(
                            "Test has more than one ALLOW_RETRIES line (at line {})",
                            line_number
                        ));
                    }
                    let value = line_tail.trim();
                    if value.is_empty() {
                        continue;
                    }
                    value.parse::<usize>().map_err(|_| {
                        format!(
                            "invalid ALLOW_RETRIES value in line {}: '{}'",
                            line_number, value
                        )
                    })?;
                    parser.append(std::iter::once(value.to_string()));
                }
                ParserKind::Tag => {
                    if !line_tail.trim().is_empty() {
                        return Err(format!(
                            "END. only accepts empty value at line {line_number}"
                        ));
                    }
                    parser.append(std::iter::once("END".to_string()));
                    end_reached = true;
                }
            }

            cursor = absolute_offset + keyword.len() + line_tail.len();
            if cursor >= line.len() {
                break;
            }

            if end_reached {
                break;
            }
        }

        if end_reached {
            break;
        }
    }

    let Some(first_parser) = parsers.get_mut("RUN:") else {
        return Err("internal parser state missing RUN parser".to_string());
    };
    if first_parser.values.is_empty() && directives.is_empty() {
        return Err("Test has no 'RUN:' line".to_string());
    }

    for directive in &directives {
        match directive {
            ScriptDirective::Command(cmd) if cmd.needs_continuation() => {
                return Err(format!(
                    "Test has unterminated '{}' at line {}",
                    cmd.keyword, cmd.start_line
                ));
            }
            ScriptDirective::Substitution(subst) if subst.needs_continuation() => {
                return Err(format!(
                    "Test has unterminated '{}' at line {}",
                    subst.keyword, subst.start_line
                ));
            }
            _ => {}
        }
    }

    for (keyword, parser) in &parsers {
        if !matches!(parser.kind, ParserKind::BooleanExpr) {
            continue;
        }

        match parser.values.last() {
            Some(last) if last.ends_with('\\') => {
                return Err(format!(
                    "Test has unterminated '{keyword}' lines (with '\\')"
                ));
            }
            _ => {}
        }
    }

    let xfails = parsers
        .get("XFAIL:")
        .map(|p| p.values.clone())
        .unwrap_or_default();
    let requires = parsers
        .get("REQUIRES:")
        .map(|p| p.values.clone())
        .unwrap_or_default();
    let unsupported = parsers
        .get("UNSUPPORTED:")
        .map(|p| p.values.clone())
        .unwrap_or_default();

    let allow_retries = parsers
        .get("ALLOW_RETRIES:")
        .and_then(|parser| parser.values.first())
        .and_then(|raw| raw.parse::<usize>().ok())
        .unwrap_or_default();

    Ok(ParsedIntegrated {
        directives,
        xfails,
        requires,
        unsupported,
        allow_retries,
    })
}

fn parse_comma_list(text: &str) -> Vec<String> {
    text.split(',')
        .map(|value| value.trim().to_string())
        .collect()
}

fn find_next_keyword<'a>(line: &'a str, keywords: &[&'a str]) -> Option<(usize, &'a str)> {
    let mut best: Option<(usize, &str)> = None;

    for keyword in keywords {
        if let Some(pos) = line.find(keyword) {
            match best {
                None => best = Some((pos, keyword)),
                Some((best_pos, _)) => {
                    if pos < best_pos {
                        best = Some((pos, keyword));
                    }
                }
            }
        }
    }

    best
}

fn substitute_line_numbers(line_number: usize, line: &str) -> String {
    crate::substitution::substitute_line_numbers(line_number, line)
}

#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::parse_integrated_test_script;

    #[test]
    fn parse_run_and_requires() {
        let dir = tempdir().unwrap();
        let path = dir.path().join("a.mlir");
        std::fs::write(
            &path,
            "// RUN: echo foo \\\n// RUN: && echo bar\n// REQUIRES: linux\n",
        )
        .unwrap();

        let parsed = parse_integrated_test_script(&path).unwrap();
        assert_eq!(parsed.requires, vec!["linux".to_string()]);
        assert_eq!(parsed.directives.len(), 1);
    }

    #[test]
    fn parse_define_and_redefine() {
        let dir = tempdir().unwrap();
        let path = dir.path().join("b.mlir");
        std::fs::write(
            &path,
            "// DEFINE: %{X}=1\n// REDEFINE: %{X}=2\n// RUN: echo %{X}\n",
        )
        .unwrap();

        let parsed = parse_integrated_test_script(&path).unwrap();
        assert!(parsed.directives.len() >= 3);
    }

    #[test]
    fn parse_allow_retries_rejects_duplicates() {
        let dir = tempdir().unwrap();
        let path = dir.path().join("c.mlir");
        std::fs::write(
            &path,
            "// RUN: true\n// ALLOW_RETRIES: 2\n// ALLOW_RETRIES: 1\n",
        )
        .unwrap();

        let err = parse_integrated_test_script(&path).unwrap_err();
        assert!(err.contains("more than one ALLOW_RETRIES"));
    }

    #[test]
    fn parse_unterminated_define_is_rejected() {
        let dir = tempdir().unwrap();
        let path = dir.path().join("d.mlir");
        std::fs::write(&path, "// DEFINE: %{X}=1\\\n").unwrap();
        let err = parse_integrated_test_script(&path).unwrap_err();
        assert!(
            err.contains("unterminated") || err.contains("line 1"),
            "{err}"
        );
    }
}