Result、? 与递归下降：解析器和第一个命令行

1
/// Infix operators mapped to `(precedence, meaning)`. Higher binds tighter.
2
fn infix_op(kind: &TokenKind<'_>) -> Option<(u8, Infix)> {
3
    Some(match kind {
4
        TokenKind::Or => (1, Infix::Logic(LogicalOp::Or)),
5
        TokenKind::And => (2, Infix::Logic(LogicalOp::And)),
6
        TokenKind::Eq => (3, Infix::Arithmetic(BinaryOp::Eq)),
7
        TokenKind::NotEq => (3, Infix::Arithmetic(BinaryOp::NotEq)),
8
        TokenKind::Lt => (4, Infix::Arithmetic(BinaryOp::Lt)),
9
        TokenKind::LtEq => (4, Infix::Arithmetic(BinaryOp::LtEq)),
10
        TokenKind::Gt => (4, Infix::Arithmetic(BinaryOp::Gt)),
11
        TokenKind::GtEq => (4, Infix::Arithmetic(BinaryOp::GtEq)),
12
        TokenKind::Plus => (5, Infix::Arithmetic(BinaryOp::Add)),
13
        TokenKind::Minus => (5, Infix::Arithmetic(BinaryOp::Sub)),
14
        TokenKind::Star => (6, Infix::Arithmetic(BinaryOp::Mul)),
15
        TokenKind::Slash => (6, Infix::Arithmetic(BinaryOp::Div)),
16
        TokenKind::Percent => (6, Infix::Arithmetic(BinaryOp::Rem)),
17
        _ => return None,
18
    })
19
}

1
    /// Precedence climbing over the infix operators.
2
    ///
3
    /// `min_prec` is the level we are allowed to consume; higher binds tighter.
4
    fn binary(&mut self, min_prec: u8) -> Result<Expr, Diagnostic> {
5
        let mut left = self.unary()?;
6
        while let Some((prec, infix)) = infix_op(&self.peek().kind) {
7
            if prec < min_prec {
8
                break;
9
            }
10
            self.advance();
11
            // Left-associative: recurse one level higher.
12
            let right = self.binary(prec + 1)?;
13
            let span = left.span().merge(right.span());
14
            left = match infix {
15
                Infix::Arithmetic(op) => Expr::Binary {
16
                    op,
17
                    lhs: Box::new(left),
18
                    rhs: Box::new(right),
19
                    span,
20
                },
21
                Infix::Logic(op) => Expr::Logical {
22
                    op,
23
                    lhs: Box::new(left),
24
                    rhs: Box::new(right),
25
                    span,
26
                },
27
            };
28
        }
29
        Ok(left)
30
    }

1
#![allow(dead_code)]
2
#[derive(Debug)]
3
enum E {
4
    Int(i64),
5
    Add(Box<E>, Box<E>),
6
}
7

8
fn main() {
9
    let mut left = E::Int(1);
10
    for n in 2..=4 {
11
        let right = E::Int(n);
12
        // `left` moves into the Box, then the assignment gives it a new value.
13
        left = E::Add(Box::new(left), Box::new(right));
14
    }
15
    println!("{left:?}");
16
}

1
$ cargo build --bin ch07_move_fail
2
   Compiling rust-lab v0.1.0 (/tmp/rust-lab)
3
error[E0382]: borrow of moved value: `left`
4
  --> src/bin/ch07_move_fail.rs:12:29
5
   |
6
 9 |     let left = E::Int(1);
7
   |         ---- move occurs because `left` has type `E`, which does not implement the `Copy` trait
8
10 |     let right = E::Int(2);
9
11 |     let sum = E::Add(Box::new(left), Box::new(right));
10
   |                               ---- value moved here
11
12 |     println!("{sum:?} from {left:?}");
12
   |                             ^^^^ value borrowed here after move
13
   |
14
note: if `E` implemented `Clone`, you could clone the value
15
  --> src/bin/ch07_move_fail.rs:3:1
16
   |
17
 3 | enum E {
18
   | ^^^^^^ consider implementing `Clone` for this type
19
...
20
11 |     let sum = E::Add(Box::new(left), Box::new(right));
21
   |                               ---- you could clone this value
22

23
For more information about this error, try `rustc --explain E0382`.
24
error: could not compile `rust-lab` (bin "ch07_move_fail") due to 1 previous error

1
    fn unary(&mut self) -> Result<Expr, Diagnostic> {
2
        if self.matches(&TokenKind::Minus) {
3
            let start = self.previous().span;
4
            let operand = self.unary()?;
5
            let span = start.merge(operand.span());
6
            return Ok(Expr::Unary {
7
                op: UnaryOp::Neg,
8
                operand: Box::new(operand),
9
                span,
10
            });
11
        }
12
        if self.matches(&TokenKind::Not) {
13
            let start = self.previous().span;
14
            let operand = self.unary()?;
15
            let span = start.merge(operand.span());
16
            return Ok(Expr::Unary {
17
                op: UnaryOp::Not,
18
                operand: Box::new(operand),
19
                span,
20
            });
21
        }
22
        self.call()
23
    }
24

25
    fn call(&mut self) -> Result<Expr, Diagnostic> {
26
        let mut expr = self.primary()?;
27
        loop {
28
            if self.matches(&TokenKind::LParen) {
29
                let mut args = Vec::new();
30
                if !self.check(&TokenKind::RParen) {
31
                    loop {
32
                        args.push(self.expression()?);
33
                        if !self.matches(&TokenKind::Comma) {
34
                            break;
35
                        }
36
                    }
37
                }
38
                let end = self
39
                    .expect(&TokenKind::RParen, "unclosed argument list")?
40
                    .span;
41
                let span = expr.span().merge(end);
42
                expr = Expr::Call {
43
                    callee: Box::new(expr),
44
                    args,
45
                    span,
46
                };
47
            } else if self.matches(&TokenKind::LBracket) {
48
                let index = self.expression()?;
49
                let end = self.expect(&TokenKind::RBracket, "unclosed index")?.span;
50
                let span = expr.span().merge(end);
51
                expr = Expr::Index {
52
                    object: Box::new(expr),
53
                    index: Box::new(index),
54
                    span,
55
                };
56
            } else {
57
                break;
58
            }
59
        }
60
        Ok(expr)
61
    }

1
    fn primary(&mut self) -> Result<Expr, Diagnostic> {
2
        let token = self.advance();
3
        let span = token.span;
4
        match token.kind {
5
            TokenKind::Nil => Ok(Expr::Nil { span }),
6
            TokenKind::True => Ok(Expr::Bool { value: true, span }),
7
            TokenKind::False => Ok(Expr::Bool { value: false, span }),
8
            TokenKind::Int(value) => Ok(Expr::Int { value, span }),
9
            TokenKind::Float(value) => Ok(Expr::Float { value, span }),
10
            TokenKind::Str(value) => Ok(Expr::Str {
11
                value: value.into_owned(),
12
                span,
13
            }),
14
            TokenKind::Ident(name) => Ok(Expr::Var {
15
                name: Ident::new(name, span),
16
                span,
17
            }),
18
            TokenKind::LParen => {
19
                let expr = self.expression()?;
20
                self.expect(&TokenKind::RParen, "unclosed `(`")?;
21
                Ok(expr)
22
            }
23
            TokenKind::LBracket | TokenKind::HashBrace | TokenKind::Fn => {
24
                todo!("list, map and closure literals")
25
            }
26
            other => self.error(span, format!("expected an expression, found {other}")),
27
        }
28
    }

1
    // --- expressions ------------------------------------------------------
2

3
    /// Parses a full expression, including assignment.
4
    pub fn expression(&mut self) -> Result<Expr, Diagnostic> {
5
        self.assignment()
6
    }
7

8
    fn assignment(&mut self) -> Result<Expr, Diagnostic> {
9
        let expr = self.binary(0)?;
10
        if self.matches(&TokenKind::Assign) {
11
            let value = self.assignment()?; // right-associative
12
            if !is_assignable(&expr) {
13
                return self.error(expr.span(), "invalid assignment target");
14
            }
15
            let span = expr.span().merge(value.span());
16
            return Ok(Expr::Assign {
17
                target: Box::new(expr),
18
                value: Box::new(value),
19
                span,
20
            });
21
        }
22
        Ok(expr)
23
    }

1
#[cfg(test)]
2
mod tests {
3
    use super::*;
4
    use pebble_ast::pretty;
5

6
    fn parse_ok(src: &str) -> Program {
7
        let result = parse(SourceId(0), src);
8
        assert!(
9
            result.is_ok(),
10
            "expected clean parse, got {:?}",
11
            result.diagnostics
12
        );
13
        result.program
14
    }
15

16
    #[test]
17
    fn parses_precedence_correctly() {
18
        // 1 + 2 * 3 must group as 1 + (2 * 3).
19
        let program = parse_ok("1 + 2 * 3;");
20
        let rendered = pretty(&program);
21
        assert_eq!(
22
            rendered,
23
            "expr\n  binary +\n    int 1\n    binary *\n      int 2\n      int 3\n"
24
        );
25
    }
26

27
    #[test]
28
    fn parentheses_override_precedence() {
29
        let program = parse_ok("(1 + 2) * 3;");
30
        let rendered = pretty(&program);
31
        assert!(
32
            rendered.starts_with("expr\n  binary *\n    binary +\n"),
33
            "{rendered}"
34
        );
35
    }
36

37
    #[test]
38
    fn subtraction_is_left_associative() {
39
        // 1 - 2 - 3 == (1 - 2) - 3
40
        let program = parse_ok("1 - 2 - 3;");
41
        let rendered = pretty(&program);
42
        assert_eq!(
43
            rendered,
44
            "expr\n  binary -\n    binary -\n      int 1\n      int 2\n    int 3\n"
45
        );
46
    }
47

48
    #[test]
49
    fn rejects_assignment_to_literal() {
50
        let result = parse(SourceId(0), "1 = 2;");
51
        assert!(!result.is_ok());
52
        assert!(
53
            result
54
                .diagnostics
55
                .iter()
56
                .any(|d| d.message.contains("invalid assignment"))
57
        );
58
    }
59
}