yosh 0.2.3

A POSIX-compliant shell implemented in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::env::aliases::AliasStore;
use crate::error::{ParseErrorKind, ShellErrorKind};
use crate::parser::Parser;
use crate::parser::ast::CompleteCommand;

#[derive(Debug)]
pub enum ParseStatus {
    Complete(Vec<CompleteCommand>),
    Incomplete,
    Empty,
    Error(String),
}

/// Closing-keyword probes for `is_completable`: each suffix wraps a
/// single `:` null builtin (POSIX-defined, always valid) before the
/// closer, so the probe satisfies the non-empty `compound_list` rule
/// introduced in commit `fe7c31c` (2026-04-19). Without the `:` body,
/// every probe would produce an empty `then`/`do`/`else` body and fail
/// with `syntax error: empty compound list in <ctx>`, making genuinely
/// incomplete input indistinguishable from genuinely invalid input.
const CLOSING_KEYWORDS: &[&str] = &[
    "\n:\nfi\n",
    "\n:\ndone\n",
    "\n:\nesac\n",
    "\n:\n}\n",
    "\n:\n)\n",
    "\n:\n;;\nesac\n",
    // `do :\ndone` covers header-only `for x in ...\n` and `while cond\n`
    // inputs where `do` itself has not been typed yet.
    "\ndo :\ndone\n",
];

pub fn classify_parse(input: &str, aliases: &AliasStore) -> ParseStatus {
    // 1. If input is only whitespace/newlines -> Empty
    if input.trim().is_empty() {
        return ParseStatus::Empty;
    }

    // 2. If input ends with backslash-newline -> Incomplete
    if input.ends_with("\\\n") {
        return ParseStatus::Incomplete;
    }

    // 3. If input ends with | or && or || (trimmed) -> Incomplete
    let trimmed = input.trim_end_matches('\n').trim_end();
    if trimmed.ends_with('|') || trimmed.ends_with("&&") || trimmed.ends_with("||") {
        return ParseStatus::Incomplete;
    }

    // 4. Try parsing with Parser::new_with_aliases()
    let mut parser = Parser::new_with_aliases(input, aliases);
    let mut commands = Vec::new();

    // Skip leading newlines
    if parser.is_at_end() {
        return ParseStatus::Empty;
    }

    loop {
        // Skip newlines between commands
        while !parser.is_at_end() && parser.current_token() == &crate::lexer::token::Token::Newline
        {
            if let Err(e) = parser.advance() {
                if is_incomplete_error(&e.kind) {
                    return ParseStatus::Incomplete;
                }
                return ParseStatus::Error(e.message);
            }
        }

        if parser.is_at_end() {
            break;
        }

        match parser.parse_complete_command() {
            Ok(cmd) => {
                commands.push(cmd);
            }
            Err(e) => {
                if is_incomplete_error(&e.kind) {
                    return ParseStatus::Incomplete;
                }
                // If the parser hit an UnexpectedToken at EOF, determine
                // whether the input is structurally incomplete (e.g. missing
                // `fi`) or truly invalid.  We probe by appending closing
                // keywords and re-parsing; if any probe succeeds the input
                // was merely incomplete.
                if e.kind == ShellErrorKind::Parse(ParseErrorKind::UnexpectedToken)
                    && parser.is_at_end()
                    && is_completable(input, aliases)
                {
                    return ParseStatus::Incomplete;
                }
                return ParseStatus::Error(e.message);
            }
        }
    }

    // 5. If no commands collected -> Empty
    if commands.is_empty() {
        return ParseStatus::Empty;
    }

    // 6. Otherwise -> Complete(commands)
    ParseStatus::Complete(commands)
}

/// Check whether appending a closing keyword makes the input parseable,
/// which indicates the original input was incomplete rather than erroneous.
fn is_completable(input: &str, aliases: &AliasStore) -> bool {
    for suffix in CLOSING_KEYWORDS {
        let candidate = format!("{}{}", input, suffix);
        let mut p = Parser::new_with_aliases(&candidate, aliases);
        if p.parse_program().is_ok() {
            return true;
        }
    }
    false
}

fn is_incomplete_error(kind: &ShellErrorKind) -> bool {
    matches!(
        kind,
        ShellErrorKind::Parse(ParseErrorKind::UnterminatedSingleQuote)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedDoubleQuote)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedCommandSub)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedArithSub)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedParamExpansion)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedBacktick)
            | ShellErrorKind::Parse(ParseErrorKind::UnterminatedDollarSingleQuote)
            | ShellErrorKind::Parse(ParseErrorKind::UnexpectedEof)
    )
}