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