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