1pub mod prelude;
6
7use pest::error::{Error, ErrorVariant, InputLocation};
8use pest::iterators::{Pair, Pairs};
9use pest::{Parser, Position};
10use pest_derive::Parser;
11use std::iter::Peekable;
12use std::str::Chars;
13use swamp_ast::{prelude::*, AssignmentOperatorKind, BinaryOperatorKind, CompoundOperator, CompoundOperatorKind, ConcretePattern, DestructuringPattern, EnumVariantLiteral, EnumVariantLiteralKind, ExpressionKind, FieldExpression, FieldName, ForPattern, ForVar, ImportItems, IterableExpression, LocalConstantIdentifier, LocalTypeIdentifierWithOptionalTypeVariables, Mod, NamedStructDef, PatternVariableOrWildcard, QualifiedIdentifier, RangeMode, SpanWithoutFileId, StructTypeField, TypeForParameter, TypeVariable, VariableBinding};
14use swamp_ast::{AttributeLiteralKind, Function};
15use swamp_ast::{GenericParameter, LiteralKind};
16use swamp_ast::{Postfix, PostfixChain};
17use tracing::error;
18
19pub struct ParseResult<'a> {
20 #[allow(dead_code)]
21 script: String, pairs: pest::iterators::Pairs<'a, Rule>,
23}
24
25pub struct GeneralError {
26 pub description: String,
27}
28
29#[derive(Debug)]
30pub enum SpecificError {
31 CouldNotMoveDown,
32 CouldNotMoveRight,
33 General(String),
34 ExpectingTypeIdentifier,
35 ExpectingInnerPair,
36 UnexpectedTypeRule(String),
37 ExpectedTypeIdentifier(String),
38 ExpectedLocalTypeIdentifier(String),
39 UnexpectedRuleInParseScript(String),
40 ExpectedControlStatement(String),
41 ExpectedStatement(String),
42 ExpectedIfOrElse(String),
43 MissingFunctionSignature,
44 MissingFunctionBody,
45 ExpectedStatementBlock,
46 ExpectedFunctionDefinition,
47 ExpectedParameter,
48 ExpectedImplItem,
49 ExpectedMemberSignature,
50 ExpectedBlockInWhileLoop,
51 UnexpectedExpressionType(String),
52 UnexpectedAccessType(String),
53 UnknownAssignmentOperator(String),
54 CompoundOperatorCanNotContainMut,
55 InvalidAssignmentTarget,
56 CompoundOperatorCanNotHaveMultipleVariables,
57 ExpectedExpressionAfterPrefixOperator,
58 UnknownOperator(String),
59 UnexpectedPostfixOperator,
60 UnexpectedUnaryOperator(String),
61 InvalidMemberCall,
62 UnknownMatchType,
63 UnexpectedElementInPatternList,
64 InvalidPrecisionValue,
65 InvalidPrecisionType,
66 ExpectedTypeIdentifierAfterPath,
67 UnexpectedPatternListElement(String),
68 MustHaveAtLeastOneArm,
69 UnexpectedMatchArmRule(String),
70 UnknownEnumVariant(String),
71 UnknownLiteral,
72 UnknownPrimary(String),
73 InvalidFormatSpecifier,
74 UnexpectedVariantField,
75 MutOnlyForVariables,
76 UnexpectedTokenInFunctionCall,
77 ExpectedExpressionInInterpolation,
78 UnexpectedRuleInInterpolation,
79 ExpectedForPattern,
80 ExpectedBlock,
81 InvalidForPattern,
82 UnexpectedRuleInElse(String),
83 ExpectedLocationExpression,
84 ExpectedImportPath,
85 ExpectedIdentifier,
86 ExpectedIdentifierAfterPath,
87 ExpectedFieldOrRest,
88 UnknownEscapeCharacter(char),
89 UnfinishedEscapeSequence,
90 InvalidUnicodeEscape,
91 InvalidHexEscape,
92 InvalidUtf8Sequence,
93 MissingTypeName,
94 UnknownTerm(String),
95 UnknownExpr(String),
96 UnexpectedTokenInMutableExpression,
97}
98
99#[derive(Debug)]
100pub struct ParseError {
101 pub span: SpanWithoutFileId,
102 pub specific: SpecificError,
103}
104
105#[derive(Parser)]
106#[grammar = "grammar.pest"]
107pub struct ScriptParser;
108
109pub const UNKNOWN_FILE_ID: u16 = 0xffff;
110
111pub struct AstParser;
112
113impl From<Error<Rule>> for ParseError {
114 fn from(value: Error<Rule>) -> Self {
115 let span = match value.location {
116 InputLocation::Pos(pos) => SpanWithoutFileId {
117 offset: pos as u32,
118 length: 1,
119 },
120 InputLocation::Span((start, end)) => SpanWithoutFileId {
121 offset: start as u32,
122 length: (end - start) as u16,
123 },
124 };
125 Self {
126 span,
127 specific: SpecificError::General(value.variant.to_string()),
128 }
129 }
130}
131
132impl AstParser {
133 fn next_pair<'a>(
134 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
135 ) -> Result<Pair<'a, Rule>, ParseError> {
136 Ok(pairs.next().ok_or_else(|| {
137 Error::new_from_pos(
138 ErrorVariant::CustomError {
139 message: "Expected more tokens".into(),
140 },
141 Position::from_start(""),
142 )
143 })?)
144 }
145
146 fn expect_next<'a>(
147 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
148 expected_rule: Rule,
149 ) -> Result<Pair<'a, Rule>, ParseError> {
150 let pair = Self::next_pair(pairs)?;
151 if pair.as_rule() != expected_rule {
152 return Err(Error::new_from_span(
153 ErrorVariant::CustomError {
154 message: format!("Expected {:?}, found {:?}", expected_rule, pair.as_rule()),
155 },
156 pair.as_span(),
157 ))?;
158 }
159 Ok(pair)
160 }
161
162 fn expect_identifier_next<'a>(
163 &self,
164 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
165 ) -> Result<LocalIdentifier, ParseError> {
166 let pair = Self::expect_next(pairs, Rule::identifier)?;
167 Ok(LocalIdentifier::new(self.to_node(&pair)))
168 }
169
170 fn expect_function_identifier_next<'a>(
171 &self,
172 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
173 ) -> Result<LocalIdentifier, ParseError> {
174 let pair = Self::expect_next(pairs, Rule::function_identifier)?;
175 Ok(LocalIdentifier::new(self.to_node(&pair)))
176 }
177
178 fn expect_constant_identifier_next<'a>(
179 &self,
180 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
181 ) -> Result<LocalConstantIdentifier, ParseError> {
182 let pair = Self::expect_next(pairs, Rule::constant_identifier)?;
183 Ok(LocalConstantIdentifier(self.to_node(&pair)))
184 }
185
186 fn _expect_variable_next<'a>(
187 &self,
188 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
189 ) -> Result<Variable, ParseError> {
190 let identifier = self.expect_identifier_next(pairs)?;
191 Ok(Variable {
192 name: identifier.0,
193 is_mutable: None,
194 })
195 }
196
197 fn expect_field_label_next<'a>(
198 &self,
199 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
200 ) -> Result<FieldName, ParseError> {
201 let field_label_pair = Self::expect_next(pairs, Rule::field_label)?;
202 let mut inner = field_label_pair.clone().into_inner();
203 let ident_pair = inner.next().ok_or_else(|| {
204 self.create_error_pair(SpecificError::ExpectedIdentifier, &field_label_pair)
205 })?;
206
207 Ok(FieldName(self.to_node(&ident_pair)))
208 }
209
210 fn parse_dot_identifier<'a>(&self, pair: &Pair<Rule>) -> Result<FieldName, ParseError> {
211 debug_assert_eq!(pair.as_rule(), Rule::dot_identifier);
212 let mut inner = pair.clone().into_inner();
213 let ident_pair = inner
214 .next()
215 .ok_or_else(|| self.create_error_pair(SpecificError::ExpectedIdentifier, pair))?;
216
217 Ok(FieldName(self.to_node(&ident_pair)))
218 }
219
220 fn expect_local_type_identifier_next<'a>(
221 &self,
222 pairs: &mut impl Iterator<Item=Pair<'a, Rule>>,
223 ) -> Result<LocalTypeIdentifier, ParseError> {
224 let pair = Self::expect_next(pairs, Rule::type_identifier)?;
225 Ok(LocalTypeIdentifier::new(self.to_node(&pair)))
226 }
227
228 fn convert_into_iterator<'a>(pair: &'a Pair<'a, Rule>) -> impl Iterator<Item=Pair<'a, Rule>> {
229 pair.clone().into_inner()
230 }
231
232 fn create_error_pair(&self, kind: SpecificError, pair: &Pair<Rule>) -> ParseError {
233 ParseError {
234 span: self.to_span(pair.as_span()),
235 specific: kind,
236 }
237 }
238
239 fn to_err(kind: SpecificError, pair: &Pair<Rule>) -> ParseError {
240 ParseError {
241 span: Self::span(pair.as_span()),
242 specific: kind,
243 }
244 }
245
246 fn next_inner_pair<'a>(&self, pair: &Pair<'a, Rule>) -> Result<Pair<'a, Rule>, ParseError> {
247 let _span = pair.as_span();
248 pair.clone()
249 .into_inner()
250 .next()
251 .ok_or_else(move || self.create_error_pair(SpecificError::ExpectingInnerPair, pair))
252 }
253
254 pub fn parse(rule: Rule, raw_script: &str) -> Result<ParseResult<'static>, ParseError> {
255 let pairs = unsafe {
256 std::mem::transmute::<pest::iterators::Pairs<'_, Rule>, pest::iterators::Pairs<'_, Rule>>(
257 ScriptParser::parse(rule, raw_script)?,
258 )
259 };
260 Ok(ParseResult {
261 script: raw_script.to_string(),
262 pairs,
263 })
264 }
265
266 pub fn parse_item(&self, pair: &Pair<Rule>) -> Result<Definition, ParseError> {
267 debug_assert_eq!(pair.as_rule(), Rule::item);
268
269 let mut inner = pair.clone().into_inner();
270 let mut attributes = Vec::new();
271
272 while let Some(attr_pair) = inner.peek() {
273 if attr_pair.as_rule() == Rule::attribute {
274 let attr = self.parse_attribute(&inner.next().unwrap())?;
275 attributes.push(attr);
276 } else {
277 break;
278 }
279 }
280 if let Some(def_pair) = inner.next() {
282 let definition_kind = self.parse_definition(&def_pair, &attributes)?;
283 let definition = Definition {
284 node: self.to_node(&def_pair),
285 kind: definition_kind,
286 attributes,
287 };
288 Ok(definition)
289 } else {
290 panic!("must be definition after attributes")
291 }
292 }
293
294 pub fn parse_module(&self, raw_script: &str) -> Result<Module, ParseError> {
295 let result = Self::parse(Rule::program, raw_script)?;
296
297 let mut pairs = result.pairs;
298
299 let program_pair = Self::next_pair(&mut pairs)?;
300
301 let mut expressions = Vec::new();
302 let mut definitions = Vec::new();
303 for pair in Self::convert_into_iterator(&program_pair) {
304 match pair.as_rule() {
305 Rule::item => {
306 let def = self.parse_item(&pair)?;
307 definitions.push(def);
308 }
309 Rule::expression => {
310 let expr = self.parse_expression(&pair)?;
311 expressions.push(expr);
312 }
313 Rule::EOI => {} _ => {
315 return Err(self.create_error_pair(
316 SpecificError::UnexpectedRuleInParseScript(Self::pair_to_rule(&pair)),
317 &pair,
318 ));
319 }
320 }
321 }
322
323 let maybe_expression = match expressions.len() {
324 0 => None,
325 1 => Some(expressions.into_iter().next().unwrap()),
326 _ => Some(Expression {
327 kind: ExpressionKind::Block(expressions),
328 node: Node {
329 span: SpanWithoutFileId::default(),
330 },
331 }),
332 };
333
334 Ok(Module::new(definitions, maybe_expression))
335 }
336
337 fn parse_definition(
338 &self,
339 pair: &Pair<Rule>,
340 attributes: &[Attribute],
341 ) -> Result<DefinitionKind, ParseError> {
342 let inner_pair = self.next_inner_pair(pair)?;
343 match inner_pair.as_rule() {
344 Rule::impl_def => self.parse_impl_def(&inner_pair),
345 Rule::const_def => self.parse_const_definition(&inner_pair),
346 Rule::struct_def => self.parse_struct_def(&inner_pair),
347 Rule::type_def => self.parse_type_def(&inner_pair),
348 Rule::function_def => self.parse_function_def(&inner_pair, attributes),
349 Rule::use_def => self.parse_use(&inner_pair),
350 Rule::mod_def => self.parse_mod(&inner_pair),
351 Rule::enum_def => self.parse_enum_def(&inner_pair),
352 _ => todo!(),
353 }
354 }
355
356 fn parse_const_definition(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
357 Ok(DefinitionKind::Constant(self.parse_const_info(pair)?))
358 }
359
360 fn parse_const_info(&self, pair: &Pair<Rule>) -> Result<ConstantInfo, ParseError> {
361 let mut inner = pair.clone().into_inner(); let constant_identifier = self.expect_constant_identifier_next(&mut inner)?;
364
365 let maybe_annotation = self.parse_maybe_annotation(&mut inner)?;
366
367 let expr_pair = Self::next_pair(&mut inner)?;
368 let expression = self.parse_expression(&expr_pair)?;
369
370 Ok(ConstantInfo {
371 constant_identifier,
372 annotation: maybe_annotation,
373 expression: Box::new(expression),
374 })
375 }
376
377 fn module_path_and_items(
378 &self,
379 pair: &Pair<Rule>,
380 ) -> Result<(Vec<Node>, ImportItems), ParseError> {
381 let mut inner = Self::convert_into_iterator(pair);
382 let import_path = Self::next_pair(&mut inner)?;
383
384 let mut segments = Vec::new();
385 for pair in import_path.into_inner() {
386 segments.push(self.to_node(&pair));
387 }
388
389 let items = match inner.next() {
390 Some(found_rule) => match found_rule.as_rule() {
391 Rule::all_imports => ImportItems::All,
392 Rule::import_list => {
393 let mut imported_items = Vec::new();
394 for list_item in found_rule.into_inner() {
395 let item = Self::next_pair(&mut list_item.into_inner())?;
396
397 let import_item = match item.as_rule() {
398 Rule::identifier => {
399 ImportItem::Identifier(LocalIdentifier::new(self.to_node(&item)))
400 }
401 Rule::type_identifier => {
402 ImportItem::Type(LocalTypeIdentifier::new(self.to_node(&item)))
403 }
404 _ => {
405 return Err(self
406 .create_error_pair(SpecificError::ExpectedIdentifier, &item));
407 }
408 };
409
410 imported_items.push(import_item);
411 }
412 if imported_items.is_empty() {
413 ImportItems::Nothing
414 } else {
415 ImportItems::Items(imported_items)
416 }
417 }
418 _ => panic!("was not all_imports or import_list"),
419 },
420 None => ImportItems::Nothing,
421 };
422
423 Ok((segments, items))
424 }
425
426 fn parse_use(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
427 let (segments, items) = self.module_path_and_items(pair)?;
428
429 Ok(DefinitionKind::Use(Use {
430 module_path: ModulePath(segments),
431 items,
432 }))
433 }
434
435 fn parse_mod(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
436 let (segments, items) = self.module_path_and_items(pair)?;
437
438 Ok(DefinitionKind::Mod(Mod {
439 module_path: ModulePath(segments),
440 items,
441 }))
442 }
443
444 fn pair_to_rule(rule: &Pair<Rule>) -> String {
445 format!("{:?}", rule.as_rule())
446 }
447
448 fn parse_block(&self, block_pair: &Pair<Rule>) -> Result<Expression, ParseError> {
449 if block_pair.as_rule() != Rule::block {
450 return Err(self.create_error_pair(SpecificError::ExpectedBlock, block_pair));
451 }
452
453 let mut expressions = Vec::new();
454
455 for pair in Self::convert_into_iterator(block_pair) {
456 if pair.as_rule() != Rule::expression {
457 return Err(self.create_error_pair(
458 SpecificError::UnexpectedRuleInParseScript(format!(
459 "Expected expression_in_block, got: {:?}",
460 pair.as_rule()
461 )),
462 block_pair,
463 ));
464 }
465
466 match pair.as_rule() {
467 Rule::expression => {
468 let expr = self.parse_expression(&pair)?;
469 expressions.push(expr);
470 }
471 _ => {
472 return Err(self.create_error_pair(
473 SpecificError::UnexpectedRuleInParseScript(format!(
474 "Unexpected rule in parse_block: {:?}",
475 pair.as_rule()
476 )),
477 &pair,
478 ));
479 }
480 }
481 }
482
483 let block_expr = self.create_expr(ExpressionKind::Block(expressions), block_pair);
484 Ok(block_expr)
485 }
486
487 fn parse_with_expr(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
488 let mut inner = Self::convert_into_iterator(pair);
489 let binding_list_pair = inner.next().expect("variable list missing");
490 let binding_list = self.parse_variable_binding_list(&binding_list_pair)?;
491
492 let expr_pair = inner.next().expect("block missing");
493 let expr = self.parse_expression(&expr_pair)?;
494
495 let with_expr = self.create_expr(ExpressionKind::With(binding_list, Box::from(expr)), pair);
496 Ok(with_expr)
497 }
498
499 fn parse_when_expr(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
500 let mut inner = Self::convert_into_iterator(pair);
501 let binding_list =
502 self.parse_variable_binding_list(&inner.next().expect("variable list missing"))?;
503 let expr = self.parse_expression(&inner.next().expect("block missing"))?;
504
505 let next = inner.next();
506 let else_expr = if let Some(found_else) = next {
507 Some(Box::new(self.parse_expression(&found_else)?))
508 } else {
509 None
510 };
511
512 Ok(self.create_expr(
513 ExpressionKind::When(binding_list, Box::from(expr), else_expr),
514 pair,
515 ))
516 }
517
518 fn parse_when_variable_binding(
519 &self,
520 pair: &Pair<Rule>,
521 ) -> Result<VariableBinding, ParseError> {
522 let mut inner = Self::convert_into_iterator(pair);
523
524 let variable = self.parse_variable_item(&inner.next().expect("variable missing"))?;
525
526 let expression = match inner.next() {
527 Some(expr_pair) => Some(self.parse_arg_expression(&expr_pair)?),
528 _ => None,
529 };
530
531 Ok(VariableBinding {
532 variable,
533 expression,
534 })
535 }
536
537 fn parse_variable_binding_list(
538 &self,
539 pair: &Pair<Rule>,
540 ) -> Result<Vec<VariableBinding>, ParseError> {
541 let inner = Self::convert_into_iterator(pair);
542 let mut bindings = Vec::new();
543
544 for binding_pair in inner {
546 if binding_pair.as_rule() == Rule::variable_binding {
547 bindings.push(self.parse_when_variable_binding(&binding_pair)?);
548 }
549 }
550
551 Ok(bindings)
552 }
553 fn parse_if_expression(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
554 let mut inner = Self::convert_into_iterator(pair);
555 let condition = self.parse_expression(&Self::next_pair(&mut inner)?)?;
556 let then_branch = self.parse_expression(&Self::next_pair(&mut inner)?)?;
557 let else_branch = inner
558 .next()
559 .map(|p| {
560 match p.as_rule() {
561 Rule::if_expr => self.parse_if_expression(&p), _ => self.parse_expression(&p), }
564 })
565 .transpose()?;
566
567 Ok(self.create_expr(
568 ExpressionKind::If(
569 Box::new(condition),
570 Box::new(then_branch),
571 else_branch.map(Box::new),
572 ),
573 pair,
574 ))
575 }
576
577 #[allow(clippy::too_many_lines)]
578 fn parse_postfix_expression(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
579 assert_eq!(pair.as_rule(), Rule::postfix);
580 let mut inner = pair.clone().into_inner();
581
582 let primary_pair = inner.next().ok_or_else(|| {
583 self.create_error_pair(SpecificError::UnexpectedPostfixOperator, pair)
584 })?;
585 let start_expr = self.parse_term(&primary_pair)?;
586 let mut postfixes = Vec::new();
588 if inner.len() == 0 {
589 return Ok(start_expr);
590 }
591
592 for op_pair in inner.clone() {
593 match op_pair.as_rule() {
595 Rule::postfix_op => {
596 let mut sub_inner = op_pair.clone().into_inner();
597 let child = sub_inner.next().ok_or_else(|| {
598 self.create_error_pair(SpecificError::UnexpectedPostfixOperator, &op_pair)
599 })?;
600
601 match child.as_rule() {
602 Rule::unwrap_postfix => {
603 postfixes
604 .push(Postfix::OptionalChainingOperator(self.to_node(&op_pair)));
605 }
606
607 Rule::function_call_postfix => {
608 let (maybe_generics, args) =
609 self.parse_function_call_postfix(&child)?;
610 let node = self.to_node(&op_pair);
611 postfixes.push(Postfix::FunctionCall(node, maybe_generics, args));
612 }
613
614 Rule::member_call_postfix => {
615 let (member_identifier, maybe_generics, args) =
616 self.parse_member_call_postfix(&child)?;
617
618 postfixes.push(Postfix::MemberCall(
619 member_identifier.0,
620 maybe_generics,
621 args,
622 ));
623 }
624
625 Rule::member_access_postfix => {
626 let mut inner = child.into_inner();
627 let dot_id = Self::next_pair(&mut inner)?;
628 let identifier = self.parse_dot_identifier(&dot_id)?;
629 postfixes.push(Postfix::FieldAccess(identifier.0));
630 }
631
632 Rule::subscript_postfix => {
633 let mut arr_inner = child.clone().into_inner();
634
635 let first_expr_pair = arr_inner.next().ok_or_else(|| {
636 self.create_error_pair(
637 SpecificError::UnexpectedPostfixOperator,
638 &child,
639 )
640 })?;
641 let first_expression = self.parse_expression(&first_expr_pair)?;
642
643 let second_expr_pair = arr_inner.next();
644 match second_expr_pair {
645 Some(pair) => {
646 let second_expression = self.parse_expression(&pair)?;
647 postfixes.push(Postfix::SubscriptTuple(
648 first_expression,
649 second_expression,
650 ));
651 }
652 None => {
653 postfixes.push(Postfix::Subscript(first_expression));
654 }
655 }
656 }
657
658 _ => {
659 return Err(self.create_error_pair(
660 SpecificError::UnexpectedPostfixOperator,
661 &child,
662 ));
663 }
664 }
665 }
666 _ => {
667 return Err(
668 self.create_error_pair(SpecificError::UnexpectedPostfixOperator, &op_pair)
669 );
670 }
671 }
672 }
673
674 Ok(self.create_expr(
675 ExpressionKind::PostfixChain(PostfixChain {
676 base: Box::from(start_expr),
677 postfixes,
678 }),
679 pair,
680 ))
681 }
682
683 fn parse_member_call_postfix(
684 &self,
685 pair: &Pair<Rule>,
686 ) -> Result<(FieldName, Option<Vec<GenericParameter>>, Vec<Expression>), ParseError> {
687 debug_assert_eq!(pair.as_rule(), Rule::member_call_postfix);
688
689 let mut inner = pair.clone().into_inner();
690
691 let member_access = Self::next_pair(&mut inner)?;
692 debug_assert_eq!(member_access.as_rule(), Rule::member_access_postfix);
693 let mut ma_inner = member_access.into_inner();
694 let dot_id = Self::next_pair(&mut ma_inner)?;
695 let member_identifier = self.parse_dot_identifier(&dot_id)?;
696
697 let mut generic_args: Option<Vec<GenericParameter>> = None;
698 if let Some(peeked_pair) = inner.peek() {
700 if peeked_pair.as_rule() == Rule::generic_arguments {
701 let generic_args_pair = Self::next_pair(&mut inner)?;
702 generic_args = Some(self.parse_generic_arguments(&generic_args_pair)?);
703 }
704 } else {
705 panic!("shouldn't happen in member_call_postfix")
706 }
707
708 let args_pair = Self::next_pair(&mut inner)?;
709 let args = self.parse_function_call_arguments(&args_pair)?;
710
711 Ok((member_identifier, generic_args, args))
712 }
713
714 fn parse_type_def(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
715 let mut inner = Self::convert_into_iterator(pair);
716 let alias_name = self.expect_local_type_identifier_next(&mut inner)?;
717 let referenced_type = self.parse_type(inner.next().expect("should work"))?;
718
719 let alias_type = AliasType {
720 identifier: alias_name,
721 referenced_type,
722 };
723
724 Ok(DefinitionKind::AliasDef(alias_type))
725 }
726
727 fn parse_struct_type_field(&self, pair: &Pair<Rule>) -> Result<StructTypeField, ParseError> {
728 debug_assert_eq!(pair.as_rule(), Rule::struct_type_field);
729
730 let mut field_inner = Self::convert_into_iterator(pair);
731 let field_name = self.expect_field_label_next(&mut field_inner)?;
732 let field_type = self.parse_type(Self::next_pair(&mut field_inner)?)?;
733 let struct_type_field = StructTypeField {
734 field_name,
735 field_type,
736 };
737
738 Ok(struct_type_field)
739 }
740
741 fn parse_struct_type_fields(
742 &self,
743 pair: &Pair<Rule>,
744 ) -> Result<Vec<StructTypeField>, ParseError> {
745 debug_assert_eq!(pair.as_rule(), Rule::struct_type_fields);
746 let mut fields = Vec::new();
747 for field_def in Self::convert_into_iterator(pair) {
748 let anonymous_struct_field = self.parse_struct_type_field(&field_def)?;
749
750 fields.push(anonymous_struct_field);
751 }
752 Ok(fields)
753 }
754
755 fn parse_struct_type(&self, pair: &Pair<Rule>) -> Result<AnonymousStructType, ParseError> {
756 debug_assert_eq!(pair.as_rule(), Rule::struct_type);
757 let fields = Self::right_alternative(pair)?;
758 let fields = self.parse_struct_type_fields(&fields)?;
759 let struct_type = AnonymousStructType::new(fields);
760 Ok(struct_type)
761 }
762
763 fn parse_tuple_type_elements(&self, pair: &Pair<Rule>) -> Result<Vec<Type>, ParseError> {
764 debug_assert_eq!(pair.as_rule(), Rule::tuple_type);
765 let mut types = Vec::new();
766 for type_pair in pair.clone().into_inner() {
767 let type_value = self.parse_type(type_pair)?;
768 types.push(type_value);
769 }
770 Ok(types)
771 }
772
773 fn parse_struct_def(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
774 let mut inner = Self::convert_into_iterator(pair).peekable();
775
776 let name_with_optional_type_params =
777 self.parse_local_type_identifier_with_optional_type_variables(&inner.next().unwrap())?;
778
779 let struct_type_pair_option = inner.next();
783 let struct_type_result = match struct_type_pair_option {
784 Some(struct_type_pair) => Some(self.parse_struct_type(&struct_type_pair)?),
785 None => None,
786 };
787
788 let struct_type = struct_type_result.map_or_else(
789 || AnonymousStructType::new(vec![]),
790 |found_result| found_result,
791 );
792
793 Ok(DefinitionKind::NamedStructDef(NamedStructDef {
794 identifier: name_with_optional_type_params,
795 struct_type,
796 }))
797 }
798
799 fn parse_function_def(
800 &self,
801 pair: &Pair<Rule>,
802 attributes: &[Attribute],
803 ) -> Result<DefinitionKind, ParseError> {
804 let function_pair = self.next_inner_pair(pair)?;
805
806 match function_pair.as_rule() {
807 Rule::normal_function => {
808 let mut inner = function_pair.clone().into_inner();
809 let signature_pair = inner.next().ok_or_else(|| {
810 self.create_error_pair(SpecificError::MissingFunctionSignature, &function_pair)
811 })?;
812
813 let signature = self.parse_function_signature(&signature_pair)?;
814
815 let body = self.parse_block(&inner.next().ok_or_else(|| {
816 self.create_error_pair(SpecificError::MissingFunctionBody, &function_pair)
817 })?)?;
818
819 Ok(DefinitionKind::FunctionDef(Function::Internal(
820 FunctionWithBody {
821 declaration: signature,
822 attributes: attributes.to_vec(),
823 body,
824 },
825 )))
826 }
827 Rule::external_function => {
828 let mut inner = function_pair.clone().into_inner();
829 let id = inner.next().unwrap();
830 let signature_pair = inner.next().ok_or_else(|| {
831 self.create_error_pair(
832 SpecificError::MissingFunctionSignature,
833 &function_pair.clone(),
834 )
835 })?;
836
837 let signature = self.parse_function_signature(&signature_pair)?;
838 Ok(DefinitionKind::FunctionDef(Function::External(
839 self.to_node(&id),
840 signature,
841 )))
842 }
843 _ => {
844 Err(self
845 .create_error_pair(SpecificError::ExpectedFunctionDefinition, &function_pair))
846 }
847 }
848 }
849 fn parse_function_signature(
850 &self,
851 pair: &Pair<Rule>,
852 ) -> Result<FunctionDeclaration, ParseError> {
853 if pair.as_rule() != Rule::function_signature {
854 return Err(self.create_error_pair(SpecificError::MissingFunctionSignature, pair));
855 }
856
857 let mut inner = pair.clone().into_inner();
858
859 let function_name = self.expect_function_identifier_next(&mut inner)?;
860
861 let mut maybe_next_token = inner.next();
862 if let Some(next_rule) = &maybe_next_token
863 && next_rule.as_rule() == Rule::generic_type_variables {
864 maybe_next_token = inner.next();
866 }
867
868 let (parameters, return_type) = match maybe_next_token {
869 Some(token) if token.as_rule() == Rule::parameter_list => {
870 let params = self.parse_parameters(&token)?;
871
872 let ret_type = if let Some(return_type_pair) = inner.next() {
873 Some(self.parse_return_type(&return_type_pair)?)
874 } else {
875 None
876 };
877
878 (params, ret_type)
879 }
880
881 Some(token) if token.as_rule() == Rule::return_type => {
882 (Vec::new(), Some(self.parse_return_type(&token)?))
883 }
884 _ => (Vec::new(), None),
885 };
886
887 Ok(FunctionDeclaration {
888 name: function_name.0,
889 params: parameters,
890 self_parameter: None,
891 return_type,
892 })
893 }
894
895 fn parse_return_type(&self, pair: &Pair<Rule>) -> Result<Type, ParseError> {
896 let inner_pair = self.next_inner_pair(pair)?;
897 self.parse_type(inner_pair)
898 }
899
900 pub fn parse_parameters(&self, pair: &Pair<Rule>) -> Result<Vec<Parameter>, ParseError> {
901 let mut parameters = Vec::new();
902
903 for param_pair in Self::convert_into_iterator(pair) {
904 match param_pair.as_rule() {
905 Rule::parameter => {
906 let mut iterator = Self::convert_into_iterator(¶m_pair);
907 let may_mut_pair = iterator.next().unwrap();
908 let var = self.parse_maybe_mut_identifier(&may_mut_pair)?;
909 let type_pair = iterator.next().unwrap();
910 let param_type = self.parse_type(type_pair.clone())?;
911
912 parameters.push(Parameter {
913 variable: var,
914 param_type,
915 });
916 }
917 Rule::self_parameter => {
918 panic!("should have been handled before parsing parameters")
919 }
920 _ => {
921 return Err(
922 self.create_error_pair(SpecificError::ExpectedParameter, ¶m_pair)
923 );
924 }
925 }
926 }
927
928 Ok(parameters)
929 }
930
931 fn parse_impl_def(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
932 let mut inner = Self::convert_into_iterator(pair);
933 let name_with_optional_type_params =
934 self.parse_local_type_identifier_with_optional_type_variables(&inner.next().unwrap())?;
935
936 let mut functions = Vec::new();
937
938 for item_pair in inner {
939 if item_pair.as_rule() == Rule::impl_item {
940 let inner_item = self.next_inner_pair(&item_pair)?;
941 match inner_item.as_rule() {
942 Rule::external_member_function => {
943 let mut inner_inner_item = inner_item.into_inner();
944 let id = inner_inner_item.next().unwrap();
945 let signature =
946 self.parse_member_signature(&inner_inner_item.next().unwrap())?;
947 functions.push(Function::External(self.to_node(&id), signature));
948 }
949 Rule::normal_member_function => {
950 let function_data = self.parse_member_data(&inner_item)?;
951 functions.push(Function::Internal(function_data));
952 }
953 _ => {
954 return Err(
955 self.create_error_pair(SpecificError::ExpectedImplItem, &inner_item)
956 );
957 }
958 }
959 }
960 }
961
962 Ok(DefinitionKind::ImplDef(
963 name_with_optional_type_params,
964 functions,
965 ))
966 }
967
968 fn parse_member_signature(&self, pair: &Pair<Rule>) -> Result<FunctionDeclaration, ParseError> {
969 debug_assert_eq!(pair.as_rule(), Rule::member_signature);
970
971 let mut inner = pair.clone().into_inner();
972
973 let name = self.expect_function_identifier_next(&mut inner)?;
974
975 let maybe_next_token = inner.peek();
977 if let Some(next_rule) = &maybe_next_token
978 && next_rule.as_rule() == Rule::generic_type_variables {
979 let _ = inner.next();
981 }
982
983 let mut parameters = Vec::new();
984 let mut self_parameter = None;
985 let mut return_type = None;
986
987 for next_pair in inner {
988 match next_pair.as_rule() {
989 Rule::self_parameter => {
990 let mut mut_keyword_node = None;
991 let mut self_node = None;
992
993 for pair in next_pair.into_inner() {
994 match pair.as_rule() {
995 Rule::mut_keyword => {
996 mut_keyword_node = Some(self.to_node(&pair));
997 }
998 Rule::self_identifier => {
999 self_node = Some(self.to_node(&pair));
1000 }
1001 _ => unreachable!("Unexpected rule in self_parameter"),
1002 }
1003 }
1004
1005 self_parameter = Some(SelfParameter {
1006 is_mutable: mut_keyword_node,
1007 self_node: self_node.expect("self node must exist"),
1008 });
1009 }
1010 Rule::parameter_list => {
1011 parameters = self.parse_parameters(&next_pair)?;
1012 }
1013 Rule::return_type => {
1014 return_type = Some(self.parse_return_type(&next_pair)?);
1015 }
1016 _ => {}
1017 }
1018 }
1019
1020 Ok(FunctionDeclaration {
1021 name: name.0,
1022 params: parameters,
1023 self_parameter,
1024 return_type,
1025 })
1026 }
1027
1028 fn parse_member_data(&self, pair: &Pair<Rule>) -> Result<FunctionWithBody, ParseError> {
1029 if pair.as_rule() != Rule::normal_member_function {
1030 return Err(self.create_error_pair(SpecificError::ExpectedMemberSignature, pair));
1031 }
1032
1033 let mut inner = Self::convert_into_iterator(pair).peekable();
1034
1035 let mut attributes = Vec::new();
1036 while let Some(next) = inner.peek() {
1037 if next.as_rule() == Rule::attribute {
1038 let attr_pair = inner.next().unwrap();
1039 let attr = self.parse_attribute(&attr_pair)?;
1040 attributes.push(attr);
1041 } else {
1042 break;
1043 }
1044 }
1045
1046 let signature_pair = Self::next_pair(&mut inner)?;
1047 let signature = self.parse_member_signature(&signature_pair)?;
1048
1049 let block_pair = Self::next_pair(&mut inner)?;
1050 let body = self.parse_block(&block_pair)?;
1051
1052 Ok(FunctionWithBody {
1053 attributes,
1054 declaration: signature,
1055 body,
1056 })
1057 }
1058
1059 fn parse_for_loop(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1060 let mut inner = Self::convert_into_iterator(pair);
1061
1062 let pattern_pair = Self::next_pair(&mut inner)?;
1063 if pattern_pair.as_rule() != Rule::for_pattern {
1064 return Err(self.create_error_pair(SpecificError::ExpectedForPattern, &pattern_pair));
1065 }
1066
1067 let inner_pattern = self.next_inner_pair(&pattern_pair)?;
1068 let pattern = match inner_pattern.as_rule() {
1069 Rule::maybe_mut_identifier => {
1070 let mut inner_iter = inner_pattern.clone().into_inner();
1071 let is_mutable = inner_iter
1072 .peek()
1073 .is_some_and(|p| p.as_rule() == Rule::mut_keyword);
1074
1075 let is_mut = if is_mutable {
1076 let mut_node = self.to_node(&inner_iter.next().unwrap());
1077 Some(mut_node)
1078 } else {
1079 None
1080 };
1081
1082 let identifier = if is_mutable {
1083 self.expect_identifier_next(&mut inner_iter)?.0
1084 } else {
1085 self.to_node(&inner_pattern)
1086 };
1087
1088 ForPattern::Single(ForVar { identifier, is_mut })
1089 }
1090 Rule::for_pair => {
1091 let mut vars = Self::convert_into_iterator(&inner_pattern);
1092
1093 let first_var_pair = Self::next_pair(&mut vars)?;
1095 let mut first_inner_iter = first_var_pair.clone().into_inner();
1096 let first_is_mut = if first_inner_iter
1097 .peek()
1098 .is_some_and(|p| p.as_rule() == Rule::mut_keyword)
1099 {
1100 Some(self.to_node(&first_inner_iter.next().unwrap()))
1101 } else {
1102 None
1103 };
1104
1105 let first_identifier = if first_is_mut.is_some() {
1106 self.expect_identifier_next(&mut first_inner_iter)?.0
1107 } else {
1108 self.to_node(&first_var_pair)
1109 };
1110
1111 let second_var_pair = Self::next_pair(&mut vars)?;
1113 let mut second_inner_iter = second_var_pair.clone().into_inner();
1114 let second_is_mut = if second_inner_iter
1115 .peek()
1116 .is_some_and(|p| p.as_rule() == Rule::mut_keyword)
1117 {
1118 Some(self.to_node(&second_inner_iter.next().unwrap()))
1119 } else {
1120 None
1121 };
1122
1123 let second_identifier = if second_is_mut.is_some() {
1124 self.expect_identifier_next(&mut second_inner_iter)?.0
1125 } else {
1126 self.to_node(&second_var_pair)
1127 };
1128
1129 ForPattern::Pair(
1130 ForVar {
1131 identifier: first_identifier,
1132 is_mut: first_is_mut,
1133 },
1134 ForVar {
1135 identifier: second_identifier,
1136 is_mut: second_is_mut,
1137 },
1138 )
1139 }
1140 _ => {
1141 return Err(
1142 self.create_error_pair(SpecificError::InvalidForPattern, &inner_pattern)
1143 );
1144 }
1145 };
1146
1147 let next_pair = Self::next_pair(&mut inner)?;
1148 let iterable_expression = self.parse_arg_expression(&next_pair)?;
1149
1150 let mut_expression = IterableExpression {
1151 expression: Box::new(iterable_expression),
1152 };
1153
1154 let body = self.parse_expression(&Self::next_pair(&mut inner)?)?;
1155
1156 Ok(self.create_expr(
1158 ExpressionKind::ForLoop(pattern, mut_expression, Box::from(body)),
1159 pair,
1160 ))
1161 }
1162
1163 fn parse_while_loop(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1164 let mut inner = Self::convert_into_iterator(pair);
1165
1166 let condition = self.parse_expression(&Self::next_pair(&mut inner)?)?;
1167
1168 let body = self.parse_expression(&Self::next_pair(&mut inner)?)?;
1169
1170 Ok(self.create_expr(
1171 ExpressionKind::WhileLoop(Box::from(condition), Box::from(body)),
1172 pair,
1173 ))
1174 }
1175
1176 fn parse_expression(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1177 let sub = &Self::right_alternative(pair)?;
1178 match sub.as_rule() {
1179 Rule::qualified_identifier => Ok(self.create_expr(
1188 ExpressionKind::VariableReference(Variable::new(self.to_node(sub), None)),
1189 sub,
1190 )),
1191 Rule::block => self.parse_block(sub),
1192
1193 Rule::assignment => self.parse_assignment_expression(sub),
1194 Rule::destructuring_assignment => self.parse_destructuring_assignment(sub),
1195 Rule::variable_definition => self.parse_variable_definition(sub),
1196
1197 Rule::addition => self.parse_addition(sub),
1198 Rule::range => self.parse_range(sub),
1199 Rule::logical => self.parse_logical(sub),
1200 Rule::none_coalesce => self.parse_none_coalesce(sub),
1201 Rule::comparison => self.parse_comparison(sub),
1202 Rule::multiplication => self.parse_multiplication(sub),
1203
1204 Rule::prefix => self.parse_prefix(sub),
1205
1206 Rule::match_expr => self.parse_match_expr(sub),
1207 Rule::initializer_list => self.parse_initializer_list_literal(sub),
1208 Rule::initializer_pair_list => self.parse_initializer_pair_list(sub),
1209 Rule::guard_expr => self.parse_guard_expr_list(sub),
1210 Rule::with_expr => self.parse_with_expr(sub),
1211 Rule::when_expr => self.parse_when_expr(sub),
1212 Rule::if_expr => self.parse_if_expression(sub),
1213 Rule::for_loop => self.parse_for_loop(sub),
1214 Rule::while_loop => self.parse_while_loop(sub),
1215
1216 Rule::prefix_op | Rule::op_neg | Rule::op_not | Rule::op_borrow_mut_ref => {
1218 let op = self.parse_unary_operator(sub)?;
1220 let expr = self.parse_postfix_expression(&self.next_inner_pair(sub)?)?;
1221 Ok(self.create_expr(ExpressionKind::UnaryOp(op, Box::new(expr)), sub))
1222 }
1223
1224 Rule::postfix => self.parse_postfix_expression(sub), _ => {
1226 error!(rule=?sub.as_rule(), "rule");
1227 Err(self.create_error_pair(
1228 SpecificError::UnexpectedExpressionType(Self::pair_to_rule(sub)),
1229 sub,
1230 ))
1231 }
1232 }
1233 }
1234
1235 fn parse_at_least_two_variable_list(
1236 &self,
1237 pair: &Pair<Rule>,
1238 ) -> Result<Vec<Variable>, ParseError> {
1239 debug_assert_eq!(pair.as_rule(), Rule::at_least_two_variables_list);
1240 let mut variables = Vec::new();
1241 for item_pair in pair.clone().into_inner() {
1242 variables.push(self.parse_variable_item(&item_pair)?);
1243 }
1244 Ok(variables)
1245 }
1246
1247 fn parse_optional_variable_list(&self, pair: &Pair<Rule>) -> Result<Vec<Variable>, ParseError> {
1248 debug_assert_eq!(pair.as_rule(), Rule::optional_variable_list);
1249 let mut variables = Vec::new();
1250 for item_pair in pair.clone().into_inner() {
1251 variables.push(self.parse_variable_item(&item_pair)?);
1252 }
1253 Ok(variables)
1254 }
1255
1256 fn parse_maybe_mut_identifier(&self, pair: &Pair<Rule>) -> Result<Variable, ParseError> {
1257 debug_assert_eq!(pair.as_rule(), Rule::maybe_mut_identifier);
1258 let mut inner = pair.clone().into_inner();
1259 let mut_node = if let Some(peeked) = inner.peek() {
1260 if peeked.as_rule() == Rule::mut_keyword {
1261 let node = self.to_node(&peeked);
1263 inner.next(); Some(node)
1265 } else {
1266 None
1267 }
1268 } else {
1269 None
1270 };
1271
1272 let name_pair = inner.next().ok_or_else(|| {
1273 self.create_error_pair(
1274 SpecificError::UnexpectedRuleInParseScript(
1275 "Expected identifier in variable_item".into(),
1276 ),
1277 pair,
1278 )
1279 })?;
1280
1281 if name_pair.as_rule() != Rule::identifier {
1282 return Err(self.create_error_pair(
1283 SpecificError::UnexpectedRuleInParseScript(format!(
1284 "Expected identifier, found {:?}",
1285 name_pair.as_rule()
1286 )),
1287 &name_pair,
1288 ));
1289 }
1290
1291 let variable = Variable {
1292 name: self.to_node(&name_pair),
1293 is_mutable: mut_node,
1294 };
1295
1296 Ok(variable)
1297 }
1298
1299 fn parse_variable_item(&self, pair: &Pair<Rule>) -> Result<Variable, ParseError> {
1300 debug_assert_eq!(pair.as_rule(), Rule::variable_item);
1301 let mut inner = pair.clone().into_inner();
1302 self.parse_maybe_mut_identifier(&inner.next().unwrap())
1303 }
1304
1305 fn parse_assignment_expression(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1306 let mut iterator = pair.clone().into_inner();
1307 let lhs_logical =
1308 self.parse_logical(&iterator.next().expect("parse_assignment_expression"))?;
1309 if let Some(assignment_op_pair) = iterator.peek().clone() {
1310 iterator.next();
1311 let assignment_op = self.parse_assignment_op(&assignment_op_pair)?;
1312 let rhs_expr = self.parse_expression(&iterator.next().unwrap())?;
1313 let kind = match assignment_op {
1314 AssignmentOperatorKind::Assign => {
1315 ExpressionKind::Assignment(Box::new(lhs_logical), Box::from(rhs_expr))
1316 }
1317 AssignmentOperatorKind::Compound(compound) => {
1318 let op = CompoundOperator {
1319 node: Self::node_ex(&assignment_op_pair),
1320 kind: compound,
1321 };
1322 ExpressionKind::CompoundAssignment(
1323 Box::from(lhs_logical),
1324 op,
1325 Box::from(rhs_expr),
1326 )
1327 }
1328 };
1329
1330 Ok(self.create_expr(kind, pair))
1331 } else {
1332 Ok(lhs_logical)
1333 }
1334 }
1335
1336 fn parse_assignment_op(&self, pair: &Pair<Rule>) -> Result<AssignmentOperatorKind, ParseError> {
1337 debug_assert_eq!(pair.as_rule(), Rule::assign_op);
1338 let sub = Self::right_alternative(pair)?;
1339 let op = match sub.as_rule() {
1340 Rule::compound_assign_op => {
1341 AssignmentOperatorKind::Compound(Self::parse_compound_assign_op(&sub)?)
1342 }
1343 Rule::normal_assign_op => AssignmentOperatorKind::Assign,
1344 _ => {
1345 return Err(Self::to_err(
1346 SpecificError::UnknownAssignmentOperator("strange".to_string()),
1347 &sub,
1348 ));
1349 }
1350 };
1351
1352 Ok(op)
1353 }
1354
1355 #[allow(clippy::too_many_lines)]
1356 fn parse_destructuring_assignment(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1357 debug_assert_eq!(pair.as_rule(), Rule::destructuring_assignment);
1358 let mut inner = pair.clone().into_inner();
1359
1360 let var_list_pair = inner.next().ok_or_else(|| {
1361 self.create_error_pair(
1362 SpecificError::UnexpectedRuleInParseScript("missing variable_list".to_string()),
1363 pair,
1364 )
1365 })?;
1366
1367 let variables = self.parse_at_least_two_variable_list(&var_list_pair)?;
1368
1369 let rhs_pair = inner.next().ok_or_else(|| {
1370 self.create_error_pair(
1371 SpecificError::UnexpectedRuleInParseScript("missing RHS expression".to_string()),
1372 pair,
1373 )
1374 })?;
1375 let rhs_expr = self.parse_expression(&rhs_pair)?;
1376
1377 Ok(self.create_expr(
1378 ExpressionKind::DestructuringAssignment(variables, Box::new(rhs_expr)),
1379 &rhs_pair,
1380 ))
1381 }
1382
1383 fn right_alternative<'a>(pair: &Pair<'a, Rule>) -> Result<Pair<'a, Rule>, ParseError> {
1384 pair.clone()
1385 .into_inner()
1386 .next()
1387 .ok_or_else(|| Self::to_err(SpecificError::CouldNotMoveRight, pair))
1388 }
1389
1390 pub fn parse_compound_assign_op(
1391 op_pair: &Pair<Rule>,
1392 ) -> Result<CompoundOperatorKind, ParseError> {
1393 debug_assert_eq!(op_pair.as_rule(), Rule::compound_assign_op);
1394
1395 let kind = match Self::right_alternative(op_pair)?.as_rule() {
1396 Rule::add_assign_op => CompoundOperatorKind::Add,
1397 Rule::sub_assign_op => CompoundOperatorKind::Sub,
1398 Rule::mul_assign_op => CompoundOperatorKind::Mul,
1399 Rule::div_assign_op => CompoundOperatorKind::Div,
1400 Rule::modulo_assign_op => CompoundOperatorKind::Modulo,
1401 _ => {
1402 return Err(Self::to_err(
1403 SpecificError::UnknownOperator(format!(
1404 "Found unexpected operator rule: {:?}",
1405 op_pair.as_rule()
1406 )),
1407 op_pair,
1408 ));
1409 }
1410 };
1411
1412 Ok(kind)
1413 }
1414
1415 fn parse_maybe_annotation(&self, inner: &mut Pairs<Rule>) -> Result<Option<Type>, ParseError> {
1416 let result = if let Some(peeked) = inner.peek() {
1417 if peeked.as_rule() == Rule::type_coerce {
1418 let type_coerce_pair = inner.next().unwrap();
1419 let mut type_inner = type_coerce_pair.clone().into_inner();
1420 let type_name_pair = type_inner.next().ok_or_else(|| {
1421 self.create_error_pair(SpecificError::MissingTypeName, &type_coerce_pair)
1422 })?;
1423 Some(self.parse_type(type_name_pair)?)
1424 } else {
1425 None
1426 }
1427 } else {
1428 None
1429 };
1430 Ok(result)
1431 }
1432
1433 #[allow(clippy::too_many_lines)]
1434 fn parse_variable_definition(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1435 debug_assert_eq!(pair.as_rule(), Rule::variable_definition);
1436 let mut inner = pair.clone().into_inner();
1437 let variable_item = Self::next_pair(&mut inner)?;
1438 let found_var = self.parse_variable_item(&variable_item)?;
1439
1440 let maybe_annotation = self.parse_maybe_annotation(&mut inner)?;
1441
1442 let rhs_expr = self.parse_expression(&inner.next().unwrap())?;
1443
1444 if maybe_annotation.is_some() || found_var.is_mutable.is_some() {
1445 Ok(self.create_expr(
1446 ExpressionKind::VariableDefinition(
1447 found_var,
1448 maybe_annotation,
1449 Box::from(rhs_expr),
1450 ),
1451 pair,
1452 ))
1453 } else {
1454 Ok(self.create_expr(
1455 ExpressionKind::VariableAssignment(found_var, Box::from(rhs_expr)),
1456 pair,
1457 ))
1458 }
1459 }
1460 fn parse_prefix(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1461 debug_assert_eq!(pair.as_rule(), Rule::prefix);
1462 let _span = pair.as_span();
1463 let inner = Self::convert_into_iterator(pair);
1464 let mut expr = None;
1465 let mut prefix_ops = Vec::new();
1466
1467 for part in inner {
1468 match part.as_rule() {
1469 Rule::prefix_op | Rule::op_neg | Rule::op_not => {
1470 let op = self.parse_unary_operator(&part)?;
1471 prefix_ops.push(op);
1472 }
1473 _ => {
1474 expr = Some(self.parse_postfix_expression(&part)?);
1475 break;
1476 }
1477 }
1478 }
1479
1480 let mut final_expr = expr.ok_or_else(|| {
1481 self.create_error_pair(SpecificError::ExpectedExpressionAfterPrefixOperator, pair)
1482 })?;
1483
1484 for op in prefix_ops.into_iter().rev() {
1485 final_expr = self.create_expr(ExpressionKind::UnaryOp(op, Box::new(final_expr)), pair);
1486 }
1487
1488 Ok(final_expr)
1489 }
1490
1491 fn parse_binary_operator(&self, pair: &Pair<Rule>) -> Result<BinaryOperator, ParseError> {
1492 let op = match pair.as_rule() {
1493 Rule::prefix_op => self.next_inner_pair(pair)?,
1494 _ => pair.clone(),
1495 };
1496
1497 let kind = match op.as_rule() {
1498 Rule::op_add => BinaryOperatorKind::Add,
1499 Rule::op_sub => BinaryOperatorKind::Subtract,
1500 Rule::op_mul => BinaryOperatorKind::Multiply,
1501 Rule::op_div => BinaryOperatorKind::Divide,
1502 Rule::op_mod => BinaryOperatorKind::Modulo,
1503 Rule::op_eq => BinaryOperatorKind::Equal,
1504 Rule::op_neq => BinaryOperatorKind::NotEqual,
1505 Rule::op_lt => BinaryOperatorKind::LessThan,
1506 Rule::op_lte => BinaryOperatorKind::LessEqual,
1507 Rule::op_gt => BinaryOperatorKind::GreaterThan,
1508 Rule::op_gte => BinaryOperatorKind::GreaterEqual,
1509 Rule::op_and => BinaryOperatorKind::LogicalAnd,
1510 Rule::op_or => BinaryOperatorKind::LogicalOr,
1511 Rule::op_none_coalesce => BinaryOperatorKind::NoneCoalescingOperator,
1512 _ => {
1513 panic!("unknown operator")
1514 }
1515 };
1516
1517 Ok(BinaryOperator {
1518 kind,
1519 node: self.to_node(pair),
1520 })
1521 }
1522
1523 fn parse_unary_operator(&self, pair: &Pair<Rule>) -> Result<UnaryOperator, ParseError> {
1524 let op = match pair.as_rule() {
1525 Rule::prefix_op => &self.next_inner_pair(pair)?,
1526 _ => pair,
1527 };
1528
1529 let node = self.to_node(op);
1530 match op.as_rule() {
1531 Rule::op_neg => Ok(UnaryOperator::Negate(node)),
1532 Rule::op_not => Ok(UnaryOperator::Not(node)),
1533 Rule::op_borrow_mut_ref => Ok(UnaryOperator::BorrowMutRef(node)),
1534 _ => Err(self.create_error_pair(
1535 SpecificError::UnexpectedUnaryOperator(Self::pair_to_rule(op)),
1536 op,
1537 )),
1538 }
1539 }
1540
1541 fn parse_module_segments(&self, pair: Pair<Rule>) -> Vec<Node> {
1542 pair.into_inner()
1543 .filter_map(|segment| {
1544 if segment.as_rule() == Rule::identifier {
1545 Some(self.to_node(&segment))
1546 } else {
1547 None
1548 }
1549 })
1550 .collect()
1551 }
1552
1553 fn parse_qualified_type_identifier(
1554 &self,
1555 pair: &Pair<Rule>,
1556 ) -> Result<QualifiedTypeIdentifier, ParseError> {
1557 let mut inner_pairs = pair.clone().into_inner();
1558 let mut generic_types = Vec::new();
1559
1560 let first = inner_pairs.next().ok_or_else(|| {
1561 self.create_error_pair(
1562 SpecificError::ExpectedTypeIdentifier(Self::pair_to_rule(pair)),
1563 pair,
1564 )
1565 })?;
1566
1567 match first.as_rule() {
1568 Rule::module_segments => {
1569 let module_path = self.parse_module_segments(first.clone());
1570 let type_id = inner_pairs.next().ok_or_else(|| {
1571 self.create_error_pair(SpecificError::ExpectedTypeIdentifierAfterPath, &first)
1572 })?;
1573
1574 let type_identifier = self.parse_local_type_identifier(&type_id)?;
1575
1576 if let Some(generic_params) = inner_pairs.next()
1578 && generic_params.as_rule() == Rule::generic_arguments {
1579 generic_types = self.parse_generic_arguments(&generic_params)?; }
1581
1582 Ok(QualifiedTypeIdentifier::new_with_generics(
1583 type_identifier,
1584 module_path,
1585 generic_types,
1586 ))
1587 }
1588 Rule::type_identifier => {
1589 let type_identifier = LocalTypeIdentifier(self.to_node(&first));
1590
1591 if let Some(generic_params) = inner_pairs.next()
1593 && generic_params.as_rule() == Rule::generic_arguments {
1594 generic_types = self.parse_generic_arguments(&generic_params)?;
1595 }
1596
1597 Ok(QualifiedTypeIdentifier::new_with_generics(
1598 type_identifier,
1599 Vec::new(),
1600 generic_types,
1601 ))
1602 }
1603 _ => Err(self.create_error_pair(
1604 SpecificError::ExpectedTypeIdentifier(Self::pair_to_rule(&first)),
1605 &first,
1606 )),
1607 }
1608 }
1609
1610 fn parse_qualified_identifier(
1611 &self,
1612 pair: &Pair<Rule>,
1613 ) -> Result<QualifiedIdentifier, ParseError> {
1614 let mut inner_pairs = pair.clone().into_inner();
1615 let mut generic_types = Vec::new();
1616
1617 let first = inner_pairs
1618 .next()
1619 .ok_or_else(|| self.create_error_pair(SpecificError::ExpectedIdentifier, pair))?;
1620
1621 match first.as_rule() {
1622 Rule::module_segments => {
1623 let module_path = self.parse_module_segments(first.clone());
1624 let id = inner_pairs.next().ok_or_else(|| {
1625 self.create_error_pair(SpecificError::ExpectedIdentifierAfterPath, &first)
1626 })?;
1627
1628 let identifier = self.to_node(&id);
1629
1630 if let Some(generic_params) = inner_pairs.next()
1632 && generic_params.as_rule() == Rule::generic_arguments {
1633 generic_types = self.parse_generic_arguments(&generic_params)?;
1635 }
1636
1637 Ok(QualifiedIdentifier::new_with_generics(
1638 identifier,
1639 module_path,
1640 generic_types,
1641 ))
1642 }
1643 Rule::identifier => {
1644 let type_identifier = self.to_node(&first);
1645
1646 if let Some(generic_params) = inner_pairs.next()
1648 && generic_params.as_rule() == Rule::generic_arguments {
1649 generic_types = self.parse_generic_arguments(&generic_params)?;
1651 }
1652
1653 Ok(QualifiedIdentifier::new_with_generics(
1654 type_identifier,
1655 Vec::new(),
1656 generic_types,
1657 ))
1658 }
1659 _ => Err(self.create_error_pair(SpecificError::ExpectedIdentifier, &first)),
1660 }
1661 }
1662
1663 fn parse_qualified_identifier_expression(
1664 &self,
1665 pair: &Pair<Rule>,
1666 ) -> Result<Expression, ParseError> {
1667 let qualified_identifier = self.parse_qualified_identifier(pair)?;
1668 Ok(self.create_expr(
1669 ExpressionKind::IdentifierReference(qualified_identifier),
1670 pair,
1671 ))
1672 }
1673
1674 fn parse_generic_arguments(
1675 &self,
1676 pair: &Pair<Rule>,
1677 ) -> Result<Vec<GenericParameter>, ParseError> {
1678 debug_assert_eq!(pair.as_rule(), Rule::generic_arguments);
1679
1680 let inner_pairs = pair.clone().into_inner();
1681 let mut generic_types = Vec::new();
1682
1683 for generic_parameter_pair in inner_pairs {
1684 let generic_parameter = match generic_parameter_pair.as_rule() {
1685 Rule::type_name => GenericParameter::Type(self.parse_type(generic_parameter_pair)?),
1686 Rule::generic_argument_int_tuple => {
1687 let mut pairs = generic_parameter_pair.clone().into_inner();
1688 let first = pairs.next().unwrap();
1689 let second = pairs.next().unwrap();
1690 let first_node = self.to_node(&first);
1691 let second_node = self.to_node(&second);
1692 GenericParameter::UnsignedTupleInt(first_node, second_node)
1693 }
1694 Rule::unsigned_int_lit => {
1695 GenericParameter::UnsignedInt(self.to_node(&generic_parameter_pair))
1696 }
1697 _ => panic!("unknown generic parameter"),
1698 };
1699
1700 generic_types.push(generic_parameter);
1701 }
1702
1703 Ok(generic_types)
1704 }
1705
1706 fn parse_local_type_identifier_node(&self, pair: &Pair<Rule>) -> Result<Node, ParseError> {
1707 if pair.as_rule() != Rule::type_identifier {
1708 return Err(self.create_error_pair(
1709 SpecificError::ExpectedTypeIdentifier(format!("{:?}", pair.as_rule())),
1710 pair,
1711 ));
1712 }
1713 Ok(self.to_node(pair))
1714 }
1715
1716 fn parse_generic_type_variables(
1717 &self,
1718 pair: &Pair<Rule>,
1719 ) -> Result<Vec<TypeVariable>, ParseError> {
1720 debug_assert_eq!(pair.as_rule(), Rule::generic_type_variables);
1721 let mut type_params = Vec::new();
1722
1723 let inner = Self::convert_into_iterator(pair);
1724 for type_variable in inner {
1725 let mut inner_type_var = type_variable.into_inner();
1726 let type_identifier_pair = inner_type_var.next().unwrap();
1727
1728 type_params.push(TypeVariable(
1729 self.parse_local_type_identifier_node(&type_identifier_pair)?,
1730 ));
1731 }
1732 Ok(type_params)
1733 }
1734
1735 fn parse_local_type_identifier_with_optional_type_variables(
1736 &self,
1737 pair: &Pair<Rule>,
1738 ) -> Result<LocalTypeIdentifierWithOptionalTypeVariables, ParseError> {
1739 debug_assert_eq!(
1740 pair.as_rule(),
1741 Rule::type_identifier_optional_type_variables
1742 );
1743
1744 let mut inner = pair.clone().into_inner();
1745 let name = self.expect_local_type_identifier_next(&mut inner)?;
1746
1747 let type_variables = if let Some(generic_params_pair) = inner.peek() {
1748 if generic_params_pair.as_rule() == Rule::generic_type_variables {
1750 let _ = inner.next().unwrap(); self.parse_generic_type_variables(&generic_params_pair)?
1752 } else {
1753 Vec::new()
1754 }
1755 } else {
1756 Vec::new()
1757 };
1758
1759 Ok(LocalTypeIdentifierWithOptionalTypeVariables {
1760 name: name.0,
1761 type_variables,
1762 })
1763 }
1764
1765 fn parse_struct_fields_expressions<'a>(
1766 &self,
1767 field_list_pair: &Pair<Rule>,
1768 ) -> Result<(Vec<FieldExpression>, bool), ParseError> {
1769 let mut fields = Vec::new();
1770 let mut has_rest = false;
1771
1772 for field_pair in field_list_pair.clone().into_inner() {
1773 match field_pair.as_rule() {
1774 Rule::struct_field => {
1775 let mut field_inner = field_pair.into_inner();
1776 let ident = self.expect_field_label_next(&mut field_inner)?;
1777 let field_name = FieldName(ident.0);
1778 let field_value = self.parse_expression(&field_inner.next().unwrap())?;
1779
1780 fields.push(FieldExpression {
1781 field_name,
1782 expression: field_value,
1783 });
1784 }
1785 Rule::rest_fields => {
1786 has_rest = true;
1787 }
1788 _ => {
1789 return Err(
1790 self.create_error_pair(SpecificError::ExpectedFieldOrRest, &field_pair)
1791 );
1792 }
1793 }
1794 }
1795
1796 Ok((fields, has_rest))
1797 }
1798
1799 fn parse_anonymous_struct_literal(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1800 let (fields, has_rest) = self.parse_anonymous_struct_literal_fields(pair)?;
1801 Ok(self.create_expr(
1802 ExpressionKind::AnonymousStructLiteral(fields, has_rest),
1803 pair,
1804 ))
1805 }
1806
1807 fn parse_anonymous_struct_literal_fields(
1808 &self,
1809 pair: &Pair<Rule>,
1810 ) -> Result<(Vec<FieldExpression>, bool), ParseError> {
1811 debug_assert_eq!(pair.as_rule(), Rule::anonymous_struct_literal);
1812 let mut inner = Self::convert_into_iterator(pair);
1813 let (field_expressions, detected_rest) =
1814 self.parse_struct_fields_expressions(&inner.next().unwrap())?;
1815
1816 Ok((field_expressions, detected_rest))
1817 }
1818
1819 fn parse_struct_literal_optional_fields(
1820 &self,
1821 pair: &Pair<Rule>,
1822 ) -> Result<(Vec<FieldExpression>, bool), ParseError> {
1823 debug_assert_eq!(pair.as_rule(), Rule::struct_literal_optional_field_list);
1824 let mut inner = Self::convert_into_iterator(pair);
1825 let (field_expressions, detected_rest) = if let Some(field_list) = inner.next() {
1826 self.parse_struct_fields_expressions(&field_list)?
1827 } else {
1828 (vec![], false)
1829 };
1830
1831 Ok((field_expressions, detected_rest))
1832 }
1833
1834 fn parse_struct_literal(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1835 let mut inner = Self::convert_into_iterator(pair);
1836
1837 let type_pair = inner.next().unwrap();
1838
1839 let struct_name = self.parse_qualified_type_identifier(&type_pair)?;
1840
1841 let anon_fields = inner.next().unwrap();
1842
1843 let (fields, has_rest) = self.parse_struct_literal_optional_fields(&anon_fields)?;
1844
1845 Ok(self.create_expr(
1846 ExpressionKind::NamedStructLiteral(struct_name, fields, has_rest),
1847 pair,
1848 ))
1849 }
1850
1851 fn parse_context_access(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1852 Ok(self.create_expr(ExpressionKind::ContextAccess, pair))
1853 }
1854
1855 fn parse_static_member_reference(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1856 let mut inner = pair.clone().into_inner();
1857
1858 let type_identifier = self.parse_qualified_type_identifier(&inner.next().unwrap())?;
1859 let member_name = self.expect_identifier_next(&mut inner)?;
1860
1861 Ok(self.create_expr(
1862 ExpressionKind::StaticMemberFunctionReference(type_identifier, member_name.0),
1863 pair,
1864 ))
1865 }
1866
1867 fn parse_constant_reference(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1868 debug_assert_eq!(pair.as_rule(), Rule::constant_reference);
1869 let mut inner_pairs = pair.clone().into_inner();
1870
1871 let mut first = inner_pairs.next().unwrap();
1872
1873 let module_path = if first.as_rule() == Rule::module_segments {
1874 let path = self.parse_module_segments(first.clone());
1875 first = inner_pairs.next().unwrap();
1876 Some(ModulePath(path))
1877 } else {
1878 None
1879 };
1880
1881 let identifier = QualifiedConstantIdentifier::new(self.to_node(&first), module_path);
1882
1883 Ok(self.create_expr(ExpressionKind::ConstantReference(identifier), pair))
1884 }
1885
1886 fn parse_term(&self, pair2: &Pair<Rule>) -> Result<Expression, ParseError> {
1887 debug_assert_eq!(pair2.as_rule(), Rule::term);
1888 let sub = &Self::right_alternative(pair2)?;
1889 match sub.as_rule() {
1890 Rule::qualified_identifier => self.parse_qualified_identifier_expression(sub),
1891 Rule::static_member_reference => self.parse_static_member_reference(sub),
1892
1893 Rule::enum_literal => {
1894 Ok(self.create_expr(ExpressionKind::Literal(self.parse_enum_literal(sub)?), sub))
1895 }
1896 Rule::constant_reference => self.parse_constant_reference(sub),
1897 Rule::parenthesized => {
1898 let inner = self.next_inner_pair(sub)?;
1899 self.parse_expression(&inner)
1900 }
1901 Rule::basic_literal => {
1902 let (literal, node) = self.parse_basic_literal(sub)?;
1903 Ok(self.create_expr_span(ExpressionKind::Literal(literal), node))
1904 }
1905 Rule::struct_literal => self.parse_struct_literal(sub),
1906 Rule::anonymous_struct_literal => self.parse_anonymous_struct_literal(sub),
1907 Rule::initializer_list => self.parse_initializer_list_literal(sub),
1908 Rule::initializer_pair_list => self.parse_initializer_pair_list(sub),
1909
1910 Rule::interpolated_string => self.parse_interpolated_string(sub),
1911
1912 Rule::lambda => self.parse_lambda(sub),
1913 Rule::context_access => self.parse_context_access(sub),
1914
1915 _ => {
1916 Err(self
1917 .create_error_pair(SpecificError::UnknownTerm(Self::pair_to_rule(sub)), sub))
1918 }
1919 }
1920 }
1921
1922 fn parse_interpolated_string(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
1923 let mut parts = Vec::new();
1924
1925 for part_pair in Self::convert_into_iterator(pair) {
1926 match part_pair.as_rule() {
1927 Rule::text => {
1928 parts.push(StringPart::Literal(
1929 self.to_node(&part_pair),
1930 self.unescape_string(&part_pair, false)?,
1931 ));
1932 }
1933 Rule::interpolation => {
1934 let inner = self.next_inner_pair(&part_pair.clone())?;
1935 let expr = match inner.as_rule() {
1936 Rule::expression => self.parse_expression(&inner)?,
1937 _ => {
1938 return Err(self.create_error_pair(
1939 SpecificError::ExpectedExpressionInInterpolation,
1940 &inner,
1941 ));
1942 }
1943 };
1944
1945 let format = match Self::convert_into_iterator(&part_pair).nth(1) {
1946 Some(fmt) => {
1947 if fmt.as_rule() == Rule::format_specifier {
1948 Some(self.parse_format_specifier(&fmt)?)
1949 } else {
1950 None
1951 }
1952 }
1953 _ => None,
1954 };
1955
1956 parts.push(StringPart::Interpolation(Box::new(expr), format));
1957 }
1958 _ => {
1959 return Err(self.create_error_pair(
1960 SpecificError::UnexpectedRuleInInterpolation,
1961 &part_pair,
1962 ));
1963 }
1964 }
1965 }
1966
1967 Ok(self.create_expr(ExpressionKind::InterpolatedString(parts), pair))
1968 }
1969
1970 fn parse_format_specifier(&self, pair: &Pair<Rule>) -> Result<FormatSpecifier, ParseError> {
1971 let node = self.to_node(pair);
1972 match pair.as_str() {
1973 "x" => Ok(FormatSpecifier::LowerHex(node)),
1974 "X" => Ok(FormatSpecifier::UpperHex(node)),
1975 "b" => Ok(FormatSpecifier::Binary(node)),
1976 "f" => Ok(FormatSpecifier::Float(node)),
1977 s if s.starts_with("..") => {
1978 let precision: u32 = s[2..s.len() - 1].parse().map_err(|_| {
1979 self.create_error_pair(SpecificError::InvalidPrecisionValue, pair)
1980 })?;
1981 let typ = match s.chars().last().unwrap() {
1982 'f' => PrecisionType::Float(node),
1983 's' => PrecisionType::String(node),
1984 _ => {
1985 return Err(
1986 self.create_error_pair(SpecificError::InvalidPrecisionType, pair)
1987 )?;
1988 }
1989 };
1990 Ok(FormatSpecifier::Precision(
1991 precision,
1992 self.to_node(pair),
1993 typ,
1994 ))
1995 }
1996 _ => Err(self.create_error_pair(SpecificError::InvalidFormatSpecifier, pair)),
1997 }
1998 }
1999
2000 fn parse_enum_literal(&self, pair: &Pair<Rule>) -> Result<LiteralKind, ParseError> {
2001 let mut inner = Self::convert_into_iterator(pair);
2002
2003 let first_pair = inner.next().unwrap();
2005 let (enum_type, variant_type_identifier) = if first_pair.as_rule() == Rule::qualified_type_identifier {
2006 let enum_type = Some(self.parse_qualified_type_identifier(&first_pair)?);
2008 let variant_pair = inner.next().unwrap(); let variant_type_identifier = LocalTypeIdentifier::new(self.to_node(&variant_pair));
2010 (enum_type, variant_type_identifier)
2011 } else if first_pair.as_rule() == Rule::type_identifier {
2012 let variant_type_identifier = LocalTypeIdentifier::new(self.to_node(&first_pair));
2014 (None, variant_type_identifier)
2015 } else {
2016 panic!("internal parse err");
2017 };
2018
2019 let enum_variant_literal_kind = match inner.next() {
2020 Some(fields_pair) => match fields_pair.as_rule() {
2021 Rule::struct_literal_optional_field_list => {
2022 let (field_expressions, detected_rest) =
2023 self.parse_struct_literal_optional_fields(&fields_pair)?;
2024 EnumVariantLiteralKind::Struct(
2025 field_expressions,
2026 detected_rest,
2027 )
2028 }
2029 Rule::tuple_fields => {
2030 let mut expressions = vec![];
2031 for field in Self::convert_into_iterator(&fields_pair) {
2032 let field_value = self.parse_expression(&field)?;
2033 expressions.push(field_value);
2034 }
2035 EnumVariantLiteralKind::Tuple(expressions)
2036 }
2037 _ => {
2038 error!("{:?}, {}", fields_pair.as_rule(), "strange");
2039 return Err(
2040 self.create_error_pair(SpecificError::UnexpectedVariantField, &fields_pair)
2041 );
2042 }
2043 },
2044 _ => EnumVariantLiteralKind::Simple,
2045 };
2046 let enum_variant_literal = EnumVariantLiteral {
2047 qualified_enum_type_name: enum_type,
2048 name: variant_type_identifier,
2049 kind: enum_variant_literal_kind,
2050 };
2051
2052 Ok(LiteralKind::EnumVariant(enum_variant_literal))
2053 }
2054
2055 fn unescape_unicode(
2056 &self,
2057 chars: &mut Peekable<Chars>,
2058 octets: &mut Vec<u8>,
2059 pair: &Pair<Rule>,
2060 ) -> Result<(), ParseError> {
2061 match chars.next() {
2062 Some('(') => {
2063 let mut hex_digits = String::new();
2064
2065 while let Some(&c) = chars.peek() {
2066 if c == ')' {
2067 break;
2068 }
2069 if c.is_ascii_hexdigit() && hex_digits.len() < 6 {
2070 hex_digits.push(c);
2071 chars.next();
2072 } else {
2073 return Err(
2074 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2075 );
2076 }
2077 }
2078
2079 match chars.next() {
2080 Some(')') => {
2081 if hex_digits.is_empty() {
2082 return Err(
2083 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2084 );
2085 }
2086
2087 let code = u32::from_str_radix(&hex_digits, 16).map_err(|_| {
2088 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2089 })?;
2090
2091 if code > 0x0010_FFFF {
2092 return Err(
2093 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2094 );
2095 }
2096
2097 if let Some(c) = std::char::from_u32(code) {
2098 let mut buf = [0; 4];
2099 let encoded = c.encode_utf8(&mut buf);
2100 octets.extend_from_slice(encoded.as_bytes());
2101 } else {
2102 return Err(
2103 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2104 );
2105 }
2106 }
2107 _ => {
2108 return Err(
2109 self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair)
2110 );
2111 }
2112 }
2113 }
2114 _ => {
2115 return Err(self.create_error_pair(SpecificError::InvalidUnicodeEscape, pair));
2116 }
2117 }
2118 Ok(())
2119 }
2120
2121 fn unescape_hex(
2122 &self,
2123 chars: &mut Peekable<Chars>,
2124 pair: &Pair<Rule>,
2125 ) -> Result<u8, ParseError> {
2126 let mut hex_digits = String::new();
2127 for _ in 0..2 {
2128 match chars.next() {
2129 Some(h) if h.is_ascii_hexdigit() => {
2130 hex_digits.push(h);
2131 }
2132 _ => {
2133 return Err(self.create_error_pair(SpecificError::InvalidHexEscape, pair));
2134 }
2135 }
2136 }
2137 u8::from_str_radix(&hex_digits, 16)
2138 .map_err(|_| self.create_error_pair(SpecificError::InvalidHexEscape, pair))
2139 }
2140
2141 fn unescape_string(&self, pair: &Pair<Rule>, is_literal: bool) -> Result<String, ParseError> {
2142 let mut octets = Vec::new();
2143
2144 let raw = if is_literal {
2145 &pair.as_str()[1..pair.as_str().len() - 1]
2146 } else {
2147 pair.as_str()
2148 };
2149
2150 let mut chars = raw.chars().peekable();
2151
2152 while let Some(ch) = chars.next() {
2153 if ch == '\\' {
2154 let Some(next_ch) = chars.next() else {
2155 return Err(
2156 self.create_error_pair(SpecificError::UnfinishedEscapeSequence, pair)
2157 );
2158 };
2159 match next_ch {
2160 'n' => {
2161 octets.push(b'\n');
2162 }
2163 't' => {
2164 octets.push(b'\t');
2165 }
2166 '\\' => {
2167 octets.push(b'\\');
2168 }
2169 '"' => {
2170 octets.push(b'"');
2171 }
2172 '\'' => {
2173 octets.push(b'\'');
2174 }
2175 'x' => {
2177 let code = self.unescape_hex(&mut chars, pair)?;
2178 octets.push(code);
2179 }
2180 'u' => {
2182 self.unescape_unicode(&mut chars, &mut octets, pair)?;
2183 }
2184
2185 other => {
2186 return Err(self.create_error_pair(
2187 SpecificError::UnknownEscapeCharacter(other),
2188 pair,
2189 ));
2190 }
2191 }
2192 } else {
2193 let mut buf = [0; 4];
2194 let utf8_bytes = ch.encode_utf8(&mut buf);
2195 octets.extend_from_slice(utf8_bytes.as_bytes());
2196 }
2197 }
2198
2199 let output = String::from_utf8(octets)
2200 .map_err(|_| self.create_error_pair(SpecificError::InvalidUtf8Sequence, pair))?;
2201
2202 Ok(output)
2203 }
2204
2205 fn parse_basic_literal(&self, pair: &Pair<Rule>) -> Result<(LiteralKind, Node), ParseError> {
2206 debug_assert_eq!(pair.as_rule(), Rule::basic_literal);
2207 let inner = self.next_inner_pair(pair)?;
2208 let literal_kind = match inner.as_rule() {
2209 Rule::int_lit => LiteralKind::Int,
2210 Rule::float_lit => LiteralKind::Float,
2211 Rule::string_lit => {
2212 let processed_string = self.unescape_string(&inner, true)?;
2213 LiteralKind::String(processed_string)
2214 }
2215 Rule::bool_lit => LiteralKind::Bool,
2216 Rule::none_lit => LiteralKind::None,
2217 Rule::tuple_lit => {
2218 let mut expressions = Vec::new();
2219 for expr_pair in Self::convert_into_iterator(&inner) {
2220 expressions.push(self.parse_expression(&expr_pair)?);
2221 }
2222 LiteralKind::Tuple(expressions)
2223 }
2224 _ => return Err(self.create_error_pair(SpecificError::UnknownLiteral, &inner)),
2225 };
2226 Ok((literal_kind, self.to_node(&inner)))
2227 }
2228
2229 fn parse_initializer_list_literal(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2230 let mut elements = Vec::new();
2231 for element in Self::convert_into_iterator(pair) {
2232 elements.push(self.parse_expression(&element)?);
2233 }
2234 Ok(self.create_expr(
2235 ExpressionKind::Literal(LiteralKind::InternalInitializerList(elements)),
2236 pair,
2237 ))
2238 }
2239
2240 fn parse_initializer_pair_list(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2241 let mut entries = Vec::new();
2242
2243 for entry_pair in Self::convert_into_iterator(pair) {
2244 if entry_pair.as_rule() == Rule::map_entry {
2245 let mut entry_inner = Self::convert_into_iterator(&entry_pair);
2246 let key = self.parse_expression(&Self::next_pair(&mut entry_inner)?)?;
2247 let value = self.parse_expression(&Self::next_pair(&mut entry_inner)?)?;
2248 entries.push((key, value));
2249 }
2250 }
2251
2252 Ok(self.create_expr(
2253 ExpressionKind::Literal(LiteralKind::InternalInitializerPairList(entries)),
2254 pair,
2255 ))
2256 }
2257
2258 fn assert_end(pairs: &mut Pairs<Rule>) {
2259 assert!(pairs.next().is_none());
2260 }
2261
2262 fn parse_function_call_postfix(
2263 &self,
2264 pair: &Pair<Rule>,
2265 ) -> Result<(Option<Vec<GenericParameter>>, Vec<Expression>), ParseError> {
2266 debug_assert_eq!(pair.as_rule(), Rule::function_call_postfix);
2267 let mut inner = pair.clone().into_inner();
2268
2269 let mut generic_args: Option<Vec<GenericParameter>> = None;
2270 let args_pair: Pair<Rule>; if let Some(first_inner) = inner.peek() {
2273 if first_inner.as_rule() == Rule::generic_arguments {
2274 let generic_args_pair = Self::next_pair(&mut inner)?;
2275 generic_args = Some(self.parse_generic_arguments(&generic_args_pair)?);
2276
2277 args_pair = Self::next_pair(&mut inner)?;
2278 } else {
2279 args_pair = Self::next_pair(&mut inner)?;
2280 }
2281 } else {
2282 panic!("problem in function_call_postfix");
2283 }
2284
2285 debug_assert_eq!(args_pair.as_rule(), Rule::function_call_args);
2286
2287 let regular_args = self.parse_function_call_arguments(&args_pair)?;
2288
2289 Self::assert_end(&mut inner);
2290
2291 Ok((generic_args, regular_args))
2292 }
2293
2294 fn parse_arg_expression(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2295 debug_assert_eq!(pair.as_rule(), Rule::arg_expression);
2296 let mut inner = pair.clone().into_inner();
2297 self.parse_logical(&inner.next().unwrap())
2298 }
2299
2300 fn parse_function_call_arguments(
2301 &self,
2302 pair: &Pair<Rule>,
2303 ) -> Result<Vec<Expression>, ParseError> {
2304 debug_assert_eq!(pair.as_rule(), Rule::function_call_args);
2305 let inner = pair.clone().into_inner();
2306 let mut args = Vec::new();
2307
2308 for arg_pair in inner {
2310 let expr = self.parse_arg_expression(&arg_pair)?;
2311 args.push(expr);
2312 }
2313
2314 Ok(args)
2315 }
2316
2317 #[allow(clippy::too_many_lines)]
2318 fn parse_type(&self, pair: Pair<Rule>) -> Result<Type, ParseError> {
2319 match pair.as_rule() {
2320 Rule::type_name => {
2321 let mut inner = pair.clone().into_inner();
2322 let base_type = if let Some(inner_pair) = inner.next() {
2323 self.parse_type(inner_pair)?
2324 } else {
2325 panic!("shouldn't get to here")
2326 };
2327
2328 let optional_marker = inner
2329 .find(|p| p.as_rule() == Rule::optional_marker)
2330 .map(|marker_pair| self.to_node(&marker_pair));
2331 if let Some(found_optional_marker) = optional_marker {
2332 Ok(Type::Optional(Box::new(base_type), found_optional_marker))
2333 } else {
2334 Ok(base_type)
2335 }
2336 }
2337
2338 Rule::base_type => {
2339 let mut inner = pair.into_inner();
2340 let first = inner.next().unwrap();
2341 let base_type = self.parse_type(first)?;
2342
2343 Ok(base_type)
2344 }
2345 Rule::function_type => {
2346 let mut function_inner = pair.into_inner();
2347
2348 let param_types = if let Some(params) = function_inner
2350 .next()
2351 .filter(|p| p.as_rule() == Rule::function_params)
2352 {
2353 params
2354 .into_inner()
2355 .map(|param| {
2356 Ok(TypeForParameter {
2357 ast_type: self.parse_type(param).unwrap(),
2358 is_mutable: false,
2359 })
2360 })
2361 .collect::<Result<Vec<_>, ParseError>>()?
2362 } else {
2363 Vec::new()
2364 };
2365
2366 let return_type = self.parse_type(function_inner.next().unwrap())?;
2368
2369 Ok(Type::Function(param_types, Box::new(return_type)))
2370 }
2371
2372 Rule::qualified_type_identifier => {
2373 let qualified_id = self.parse_qualified_type_identifier(&pair)?;
2374 Ok(Type::Named(qualified_id))
2375 }
2376 Rule::tuple_type => {
2377 let elements = self.parse_tuple_type_elements(&pair)?;
2378 Ok(Type::Tuple(elements))
2379 }
2380 Rule::fixed_capacity_array_type => self.parse_fixed_capacity_array_type(&pair),
2381 Rule::slice_view_type => self.parse_slice_view_type(&pair),
2382
2383 Rule::fixed_capacity_map_type => self.parse_fixed_capacity_map_type(&pair),
2384 Rule::dynamic_map_type => self.parse_dynamic_map_type(&pair),
2385
2386 Rule::struct_type => {
2387 let element_type = self.parse_struct_type(&pair)?;
2388 Ok(Type::AnonymousStruct(element_type))
2389 }
2390
2391 Rule::unit_type => Ok(Type::Unit),
2392
2393 _ => Err(self.create_error_pair(
2394 SpecificError::UnexpectedTypeRule(format!("{:?}", pair.as_rule())),
2395 &pair,
2396 )),
2397 }
2398 }
2399
2400 fn parse_fixed_capacity_map_type(&self, pair: &Pair<Rule>) -> Result<Type, ParseError> {
2401 let mut inner = pair.clone().into_inner();
2402 let key_type = self.parse_type(Self::next_pair(&mut inner)?)?;
2403 let value_type = self.parse_type(Self::next_pair(&mut inner)?)?;
2404 let size_pair = inner.next().unwrap();
2405 let size_node = self.to_node(&size_pair);
2406
2407 Ok(Type::FixedCapacityMap(
2408 Box::new(key_type),
2409 Box::new(value_type),
2410 size_node,
2411 ))
2412 }
2413
2414 fn parse_dynamic_map_type(&self, pair: &Pair<Rule>) -> Result<Type, ParseError> {
2415 let mut inner = pair.clone().into_inner();
2416 let key_type = self.parse_type(Self::next_pair(&mut inner)?)?;
2417 let value_type = self.parse_type(Self::next_pair(&mut inner)?)?;
2418
2419 Ok(Type::DynamicLengthMap(
2420 Box::new(key_type),
2421 Box::new(value_type),
2422 ))
2423 }
2424
2425 fn parse_fixed_capacity_array_type(&self, pair: &Pair<Rule>) -> Result<Type, ParseError> {
2426 let mut inner = pair.clone().into_inner();
2427 let element_type = self.parse_type(inner.next().unwrap())?;
2428 let size_pair = inner.next().unwrap();
2429 let size_node = self.to_node(&size_pair);
2430 Ok(Type::FixedCapacityArray(Box::new(element_type), size_node))
2431 }
2432
2433 fn parse_slice_view_type(&self, pair: &Pair<Rule>) -> Result<Type, ParseError> {
2434 let mut inner = pair.clone().into_inner();
2435 let element_type = self.parse_type(inner.next().unwrap())?;
2436 Ok(Type::Slice(Box::new(element_type)))
2437 }
2438
2439 #[allow(unused)] fn parse_local_type_identifier(
2441 &self,
2442 pair: &Pair<Rule>,
2443 ) -> Result<LocalTypeIdentifier, ParseError> {
2444 if pair.as_rule() != Rule::type_identifier {
2445 return Err(self.create_error_pair(
2446 SpecificError::ExpectedTypeIdentifier(format!("{:?}", pair.as_rule())),
2447 pair,
2448 ));
2449 }
2450 Ok(LocalTypeIdentifier::new(self.to_node(pair)))
2451 }
2452
2453 fn parse_enum_def(&self, pair: &Pair<Rule>) -> Result<DefinitionKind, ParseError> {
2454 let mut inner = Self::convert_into_iterator(pair);
2455
2456 let name_with_optional_type_params =
2457 self.parse_local_type_identifier_with_optional_type_variables(&inner.next().unwrap())?;
2458
2459 let mut variants = Vec::new();
2460
2461 if let Some(variants_pair) = inner.next()
2462 && variants_pair.as_rule() == Rule::enum_variants {
2463 for variant_pair in Self::convert_into_iterator(&variants_pair) {
2464 if variant_pair.as_rule() == Rule::enum_variant {
2465 let variant =
2466 self.parse_enum_variant(&self.next_inner_pair(&variant_pair)?)?;
2467
2468 variants.push(variant);
2469 }
2470 }
2471 }
2472
2473 Ok(DefinitionKind::EnumDef(
2474 name_with_optional_type_params,
2475 variants,
2476 ))
2477 }
2478
2479 fn parse_enum_variant(&self, pair: &Pair<Rule>) -> Result<EnumVariantType, ParseError> {
2480 let enum_variant = match pair.as_rule() {
2481 Rule::simple_variant => EnumVariantType::Simple(self.to_node(pair)),
2482 Rule::direct_variant => {
2483 let mut inner = Self::convert_into_iterator(pair);
2484 let name = self.expect_local_type_identifier_next(&mut inner)?;
2485 let type_name = self.parse_type(inner.next().unwrap())?;
2486 EnumVariantType::Direct(name.0, type_name)
2487 }
2488 Rule::tuple_variant => {
2489 let mut inner = Self::convert_into_iterator(pair);
2490 let name = self.expect_local_type_identifier_next(&mut inner)?;
2491
2492 let tuple_elements = self.parse_tuple_type_elements(&inner.next().unwrap())?;
2493
2494 if tuple_elements.len() == 1 {
2496 EnumVariantType::Direct(name.0, tuple_elements.into_iter().next().unwrap())
2497 } else {
2498 EnumVariantType::Tuple(name.0, tuple_elements)
2499 }
2500 }
2501 Rule::struct_variant => {
2502 let mut inner = Self::convert_into_iterator(pair);
2503 let name = self.expect_local_type_identifier_next(&mut inner)?;
2504
2505 let struct_type = self.parse_struct_type(&inner.next().unwrap())?;
2506 EnumVariantType::Struct(name.0, struct_type)
2507 }
2508 _ => {
2509 return Err(self.create_error_pair(
2510 SpecificError::UnknownEnumVariant(Self::pair_to_rule(pair)),
2511 pair,
2512 ));
2513 }
2514 };
2515
2516 Ok(enum_variant)
2517 }
2518
2519 fn parse_match_expr(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2520 let mut inner = Self::convert_into_iterator(pair);
2521 let value = self.parse_arg_expression(&Self::next_pair(&mut inner)?)?;
2522 let arms_pair = Self::next_pair(&mut inner)?;
2523 let mut arms = Vec::new();
2524
2525 for arm_pair in Self::convert_into_iterator(&arms_pair) {
2526 if arm_pair.as_rule() == Rule::match_arm {
2527 let mut arm_inner = Self::convert_into_iterator(&arm_pair);
2528 let pattern = self.parse_match_pattern(&Self::next_pair(&mut arm_inner)?)?;
2529
2530 let expr = match Self::next_pair(&mut arm_inner)? {
2532 block if block.as_rule() == Rule::block => self.parse_block(&block)?,
2533 expr => self.parse_expression(&expr)?,
2534 };
2535
2536 arms.push(MatchArm {
2537 pattern,
2538 expression: expr,
2539 });
2540 }
2541 }
2542
2543 if arms.is_empty() {
2544 return Err(self.create_error_pair(SpecificError::MustHaveAtLeastOneArm, pair));
2545 }
2546
2547 Ok(self.create_expr(ExpressionKind::Match(Box::new(value), arms), pair))
2548 }
2549
2550 fn parse_match_pattern(&self, pair: &Pair<Rule>) -> Result<Pattern, ParseError> {
2551 let mut inner = Self::convert_into_iterator(pair);
2552 let pattern_inside = inner.next().expect("should have inner");
2553 match pattern_inside.as_rule() {
2554 Rule::normal_pattern => {
2555 let (concrete_pattern, pattern_node) =
2556 self.parse_normal_match_pattern(&pattern_inside)?;
2557 let inner_pairs: Vec<_> = pattern_inside.clone().into_inner().collect();
2558 let has_guard = inner_pairs
2559 .get(1)
2560 .is_some_and(|p| p.as_rule() == Rule::guard_clause);
2561
2562 let guard_clause = if has_guard {
2563 Some(self.parse_guard_clause(&inner_pairs[1])?)
2564 } else {
2565 None
2566 };
2567 Ok(Pattern::ConcretePattern(
2568 pattern_node,
2569 concrete_pattern,
2570 guard_clause,
2571 ))
2572 }
2573 Rule::wildcard_pattern => Ok(Pattern::Wildcard(self.to_node(pair))),
2574 _ => Err(self.create_error_pair(SpecificError::MustHaveAtLeastOneArm, pair)),
2575 }
2576 }
2577
2578 fn parse_guard_clause(&self, pair: &Pair<Rule>) -> Result<GuardClause, ParseError> {
2579 let inner = Self::right_alternative(pair)?;
2580 let clause = match inner.as_rule() {
2581 Rule::wildcard_pattern => GuardClause::Wildcard(Self::node_ex(pair)),
2582 Rule::expression => {
2583 let mut iterator = inner.into_inner();
2584 let result = self.parse_expression(&Self::next_pair(&mut iterator)?)?;
2585 GuardClause::Expression(result)
2586 }
2587 _ => {
2588 return Err(Self::to_err(
2589 SpecificError::UnknownExpr("guard_clause".to_string()),
2590 pair,
2591 ))?;
2592 }
2593 };
2594
2595 Ok(clause)
2596 }
2597
2598 fn parse_guard_expr_list(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2599 let mut guard_exprs = Vec::new();
2600
2601 for expr_pair in Self::convert_into_iterator(pair) {
2602 match expr_pair.as_rule() {
2603 Rule::guard_item => {
2604 let mut guard_inner = Self::convert_into_iterator(&expr_pair);
2605 let guard_clause = Self::next_pair(&mut guard_inner)?;
2606 let condition = self.parse_guard_clause(&guard_clause)?;
2607 let result = self.parse_expression(&Self::next_pair(&mut guard_inner)?)?;
2608 guard_exprs.push(GuardExpr {
2609 clause: condition,
2610 result,
2611 });
2612 }
2613
2614 _ => {
2615 panic!("Unexpected rule: {:?}", expr_pair.as_rule());
2616 }
2617 }
2618 }
2619
2620 Ok(self.create_expr(ExpressionKind::Guard(guard_exprs), pair))
2621 }
2622
2623 fn parse_enum_pattern(
2624 &self,
2625 pattern_type: &Pair<Rule>,
2626 ) -> Result<(ConcretePattern, Node), ParseError> {
2627 let mut inner = pattern_type.clone().into_inner(); let variant = self.expect_local_type_identifier_next(&mut inner)?;
2629
2630 let destructuring = if let Some(destructuring_node) = inner.next() {
2632 self.parse_destructuring_pattern(&destructuring_node)?
2633 } else {
2634 DestructuringPattern::Unit
2636 };
2637
2638 Ok((
2639 ConcretePattern::EnumPattern(variant.0, destructuring),
2640 self.to_node(pattern_type),
2641 ))
2642 }
2643
2644 fn parse_destructuring_pattern(
2645 &self,
2646 pair: &Pair<Rule>,
2647 ) -> Result<DestructuringPattern, ParseError> {
2648 let mut inner = Self::convert_into_iterator(pair);
2649 let destructuring_type = inner.next().expect("should have inner");
2650
2651 match destructuring_type.as_rule() {
2652 Rule::struct_destruct => {
2653 let fields = self.parse_struct_destructuring_fields(&destructuring_type)?;
2654 Ok(DestructuringPattern::Struct { fields })
2655 }
2656 Rule::tuple_destruct => {
2657 let elements = self.parse_tuple_destructuring_elements(&destructuring_type)?;
2658 if elements.is_empty() {
2659 Ok(DestructuringPattern::Unit)
2660 }
2661 else if elements.len() == 1 {
2663 match &elements[0] {
2664 PatternVariableOrWildcard::Variable(var) => {
2665 Ok(DestructuringPattern::None {
2666 variable: var.clone(),
2667 })
2668 }
2669 PatternVariableOrWildcard::Wildcard(_) => {
2670 Ok(DestructuringPattern::Tuple { elements })
2672 }
2673 }
2674 } else {
2675 assert!(!elements.is_empty(), "tuples can not be zero");
2676 assert!(elements.len() > 1, "tuples must be at least two");
2677 Ok(DestructuringPattern::Tuple { elements })
2678 }
2679 }
2680 Rule::maybe_mut_identifier => {
2681 let variable = self.parse_maybe_mut_identifier(&destructuring_type)?;
2682 Ok(DestructuringPattern::None { variable })
2683 }
2684 _ => Err(self.create_error_pair(SpecificError::UnknownMatchType, &destructuring_type)),
2685 }
2686 }
2687
2688 fn parse_struct_destructuring_fields(
2689 &self,
2690 pair: &Pair<Rule>,
2691 ) -> Result<Vec<Variable>, ParseError> {
2692 let mut fields = Vec::new();
2693 for field_pair in Self::convert_into_iterator(pair) {
2694 match field_pair.as_rule() {
2695 Rule::pattern_variable => {
2696 let mut inner = Self::convert_into_iterator(&field_pair);
2697 let variable_pair = inner.next().expect("should have inner");
2698 let variable = self.parse_maybe_mut_identifier(&variable_pair)?;
2699 fields.push(variable);
2700 }
2701 _ => {} }
2703 }
2704 Ok(fields)
2705 }
2706
2707 fn parse_tuple_destructuring_elements(
2708 &self,
2709 pair: &Pair<Rule>,
2710 ) -> Result<Vec<PatternVariableOrWildcard>, ParseError> {
2711 let mut elements = Vec::new();
2712 for element_pair in Self::convert_into_iterator(pair) {
2713 match element_pair.as_rule() {
2714 Rule::pattern_variable_or_wildcard => {
2715 let mut inner = Self::convert_into_iterator(&element_pair);
2716 let element_inner = inner.next().expect("should have inner");
2717
2718 match element_inner.as_rule() {
2719 Rule::maybe_mut_identifier => {
2720 let variable = self.parse_maybe_mut_identifier(&element_inner)?;
2721 elements.push(PatternVariableOrWildcard::Variable(variable));
2722 }
2723 _ => {
2724 if element_inner.as_str() == "_" {
2726 elements.push(PatternVariableOrWildcard::Wildcard(
2727 self.to_node(&element_inner),
2728 ));
2729 } else {
2730 return Err(self.create_error_pair(
2731 SpecificError::UnknownMatchType,
2732 &element_inner,
2733 ));
2734 }
2735 }
2736 }
2737 }
2738 _ => {} }
2740 }
2741 Ok(elements)
2742 }
2743
2744 fn parse_normal_match_pattern(
2745 &self,
2746 pair: &Pair<Rule>,
2747 ) -> Result<(ConcretePattern, Node), ParseError> {
2748 let mut inner = Self::convert_into_iterator(pair);
2749 let pattern = inner.next().expect("should have inner");
2750
2751 match pattern.as_rule() {
2752 Rule::pattern => {
2753 let mut pattern_inner = Self::convert_into_iterator(&pattern);
2754 let pattern_type = pattern_inner.next().expect("should have inner");
2755
2756 match pattern_type.as_rule() {
2757 Rule::enum_pattern => self.parse_enum_pattern(&pattern_type),
2758 Rule::basic_literal => {
2759 let (literal, node) = self.parse_basic_literal(&pattern_type)?;
2760 Ok((ConcretePattern::Literal(literal), node))
2761 }
2762 _ => {
2763 Err(self.create_error_pair(SpecificError::UnknownMatchType, &pattern_type))
2764 }
2765 }
2766 }
2767 _ => Err(self.create_error_pair(SpecificError::UnknownMatchType, &pattern)),
2768 }
2769 }
2770
2771 fn to_node(&self, pair: &Pair<Rule>) -> Node {
2772 let pair_span = pair.as_span();
2773 let span = SpanWithoutFileId {
2774 offset: pair_span.start() as u32,
2775 length: (pair_span.end() - pair_span.start()) as u16,
2776 };
2777
2778 Node { span }
2779 }
2780
2781 fn node_ex(pair: &Pair<Rule>) -> Node {
2782 let pair_span = pair.as_span();
2783 let span = SpanWithoutFileId {
2784 offset: pair_span.start() as u32,
2785 length: (pair_span.end() - pair_span.start()) as u16,
2786 };
2787
2788 Node { span }
2789 }
2790
2791 fn to_span(&self, pest_span: pest::Span) -> SpanWithoutFileId {
2792 SpanWithoutFileId {
2793 offset: pest_span.start() as u32,
2794 length: (pest_span.end() - pest_span.start()) as u16,
2795 }
2796 }
2797
2798 fn span(pest_span: pest::Span) -> SpanWithoutFileId {
2799 SpanWithoutFileId {
2800 offset: pest_span.start() as u32,
2801 length: (pest_span.end() - pest_span.start()) as u16,
2802 }
2803 }
2804
2805 fn create_expr(&self, kind: ExpressionKind, pair: &Pair<Rule>) -> Expression {
2806 self.create_expr_span(kind, self.to_node(pair))
2807 }
2808
2809 const fn create_expr_span(&self, kind: ExpressionKind, node: Node) -> Expression {
2810 Expression { kind, node }
2812 }
2813
2814 fn parse_multiplication(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2815 let mut inner = pair.clone().into_inner();
2816 let mut expr = self.parse_prefix(&inner.next().unwrap())?;
2817 while let Some(op) = inner.next() {
2818 let operator = self.parse_binary_operator(&op)?; let right = self.parse_prefix(&inner.next().unwrap())?;
2821 expr = self.create_expr(
2822 ExpressionKind::BinaryOp(Box::new(expr), operator, Box::new(right)),
2823 pair,
2824 );
2825 }
2826 Ok(expr)
2827 }
2828
2829 fn parse_addition(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2830 let mut inner = pair.clone().into_inner();
2831 let mut expr = self.parse_multiplication(&inner.next().unwrap())?;
2832 while let Some(op) = inner.next() {
2833 let operator = self.parse_binary_operator(&op)?; let right = self.parse_multiplication(&inner.next().unwrap())?;
2835 expr = self.create_expr(
2836 ExpressionKind::BinaryOp(Box::new(expr), operator, Box::new(right)),
2837 pair,
2838 );
2839 }
2840 Ok(expr)
2841 }
2842
2843 fn parse_comparison(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2844 let mut inner = pair.clone().into_inner();
2845 let mut expr = self.parse_addition(&inner.next().unwrap())?;
2846 while let Some(op) = inner.next() {
2847 let operator = self.parse_binary_operator(&op)?; let right = self.parse_addition(&inner.next().unwrap())?;
2849 expr = self.create_expr(
2850 ExpressionKind::BinaryOp(Box::new(expr), operator, Box::new(right)),
2851 pair,
2852 );
2853 }
2854 Ok(expr)
2855 }
2856
2857 fn parse_range(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2858 let mut inner = pair.clone().into_inner();
2859 let left = self.parse_comparison(&inner.next().unwrap())?;
2860 if let Some(op) = inner.next() {
2861 let right = self.parse_comparison(&inner.next().unwrap())?;
2862 match op.as_rule() {
2863 Rule::exclusive_range_op => {
2864 return Ok(self.create_expr(
2865 ExpressionKind::Range(
2866 Box::new(left),
2867 Box::new(right),
2868 RangeMode::Exclusive,
2869 ),
2870 pair,
2871 ));
2872 }
2873 Rule::inclusive_range_op => {
2874 return Ok(self.create_expr(
2875 ExpressionKind::Range(
2876 Box::new(left),
2877 Box::new(right),
2878 RangeMode::Inclusive,
2879 ),
2880 pair,
2881 ));
2882 }
2883 _ => {}
2884 }
2885 let operator = self.parse_binary_operator(&op)?; Ok(self.create_expr(
2887 ExpressionKind::BinaryOp(Box::new(left), operator, Box::new(right)),
2888 pair,
2889 ))
2890 } else {
2891 Ok(left)
2892 }
2893 }
2894
2895 fn parse_none_coalesce(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2896 debug_assert_eq!(pair.as_rule(), Rule::none_coalesce);
2897 let mut inner = pair.clone().into_inner();
2898 let mut expr = self.parse_range(&inner.next().unwrap())?;
2899 while let Some(op) = inner.next() {
2900 let operator = self.parse_binary_operator(&op)?; assert!(!(operator.kind != BinaryOperatorKind::NoneCoalescingOperator), "expected ?? in none_coalesce, got {operator:?}");
2903
2904 let right = self.parse_range(&inner.next().unwrap())?;
2905 expr = self.create_expr(
2906 ExpressionKind::BinaryOp(Box::new(expr), operator, Box::new(right)),
2907 pair,
2908 );
2909 }
2910 Ok(expr)
2911 }
2912
2913 fn parse_logical(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2914 debug_assert_eq!(pair.as_rule(), Rule::logical);
2915
2916 let mut inner = pair.clone().into_inner();
2917 let mut expr = self.parse_none_coalesce(&inner.next().unwrap())?;
2919
2920 while let Some(op_pair) = inner.next() {
2921 let operator = self.parse_binary_operator(&op_pair)?; let right = self.parse_none_coalesce(&inner.next().unwrap())?;
2923 expr = self.create_expr(
2924 ExpressionKind::BinaryOp(Box::new(expr), operator, Box::new(right)),
2925 pair,
2926 );
2927 }
2928
2929 Ok(expr)
2930 }
2931
2932 fn parse_lambda(&self, pair: &Pair<Rule>) -> Result<Expression, ParseError> {
2933 debug_assert_eq!(pair.as_rule(), Rule::lambda);
2934 let mut inner = pair.clone().into_inner();
2935 let variable_list_pair = inner.next().unwrap();
2936 let variable_list = self.parse_optional_variable_list(&variable_list_pair)?;
2937 let expression_pair = inner.next().unwrap();
2938 let expression = self.parse_expression(&expression_pair)?;
2939
2940 Ok(self.create_expr(
2941 ExpressionKind::Lambda(variable_list, Box::new(expression)),
2942 pair,
2943 ))
2944 }
2945
2946 pub fn parse_attribute(&self, pair: &Pair<Rule>) -> Result<Attribute, ParseError> {
2947 let inner = pair.clone().into_inner().next().unwrap();
2948 let is_inner = match inner.as_rule() {
2949 Rule::outer_attribute => false,
2950 Rule::inner_attribute => true,
2951 _ => panic!("must be attribute"),
2952 };
2953 let meta_item = inner.into_inner().next().unwrap();
2954 let (path, args) = self.parse_meta_item(&meta_item)?;
2955
2956 Ok(Attribute {
2957 is_inner,
2958 path,
2959 args,
2960 node: self.to_node(pair),
2961 })
2962 }
2963
2964 fn parse_any_meta_item_to_arg(&self, pair: &Pair<Rule>) -> Result<AttributeArg, ParseError> {
2965 debug_assert_eq!(pair.as_rule(), Rule::meta_item);
2966 let matched_alternative = pair.clone().into_inner().next().unwrap();
2967
2968 match matched_alternative.as_rule() {
2969 Rule::meta_path => {
2970 let path_pair = matched_alternative.clone().into_inner().next().unwrap();
2971 let path = self.parse_qualified_identifier(&path_pair)?;
2972 Ok(AttributeArg::Path(path))
2973 }
2974 Rule::meta_key_value => {
2975 let mut inner_items = matched_alternative.clone().into_inner();
2976 let key_pair = inner_items.next().unwrap();
2977 let value_pair = inner_items.next().unwrap();
2978 let key = self.parse_qualified_identifier(&key_pair)?;
2979 let value_arg = self.parse_meta_value(&value_pair)?;
2980 Ok(AttributeArg::Function(key, vec![value_arg]))
2981 }
2982 Rule::meta_list => {
2983 let mut inner_items = matched_alternative.clone().into_inner();
2984 let path_pair = inner_items.next().unwrap();
2985 let path = self.parse_qualified_identifier(&path_pair)?;
2986 let args = if let Some(list_pair) = inner_items.next() {
2987 self.parse_meta_item_list(&list_pair)?
2988 } else {
2989 vec![]
2990 };
2991 Ok(AttributeArg::Function(path, args))
2992 }
2993 _ => panic!("unexpected rule inside meta_item"),
2994 }
2995 }
2996
2997 fn parse_meta_item(
2998 &self,
2999 pair: &Pair<Rule>,
3000 ) -> Result<(QualifiedIdentifier, Vec<AttributeArg>), ParseError> {
3001 debug_assert_eq!(pair.as_rule(), Rule::meta_item);
3002 let arg = self.parse_any_meta_item_to_arg(pair)?;
3003
3004 match arg {
3005 AttributeArg::Path(path) => Ok((path, vec![])),
3006 AttributeArg::Function(path, args) => Ok((path, args)),
3007 AttributeArg::Literal(_) => panic!(),
3008 }
3009 }
3010
3011 fn parse_meta_item_list(&self, pair: &Pair<Rule>) -> Result<Vec<AttributeArg>, ParseError> {
3012 let mut args = Vec::new();
3013 for item in pair.clone().into_inner() {
3014 args.push(self.parse_meta_item_arg(&item)?);
3015 }
3016 Ok(args)
3017 }
3018
3019 fn parse_meta_item_arg(&self, pair: &Pair<Rule>) -> Result<AttributeArg, ParseError> {
3020 self.parse_any_meta_item_to_arg(pair)
3021 }
3022
3023 fn parse_meta_value(&self, pair: &Pair<Rule>) -> Result<AttributeArg, ParseError> {
3024 let matched_alternative = self.next_inner_pair(pair)?;
3025 match matched_alternative.as_rule() {
3026 Rule::basic_literal => {
3027 let (kind, node) = self.parse_basic_literal(&matched_alternative)?;
3028 Ok(AttributeArg::Literal(match kind {
3029 LiteralKind::Int => AttributeValue::Literal(node, AttributeLiteralKind::Int),
3030 LiteralKind::String(s) => {
3031 AttributeValue::Literal(node, AttributeLiteralKind::String(s))
3032 }
3033 LiteralKind::Bool => AttributeValue::Literal(node, AttributeLiteralKind::Bool),
3034 _ => panic!("not supported"),
3035 }))
3036 }
3037 Rule::meta_path => {
3038 let path = self.parse_qualified_identifier(
3039 &matched_alternative.clone().into_inner().next().unwrap(),
3040 )?;
3041 Ok(AttributeArg::Path(path))
3042 }
3043 Rule::meta_list => {
3044 let mut inner = matched_alternative.clone().into_inner();
3045 let path = self.parse_qualified_identifier(&inner.next().unwrap())?;
3046 let args = if let Some(list) = inner.next() {
3047 self.parse_meta_item_list(&list)?
3048 } else {
3049 vec![]
3050 };
3051 Ok(AttributeArg::Function(path, args))
3052 }
3053 _ => panic!("unexpected meta_value {:?}", pair.as_rule()),
3054 }
3055 }
3056}