rune/ast/
pat.rs

Help
1use crate::ast::prelude::*;
2
3#[test]
4#[cfg(not(miri))]
5fn ast_parse() {
6    rt::<ast::Pat>("()");
7    rt::<ast::Pat>("42");
8    rt::<ast::Pat>("-42");
9    rt::<ast::Pat>("3.1415");
10    rt::<ast::Pat>("-3.1415");
11    rt::<ast::Pat>("b'a'");
12    rt::<ast::Pat>("'a'");
13    rt::<ast::Pat>("b\"hello world\"");
14    rt::<ast::Pat>("\"hello world\"");
15    rt::<ast::Pat>("var");
16    rt::<ast::Pat>("_");
17    rt::<ast::Pat>("Foo(n)");
18}
19
20/// A pattern match.
21#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
22#[non_exhaustive]
23pub enum Pat {
24    /// An ignored binding `_`.
25    Ignore(PatIgnore),
26    /// A variable binding `n`.
27    Path(PatPath),
28    /// A literal pattern. This is represented as an expression.
29    Lit(PatLit),
30    /// A vector pattern.
31    Vec(PatVec),
32    /// A tuple pattern.
33    Tuple(PatTuple),
34    /// An object pattern.
35    Object(PatObject),
36    /// A binding `a: pattern` or `"foo": pattern`.
37    Binding(PatBinding),
38    /// The rest pattern `..`.
39    Rest(PatRest),
40}
41
42impl Parse for Pat {
43    fn parse(p: &mut Parser<'_>) -> Result<Self> {
44        let attributes = p.parse::<Vec<ast::Attribute>>()?;
45
46        match p.nth(0)? {
47            K![byte] => {
48                return Ok(Self::Lit(PatLit {
49                    attributes,
50                    expr: Box::try_new(ast::Expr::from_lit(ast::Lit::Byte(p.parse()?)))?,
51                }));
52            }
53            K![char] => {
54                return Ok(Self::Lit(PatLit {
55                    attributes,
56                    expr: Box::try_new(ast::Expr::from_lit(ast::Lit::Char(p.parse()?)))?,
57                }));
58            }
59            K![bytestr] => {
60                return Ok(Self::Lit(PatLit {
61                    attributes,
62                    expr: Box::try_new(ast::Expr::from_lit(ast::Lit::ByteStr(p.parse()?)))?,
63                }));
64            }
65            K![true] | K![false] => {
66                return Ok(Self::Lit(PatLit {
67                    attributes,
68                    expr: Box::try_new(ast::Expr::from_lit(ast::Lit::Bool(p.parse()?)))?,
69                }));
70            }
71            K![str] => {
72                return Ok(match p.nth(1)? {
73                    K![:] => Self::Binding(PatBinding {
74                        attributes,
75                        key: ast::ObjectKey::LitStr(p.parse()?),
76                        colon: p.parse()?,
77                        pat: p.parse()?,
78                    }),
79                    _ => Self::Lit(PatLit {
80                        attributes,
81                        expr: Box::try_new(ast::Expr::from_lit(ast::Lit::Str(p.parse()?)))?,
82                    }),
83                });
84            }
85            K![number] => {
86                return Ok(Self::Lit(PatLit {
87                    attributes,
88                    expr: Box::try_new(ast::Expr::from_lit(ast::Lit::Number(p.parse()?)))?,
89                }));
90            }
91            K![..] => {
92                return Ok(Self::Rest(PatRest {
93                    attributes,
94                    dot_dot: p.parse()?,
95                }))
96            }
97            K!['('] => {
98                return Ok({
99                    let _nth = p.nth(1)?;
100
101                    Self::Tuple(PatTuple {
102                        attributes,
103                        path: None,
104                        items: p.parse()?,
105                    })
106                });
107            }
108            K!['['] => {
109                return Ok(Self::Vec(PatVec {
110                    attributes,
111                    items: p.parse()?,
112                }))
113            }
114            K![#] => {
115                return Ok(Self::Object(PatObject {
116                    attributes,
117                    ident: p.parse()?,
118                    items: p.parse()?,
119                }))
120            }
121            K![-] => {
122                let expr: ast::Expr = p.parse()?;
123
124                if expr.is_lit() {
125                    return Ok(Self::Lit(PatLit {
126                        attributes,
127                        expr: Box::try_new(expr)?,
128                    }));
129                }
130            }
131            K![_] => {
132                return Ok(Self::Ignore(PatIgnore {
133                    attributes,
134                    underscore: p.parse()?,
135                }))
136            }
137            _ if ast::Path::peek(p.peeker()) => {
138                let path = p.parse::<ast::Path>()?;
139
140                return Ok(match p.nth(0)? {
141                    K!['('] => Self::Tuple(PatTuple {
142                        attributes,
143                        path: Some(path),
144                        items: p.parse()?,
145                    }),
146                    K!['{'] => Self::Object(PatObject {
147                        attributes,
148                        ident: ast::ObjectIdent::Named(path),
149                        items: p.parse()?,
150                    }),
151                    K![:] => Self::Binding(PatBinding {
152                        attributes,
153                        key: ast::ObjectKey::Path(path),
154                        colon: p.parse()?,
155                        pat: p.parse()?,
156                    }),
157                    _ => Self::Path(PatPath { attributes, path }),
158                });
159            }
160            _ => (),
161        }
162
163        Err(compile::Error::expected(p.tok_at(0)?, "pattern"))
164    }
165}
166
167impl Peek for Pat {
168    fn peek(p: &mut Peeker<'_>) -> bool {
169        match p.nth(0) {
170            K!['('] => true,
171            K!['['] => true,
172            K![#] => matches!(p.nth(1), K!['{']),
173            K![_] => true,
174            K![..] => true,
175            K![byte] | K![char] | K![number] | K![str] => true,
176            K![true] | K![false] => true,
177            K![-] => matches!(p.nth(1), K![number]),
178            _ => ast::Path::peek(p),
179        }
180    }
181}
182
183/// A literal pattern.
184#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
185#[non_exhaustive]
186pub struct PatLit {
187    /// Attributes associated with the pattern.
188    #[rune(iter)]
189    pub attributes: Vec<ast::Attribute>,
190    /// The literal expression.
191    pub expr: Box<ast::Expr>,
192}
193
194/// The rest pattern `..` and associated attributes.
195#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
196#[non_exhaustive]
197pub struct PatRest {
198    /// Attribute associated with the rest pattern.
199    #[rune(iter)]
200    pub attributes: Vec<ast::Attribute>,
201    /// The rest token `..`.
202    pub dot_dot: T![..],
203}
204
205/// An array pattern.
206#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
207#[non_exhaustive]
208pub struct PatVec {
209    /// Attributes associated with the vector pattern.
210    #[rune(iter)]
211    pub attributes: Vec<ast::Attribute>,
212    /// Bracketed patterns.
213    pub items: ast::Bracketed<ast::Pat, T![,]>,
214}
215
216/// A tuple pattern.
217#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
218#[non_exhaustive]
219pub struct PatTuple {
220    /// Attributes associated with the object pattern.
221    #[rune(iter)]
222    pub attributes: Vec<ast::Attribute>,
223    /// The path, if the tuple is typed.
224    #[rune(iter)]
225    pub path: Option<ast::Path>,
226    /// The items in the tuple.
227    pub items: ast::Parenthesized<ast::Pat, T![,]>,
228}
229
230/// An object pattern.
231#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
232#[non_exhaustive]
233pub struct PatObject {
234    /// Attributes associated with the object pattern.
235    #[rune(iter)]
236    pub attributes: Vec<ast::Attribute>,
237    /// The identifier of the object pattern.
238    pub ident: ast::ObjectIdent,
239    /// The fields matched against.
240    pub items: ast::Braced<Pat, T![,]>,
241}
242
243/// An object item.
244#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned, Parse)]
245#[non_exhaustive]
246pub struct PatBinding {
247    /// Attributes associate with the binding.
248    #[rune(iter)]
249    pub attributes: Vec<ast::Attribute>,
250    /// The key of an object.
251    pub key: ast::ObjectKey,
252    /// The colon separator for the binding.
253    pub colon: T![:],
254    /// What the binding is to.
255    pub pat: Box<ast::Pat>,
256}
257
258/// A path pattern.
259#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
260#[non_exhaustive]
261pub struct PatPath {
262    /// Attributes associate with the path.
263    #[rune(iter)]
264    pub attributes: Vec<ast::Attribute>,
265    /// The path of the pattern.
266    pub path: ast::Path,
267}
268
269/// An ignore pattern.
270#[derive(Debug, TryClone, PartialEq, Eq, ToTokens, Spanned)]
271#[non_exhaustive]
272pub struct PatIgnore {
273    /// Attributes associate with the pattern.
274    #[rune(iter)]
275    pub attributes: Vec<ast::Attribute>,
276    /// The ignore token`_`.
277    pub underscore: T![_],
278}
rune/ast/pat.rs

rune/ast/
pat.rs
