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}"
);
}
}