rune/ast/
stmt.rs

Help
1use core::mem::take;
2
3use crate::ast::prelude::*;
4
5#[test]
6#[cfg(not(miri))]
7fn ast_parse() {
8    rt::<ast::Stmt>("let x = 1;");
9    rt::<ast::Stmt>("#[attr] let a = f();");
10    rt::<ast::Stmt>("line!().bar()");
11}
12
13/// A statement within a block.
14#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
15#[non_exhaustive]
16#[allow(clippy::large_enum_variant)]
17pub enum Stmt {
18    /// A local declaration.
19    Local(Box<ast::Local>),
20    /// A declaration.
21    Item(ast::Item, #[rune(iter)] Option<T![;]>),
22    /// An expression.
23    Expr(ast::Expr),
24    /// An with a trailing semi-colon.
25    ///
26    /// And absent semicolon indicates that it is synthetic.
27    Semi(StmtSemi),
28}
29
30impl Peek for Stmt {
31    fn peek(p: &mut Peeker<'_>) -> bool {
32        matches!(p.nth(0), K![let]) || ItemOrExpr::peek(p)
33    }
34}
35
36impl Parse for Stmt {
37    fn parse(p: &mut Parser<'_>) -> Result<Self> {
38        let mut attributes = p.parse()?;
39        let visibility = p.parse()?;
40
41        if ast::Item::peek_as_item(p.peeker()) {
42            let path = p.parse::<Option<ast::Path>>()?;
43            let item: ast::Item = ast::Item::parse_with_meta_path(p, attributes, visibility, path)?;
44
45            let semi = if item.needs_semi_colon() {
46                Some(p.parse()?)
47            } else {
48                p.parse()?
49            };
50
51            return Ok(Self::Item(item, semi));
52        }
53
54        if let Some(span) = visibility.option_span() {
55            return Err(compile::Error::unsupported(span, "visibility modifier"));
56        }
57
58        let stmt = if let K![let] = p.nth(0)? {
59            let local = Box::try_new(ast::Local::parse_with_meta(p, take(&mut attributes))?)?;
60            Self::Local(local)
61        } else {
62            let expr = ast::Expr::parse_with_meta(p, &mut attributes, ast::expr::CALLABLE)?;
63
64            // Parsed an expression which can be treated directly as an item.
65            match p.parse()? {
66                Some(semi) => Self::Semi(StmtSemi::new(expr, semi)),
67                None => Self::Expr(expr),
68            }
69        };
70
71        if let Some(span) = attributes.option_span() {
72            return Err(compile::Error::unsupported(span, "attributes"));
73        }
74
75        Ok(stmt)
76    }
77}
78
79/// Parsing an item or an expression.
80#[derive(Debug, TryClone, PartialEq, Eq)]
81#[non_exhaustive]
82#[allow(clippy::large_enum_variant)]
83pub enum ItemOrExpr {
84    /// An item.
85    Item(ast::Item),
86    /// An expression.
87    Expr(ast::Expr),
88}
89
90impl Peek for ItemOrExpr {
91    fn peek(p: &mut Peeker<'_>) -> bool {
92        match p.nth(0) {
93            K![use] => true,
94            K![enum] => true,
95            K![struct] => true,
96            K![impl] => true,
97            K![async] => matches!(p.nth(1), K![fn]),
98            K![fn] => true,
99            K![mod] => true,
100            K![const] => true,
101            K![ident(..)] => true,
102            K![::] => true,
103            _ => ast::Expr::peek(p),
104        }
105    }
106}
107
108impl Parse for ItemOrExpr {
109    fn parse(p: &mut Parser<'_>) -> Result<Self> {
110        let mut attributes = p.parse()?;
111        let visibility = p.parse()?;
112
113        if ast::Item::peek_as_item(p.peeker()) {
114            let path = p.parse()?;
115            let item: ast::Item = ast::Item::parse_with_meta_path(p, attributes, visibility, path)?;
116            return Ok(Self::Item(item));
117        }
118
119        if let Some(span) = visibility.option_span() {
120            return Err(compile::Error::unsupported(span, "visibility modifier"));
121        }
122
123        let expr = ast::Expr::parse_with_meta(p, &mut attributes, ast::expr::CALLABLE)?;
124
125        if let Some(span) = attributes.option_span() {
126            return Err(compile::Error::unsupported(span, "attributes"));
127        }
128
129        Ok(Self::Expr(expr))
130    }
131}
132
133/// Key used to stort a statement into its processing order.
134#[derive(Debug, TryClone, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
135#[try_clone(copy)]
136#[non_exhaustive]
137pub enum StmtSortKey {
138    /// USe statements, that should be processed first.
139    Use,
140    /// Items.
141    Item,
142    /// Other things, that should be processed last.
143    Other,
144}
145
146/// A semi-terminated expression.
147///
148/// These have special meaning since they indicate that whatever block or
149/// function they belong to should not evaluate to the value of the expression
150/// if it is the last expression in the block.
151#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
152#[non_exhaustive]
153pub struct StmtSemi {
154    /// The expression that is considered to be semi-terminated.
155    pub expr: ast::Expr,
156    /// The semi-token associated with the expression.
157    pub semi_token: T![;],
158}
159
160impl StmtSemi {
161    /// Construct a new [StmtSemi] which doesn't override
162    /// [needs_semi][StmtSemi::needs_semi].
163    pub(crate) fn new(expr: ast::Expr, semi_token: T![;]) -> Self {
164        Self { expr, semi_token }
165    }
166
167    /// Test if the statement requires a semi-colon or not.
168    pub(crate) fn needs_semi(&self) -> bool {
169        self.expr.needs_semi()
170    }
171}
rune/ast/stmt.rs

rune/ast/
stmt.rs
