litnik 0.2.1

An embedded Lit and FileCheck runner for compiler test suites.
Documentation
use crate::shell::ast::{Arg, Command, Pipeline, Redirect, ScriptNode, SeqOp};
use crate::shell::lexer::{Lexer, Symbol, Token};

/// Parses Lit's restricted shell syntax into a [`ScriptNode`].
///
/// Parsing preserves whether wildcard characters were quoted so execution can
/// apply pathname expansion without changing literal arguments. The parser
/// represents `&` and every recognized redirection in the syntax tree even
/// when the executor rejects that operation.
#[derive(Debug)]
pub struct ShParser {
    lexer: Lexer,
    lookahead: Option<Token>,
    pipefail: bool,
}

impl ShParser {
    /// Creates a parser for one shell expression.
    ///
    /// `pipefail` is recorded on every parsed pipeline. `win32_escapes`
    /// controls whether unquoted backslashes are path separators or escapes.
    pub fn new(data: &str, win32_escapes: bool, pipefail: bool) -> Self {
        Self {
            lexer: Lexer::new(data, win32_escapes),
            lookahead: None,
            pipefail,
        }
    }

    /// Parses the complete input.
    ///
    /// # Errors
    ///
    /// Returns an error when an operator lacks an operand, a command is empty,
    /// or a redirection is incomplete.
    pub fn parse(&mut self) -> Result<ScriptNode, String> {
        let mut node = self.parse_pipeline()?;
        while let Some(op) = self.peek()? {
            let seq_op = match op {
                Token::Symbol(Symbol::Semicolon) => SeqOp::Semicolon,
                Token::Symbol(Symbol::Ampersand) => SeqOp::Ampersand,
                Token::Symbol(Symbol::OrOr) => SeqOp::Or,
                Token::Symbol(Symbol::AndAnd) => SeqOp::And,
                _ => break,
            };
            self.next()?;
            if self.peek()?.is_none() {
                if seq_op == SeqOp::Semicolon {
                    return Ok(node);
                }
                return Err("missing argument to operator".to_string());
            }
            let rhs = self.parse_pipeline()?;
            node = ScriptNode::Seq(Box::new(node), seq_op, Box::new(rhs));
        }
        Ok(node)
    }

    fn parse_pipeline(&mut self) -> Result<ScriptNode, String> {
        let mut commands = vec![self.parse_command()?];
        while self.peek()? == Some(Token::Symbol(Symbol::Pipe)) {
            self.next()?;
            commands.push(self.parse_command()?);
        }
        Ok(ScriptNode::Pipeline(Pipeline {
            commands,
            negate: false,
            pipe_fail: self.pipefail,
        }))
    }

    fn parse_command(&mut self) -> Result<Command, String> {
        let mut args = Vec::new();
        let mut redirects = Vec::new();
        let mut have_command = false;

        while let Some(tok) = self.peek()? {
            match tok {
                Token::Word(_) => {
                    let word = self
                        .next()?
                        .to_word()
                        .ok_or_else(|| "internal parser error".to_string())?;
                    self.append_word_or_redirect(&mut args, &mut redirects, word)?;
                    have_command = true;
                }
                Token::Symbol(Symbol::Redirect(_)) => {
                    let redirect = self.next()?;
                    let op = redirect
                        .to_redirect()
                        .ok_or_else(|| "expected redirect".to_string())?;
                    self.append_redirect(&mut redirects, None, op)?;
                }
                Token::Symbol(Symbol::Semicolon)
                | Token::Symbol(Symbol::Ampersand)
                | Token::Symbol(Symbol::OrOr)
                | Token::Symbol(Symbol::AndAnd)
                | Token::Symbol(Symbol::Pipe) => break,
                Token::Eof => break,
            }
        }

        if !have_command {
            return Err("empty command".to_string());
        }
        Ok(Command { args, redirects })
    }

    fn append_word_or_redirect(
        &mut self,
        args: &mut Vec<Arg>,
        redirects: &mut Vec<Redirect>,
        word: Arg,
    ) -> Result<(), String> {
        if Self::word_is_redirect_prefix(word.as_str())
            && matches!(self.peek()?, Some(Token::Symbol(Symbol::Redirect(_))))
        {
            let source_fd = word
                .parse::<usize>()
                .map_err(|_| "bad redirect prefix".to_string())?;
            let op = self
                .next()?
                .to_redirect()
                .ok_or_else(|| "expected redirect after prefix".to_string())?;
            self.append_redirect(redirects, Some(source_fd), op)?;
            return Ok(());
        }

        args.push(word);
        Ok(())
    }

    fn append_redirect(
        &mut self,
        redirects: &mut Vec<Redirect>,
        source_fd: Option<usize>,
        op: String,
    ) -> Result<(), String> {
        let has_source = source_fd.is_some();
        let op = if has_source && op == "&>" {
            ">&".to_string()
        } else {
            op
        };

        let target = self
            .next()?
            .to_word()
            .ok_or_else(|| "redirection target missing".to_string())?;

        let source_fd = source_fd.unwrap_or_else(|| Redirect::default_source_fd(&op));
        redirects.push(Redirect {
            source_fd,
            op,
            target,
        });
        Ok(())
    }

    fn word_is_redirect_prefix(word: &str) -> bool {
        !word.is_empty() && word.chars().all(|c| c.is_ascii_digit())
    }

    fn next(&mut self) -> Result<Token, String> {
        if let Some(tok) = self.lookahead.take() {
            Ok(tok)
        } else {
            self.lexer.next_token()
        }
    }

    fn peek(&mut self) -> Result<Option<Token>, String> {
        if self.lookahead.is_none() {
            let tok = self.lexer.next_token()?;
            if tok == Token::Eof {
                return Ok(None);
            }
            self.lookahead = Some(tok);
        }
        Ok(self.lookahead.clone())
    }
}

impl Redirect {
    fn default_source_fd(op: &str) -> usize {
        match op {
            "<" | "<&" | "<<" => 0,
            "&>" | ">" | ">>" | ">&" => 1,
            _ => 1,
        }
    }
}

trait TokenExt {
    fn to_word(self) -> Option<Arg>;
    fn to_redirect(self) -> Option<String>;
}

impl TokenExt for Token {
    fn to_word(self) -> Option<Arg> {
        match self {
            Token::Word(w) => Some(w),
            _ => None,
        }
    }

    fn to_redirect(self) -> Option<String> {
        match self {
            Token::Symbol(Symbol::Redirect(op)) => Some(op),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::ShParser;
    use crate::shell::ast::{ScriptNode, SeqOp};

    #[test]
    fn parse_pipeline() {
        let mut p = ShParser::new("echo a | cat", false, true);
        assert!(matches!(p.parse().unwrap(), ScriptNode::Pipeline(_)));
    }

    #[test]
    fn parse_redirections_with_numeric_fd() {
        let mut p = ShParser::new("echo foo 2> out 2>&1", false, true);
        if let ScriptNode::Pipeline(pipeline) = p.parse().unwrap() {
            assert_eq!(pipeline.commands[0].redirects.len(), 2);
            assert_eq!(pipeline.commands[0].redirects[0].source_fd, 2);
            assert_eq!(pipeline.commands[0].redirects[1].source_fd, 2);
        } else {
            panic!("expected pipeline");
        }
    }

    #[test]
    fn parse_redirect_with_leading_fd_prefix() {
        let mut p = ShParser::new("2> out echo foo", false, true);
        if let ScriptNode::Pipeline(pipeline) = p.parse().unwrap() {
            assert_eq!(pipeline.commands[0].redirects.len(), 1);
            assert_eq!(pipeline.commands[0].redirects[0].source_fd, 2);
            assert_eq!(pipeline.commands[0].redirects[0].target, "out");
            assert_eq!(
                pipeline.commands[0].args,
                vec!["echo".to_string(), "foo".to_string()]
            );
        } else {
            panic!("expected pipeline");
        }
    }

    #[test]
    fn parse_sequence() {
        let mut p = ShParser::new("echo a && echo b", false, true);
        match p.parse().unwrap() {
            ScriptNode::Seq(_, SeqOp::And, _) => {}
            _ => panic!("expected and sequence"),
        }
    }
}