sway_parse/
pattern.rs

1use crate::{Parse, ParseBracket, ParseResult, Parser, Peek};
2
3use sway_ast::brackets::{Braces, Parens};
4use sway_ast::keywords::{DoubleDotToken, FalseToken, TrueToken};
5use sway_ast::literal::{LitBool, LitBoolType};
6use sway_ast::punctuated::Punctuated;
7use sway_ast::{Literal, PathExpr, Pattern, PatternStructField};
8use sway_error::parser_error::ParseErrorKind;
9use sway_types::Spanned;
10
11impl Parse for Pattern {
12    fn parse(parser: &mut Parser) -> ParseResult<Pattern> {
13        let combine = |lhs, rhs, pipe_token| Pattern::Or {
14            lhs,
15            pipe_token,
16            rhs,
17        };
18        parse_binary(parser, parse_atomic_pattern, combine)
19    }
20}
21
22fn parse_binary<O: Peek>(
23    parser: &mut Parser,
24    sub: impl Fn(&mut Parser) -> ParseResult<Pattern>,
25    combine: impl Fn(Box<Pattern>, Box<Pattern>, O) -> Pattern,
26) -> ParseResult<Pattern> {
27    let mut expr = sub(parser)?;
28    while let Some((op_token, rhs)) = parse_op_rhs(parser, &sub)? {
29        expr = combine(Box::new(expr), rhs, op_token);
30    }
31    Ok(expr)
32}
33
34fn parse_op_rhs<O: Peek>(
35    parser: &mut Parser,
36    sub: impl Fn(&mut Parser) -> ParseResult<Pattern>,
37) -> ParseResult<Option<(O, Box<Pattern>)>> {
38    if let Some(op_token) = parser.take() {
39        let rhs = Box::new(sub(parser)?);
40        return Ok(Some((op_token, rhs)));
41    }
42    Ok(None)
43}
44
45fn parse_atomic_pattern(parser: &mut Parser) -> ParseResult<Pattern> {
46    {
47        let ref_token = parser.take();
48        let mut_token = parser.take();
49        if ref_token.is_some() || mut_token.is_some() {
50            let name = parser.parse()?;
51            return Ok(Pattern::Var {
52                reference: ref_token,
53                mutable: mut_token,
54                name,
55            });
56        }
57
58        let lit_bool = |span, kind| Ok(Pattern::Literal(Literal::Bool(LitBool { span, kind })));
59
60        if let Some(ident) = parser.take::<TrueToken>() {
61            return lit_bool(ident.span(), LitBoolType::True);
62        }
63        if let Some(ident) = parser.take::<FalseToken>() {
64            return lit_bool(ident.span(), LitBoolType::False);
65        }
66        if let Some(literal) = parser.take() {
67            return Ok(Pattern::Literal(literal));
68        }
69        if let Some(tuple) = Parens::try_parse(parser)? {
70            return Ok(Pattern::Tuple(tuple));
71        }
72        if let Some(underscore_token) = parser.take() {
73            return Ok(Pattern::Wildcard { underscore_token });
74        }
75
76        let path = parser.parse::<PathExpr>()?;
77        if path.incomplete_suffix {
78            return Ok(Pattern::Error(
79                Box::new([path.span()]),
80                parser.emit_error(ParseErrorKind::ExpectedPathType),
81            ));
82        }
83        if let Some(args) = Parens::try_parse(parser)? {
84            return Ok(Pattern::Constructor { path, args });
85        }
86        if let Some(fields) = Braces::try_parse(parser)? {
87            let inner_fields: &Punctuated<_, _> = fields.get();
88            let rest_pattern = inner_fields
89                .value_separator_pairs
90                .iter()
91                .find(|(p, _)| matches!(p, PatternStructField::Rest { token: _ }));
92
93            if let Some((rest_pattern, _)) = rest_pattern {
94                return Err(parser.emit_error_with_span(
95                    ParseErrorKind::UnexpectedRestPattern,
96                    rest_pattern.span(),
97                ));
98            }
99
100            return Ok(Pattern::Struct { path, fields });
101        }
102        match path.try_into_ident() {
103            Ok(name) => Ok(Pattern::AmbiguousSingleIdent(name)),
104            Err(path) => Ok(Pattern::Constant(path)),
105        }
106    }
107}
108
109impl Parse for PatternStructField {
110    fn parse(parser: &mut Parser) -> ParseResult<PatternStructField> {
111        if let Some(token) = parser.take::<DoubleDotToken>() {
112            return Ok(PatternStructField::Rest { token });
113        }
114
115        let field_name = parser.parse()?;
116        let pattern_opt = match parser.take() {
117            Some(colon_token) => Some((colon_token, parser.parse()?)),
118            None => None,
119        };
120        Ok(PatternStructField::Field {
121            field_name,
122            pattern_opt,
123        })
124    }
125}
sway_parse/pattern.rs

sway_parse/
pattern.rs
