1use crate::parser::helper::unknown_range;
2
3use super::prelude::*;
4
5#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
6pub enum Pattern<'s> {
7 Grouping(TokenRef<'s>, Box<Pattern<'s>>, TokenRef<'s>),
11 Literal(Option<TokenRef<'s>>, TokenRef<'s>),
15 Constant(TokenRef<'s>),
19 Relation(TokenRef<'s>, Box<Pattern<'s>>),
23 Range(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
27 Discard(TokenRef<'s>),
31 Bind(Option<TokenRef<'s>>, TokenRef<'s>),
35 Record(TokenRef<'s>, Vec<RecordPattern<'s>>, TokenRef<'s>),
52 Array(TokenRef<'s>, Vec<ArrayPattern<'s>>, TokenRef<'s>),
62 SpreadDiscard(usize),
72
73 And(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
77 Or(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
81 Not(TokenRef<'s>, Box<Pattern<'s>>),
85
86 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}