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