Skip to main content

mirascript_core/parser/
pattern.rs

1use crate::parser::helper::unknown_range;
2
3use super::prelude::*;
4
5#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
6pub enum Pattern<'s> {
7    /// `(` pattern `)`
8    ///
9    /// Grouping pattern.
10    Grouping(TokenRef<'s>, Box<Pattern<'s>>, TokenRef<'s>),
11    /// ( `+` | `-` )? literal
12    ///
13    /// Matches against a literal value.
14    Literal(Option<TokenRef<'s>>, TokenRef<'s>),
15    /// constant
16    ///
17    /// Matches against a constant value.
18    Constant(TokenRef<'s>),
19    /// ( `>` | `>=` | `<=` | `<` | `==` | `!=` | `=~` | `!~` ) (pattern_constant | pattern_literal)
20    ///
21    /// Matches against a relation with constant values.
22    Relation(TokenRef<'s>, Box<Pattern<'s>>),
23    /// (pattern_constant | pattern_literal) ( `..` | `..<` ) (pattern_constant | pattern_literal)
24    ///
25    /// Matches against a range of constant values.
26    Range(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
27    /// `_`
28    ///
29    /// Matches and discards a value.
30    Discard(TokenRef<'s>),
31    /// `mut`? identifier
32    ///
33    /// Matches and binds a value to a variable.
34    Bind(Option<TokenRef<'s>>, TokenRef<'s>),
35    /// ``````antlr
36    /// pattern_record
37    ///     : '(' sub_pattern* ')'
38    ///     ;
39    /// sub_pattern
40    ///     : name colon pattern ','?
41    ///     | colon pattern_bind ','?
42    ///     | pattern ','?
43    ///     | '..' pattern ','?
44    ///     ;
45    /// colon
46    ///     : ':'
47    ///     | '?:'
48    ///     ;
49    /// ``````
50    /// Matches a record pattern.
51    Record(TokenRef<'s>, Vec<RecordPattern<'s>>, TokenRef<'s>),
52    /// ```antlr
53    /// pattern_array
54    ///     : '[' sub_pattern* ']'
55    ///     ;
56    /// sub_pattern
57    ///     : pattern ','?
58    ///     | '..' pattern? ','?
59    ///     ;
60    /// ```
61    Array(TokenRef<'s>, Vec<ArrayPattern<'s>>, TokenRef<'s>),
62    /// prefix<`..`>
63    ///
64    /// Contains no token.
65    /// Used in [ArrayPattern]::Spread and [RecordPattern]::Spread
66    /// as a placeholder since `_`
67    /// must be omitted in these cases.
68    ///
69    /// The value is the position of the spread discard in the pattern.
70    /// Used in the [AstWalker::range] method
71    SpreadDiscard(usize),
72
73    /// pattern `and` pattern
74    ///
75    /// Matches all of the patterns.
76    And(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
77    /// pattern `or` pattern
78    ///
79    /// Matches any of the patterns.
80    Or(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
81    /// `not` pattern
82    ///
83    /// Matches if the pattern does not match.
84    Not(TokenRef<'s>, Box<Pattern<'s>>),
85
86    /// Unknown pattern.
87    Unknown {
88        recovered: Option<Box<Pattern<'s>>>,
89        tokens: Vec<TokenRef<'s>>,
90        errors: Vec<SourceDiagnostic>,
91    },
92}
93
94impl<'s> Pattern<'s> {
95    pub(crate) fn wrap_as_unknown<T: Into<Vec<TokenRef<'s>>>>(
96        self,
97        tokens: T,
98        error: DiagnosticCode,
99    ) -> Self {
100        let tokens = tokens.into();
101        assert!(!tokens.is_empty());
102        let mut range = tokens[0].range.clone();
103        range.end = tokens.last().unwrap().range.end;
104        Pattern::Unknown {
105            recovered: Some(Box::new(self)),
106            tokens,
107            errors: vec![SourceDiagnostic::new(range, error)],
108        }
109    }
110
111    pub(crate) fn unknown<T: Into<Vec<TokenRef<'s>>>>(tokens: T, error: DiagnosticCode) -> Self {
112        let tokens = tokens.into();
113        assert!(!tokens.is_empty());
114        let mut range = tokens[0].range.clone();
115        range.end = tokens.last().unwrap().range.end;
116        Pattern::Unknown {
117            recovered: None,
118            tokens,
119            errors: vec![SourceDiagnostic::new(range, error)],
120        }
121    }
122    pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
123        tokens: T,
124        error_range: SourceRange,
125        error: DiagnosticCode,
126    ) -> Self {
127        Pattern::Unknown {
128            recovered: None,
129            tokens: tokens.into(),
130            errors: vec![SourceDiagnostic::new(error_range, error)],
131        }
132    }
133
134    pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
135        tokens: T,
136        errors: E,
137    ) -> Self {
138        Pattern::Unknown {
139            recovered: None,
140            tokens: tokens.into(),
141            errors: errors.into(),
142        }
143    }
144}
145
146impl<'s> AstWalker<'s> for Pattern<'s> {
147    fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
148        use Pattern::*;
149        match self {
150            Grouping(o, p, e) => {
151                o.collect_diagnostics(collector);
152                p.collect_diagnostics(collector);
153                e.collect_diagnostics(collector);
154            }
155            Literal(p, t) => {
156                p.collect_diagnostics(collector);
157                t.collect_diagnostics(collector);
158            }
159            Constant(t) => {
160                t.collect_diagnostics(collector);
161            }
162            Relation(o, p) => {
163                o.collect_diagnostics(collector);
164                p.collect_diagnostics(collector);
165            }
166            Range(s, o, e) => {
167                s.collect_diagnostics(collector);
168                o.collect_diagnostics(collector);
169                e.collect_diagnostics(collector);
170            }
171            Discard(t) => t.collect_diagnostics(collector),
172            Bind(p, t) => {
173                p.collect_diagnostics(collector);
174                t.collect_diagnostics(collector);
175            }
176            Record(s, p, e) => {
177                s.collect_diagnostics(collector);
178                for sub_pattern in p.iter_mut() {
179                    sub_pattern.collect_diagnostics(collector);
180                }
181                e.collect_diagnostics(collector);
182            }
183            Array(s, p, e) => {
184                s.collect_diagnostics(collector);
185                for sub_pattern in p.iter_mut() {
186                    sub_pattern.collect_diagnostics(collector);
187                }
188                e.collect_diagnostics(collector);
189            }
190            SpreadDiscard(_) => {}
191            And(l, o, r) => {
192                l.collect_diagnostics(collector);
193                o.collect_diagnostics(collector);
194                r.collect_diagnostics(collector);
195            }
196            Or(l, o, r) => {
197                l.collect_diagnostics(collector);
198                o.collect_diagnostics(collector);
199                r.collect_diagnostics(collector);
200            }
201            Not(o, p) => {
202                o.collect_diagnostics(collector);
203                p.collect_diagnostics(collector);
204            }
205            Unknown {
206                recovered,
207                tokens,
208                errors,
209            } => {
210                collector.append(errors);
211                tokens.collect_diagnostics(collector);
212                if let Some(mut recovered) = std::mem::take(recovered) {
213                    recovered.collect_diagnostics(collector);
214                    *self = *recovered;
215                }
216            }
217        }
218    }
219    fn range(&self) -> SourceRange {
220        use Pattern::*;
221        match self {
222            Grouping(o, _, e) | Record(o, _, e) | Array(o, _, e) => o.range.start..e.range.end,
223            Range(o, _, e) => o.range().start..e.range().end,
224            SpreadDiscard(pos) => *pos..*pos,
225            Relation(op, pattern) => op.range.start..pattern.range().end,
226            Discard(underscore) => underscore.range(),
227            Literal(None, token) | Bind(None, token) => token.range(),
228            Literal(Some(op), token) | Bind(Some(op), token) => op.range.start..token.range.end,
229            Constant(token) => token.range(),
230            And(left, _, right) | Or(left, _, right) => left.range().start..right.range().end,
231            Not(op, pattern) => op.range.start..pattern.range().end,
232            Unknown {
233                recovered,
234                tokens,
235                errors: _,
236            } => unknown_range(recovered, tokens),
237        }
238    }
239}