better subshells

Cargo.toml

@@ -5,3 +5,6 @@ edition = "2021"
 
 [dev-dependencies]
 tempdir = "0.3.7"
+
+[dependencies]
+thiserror = "1.0.65"

src/ast.rs

@@ -1,6 +1,6 @@
 use crate::grammar::Token;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Ast {
     Command { command: Token, args: Vec<Token> },
     Pipe { left: Box<Ast>, right: Box<Ast> },

src/error.rs

@@ -0,0 +1,17 @@
+use crate::grammar::Token;
+
+#[derive(thiserror::Error, Debug, PartialEq)]
+pub enum Error {
+    #[error("parse error near `{0}`")]
+    Parse(Token),
+}
+
+impl From<Error> for std::io::Error {
+    fn from(e: Error) -> std::io::Error {
+        match e {
+            Error::Parse(token) => {
+                std::io::Error::new(std::io::ErrorKind::InvalidInput, token.to_string())
+            }
+        }
+    }
+}

src/grammar.rs

@@ -17,6 +17,12 @@ pub enum Token {
     // - Variable
 }
 
+impl std::fmt::Display for Token {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self.as_ref())
+    }
+}
+
 impl AsRef<OsStr> for Token {
     fn as_ref(&self) -> &OsStr {
         match self {

src/lex.rs

@@ -1,11 +1,9 @@
-use std::io;
-
-use crate::{grammar::Token, input};
+use crate::{error::Error, grammar::Token, input};
 
 pub struct Lexer;
 
 impl Lexer {
-    pub fn lex(line: &str) -> io::Result<Vec<Token>> {
+    pub fn lex(line: &str) -> Result<Vec<Token>, Error> {
         let mut tokens = vec![];
         let mut token = String::new();
         let mut escape = false;
@@ -46,10 +44,7 @@ impl Lexer {
                 if iter.peek() == Some(&'|') {
                     iter.next();
                     if iter.peek() == Some(&'|') {
-                        return Err(io::Error::new(
-                            io::ErrorKind::InvalidInput,
-                            "parse error near `|`",
-                        ));
+                        Err(Error::Parse(Token::Pipe))?;
                     }
                     tokens.push(Token::Or);
                 } else {
@@ -62,10 +57,7 @@ impl Lexer {
                 if iter.peek() == Some(&'>') {
                     iter.next();
                     if iter.peek() == Some(&'>') {
-                        return Err(io::Error::new(
-                            io::ErrorKind::InvalidInput,
-                            "parse error near `>`",
-                        ));
+                        Err(Error::Parse(Token::RedirectAppend))?;
                     }
                     tokens.push(Token::RedirectAppend);
                 } else {
@@ -78,10 +70,7 @@ impl Lexer {
                 if iter.peek() == Some(&'&') {
                     iter.next();
                     if iter.peek() == Some(&'&') {
-                        return Err(io::Error::new(
-                            io::ErrorKind::InvalidInput,
-                            "parse error near `&`",
-                        ));
+                        Err(Error::Parse(Token::Background))?;
                     }
                     tokens.push(Token::And);
                 } else {

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod ast;
+pub mod error;
 pub mod exec;
 pub mod grammar;
 pub mod lex;