From 1d4473906f93bfe24634da275e70ecf6fc226832 Mon Sep 17 00:00:00 2001 From: Selimaj Dev Date: Sun, 17 May 2026 19:21:10 +0200 Subject: [PATCH] Fix: Generics decl not working --- parser/src/lib.rs | 4 +- parser/src/parser/items/class.rs | 2 +- parser/src/parser/items/function.rs | 102 ++++++++++++++------------- parser/src/parser/items/impl_decl.rs | 4 +- parser/src/parser/items/mod.rs | 18 ++--- 5 files changed, 66 insertions(+), 64 deletions(-) diff --git a/parser/src/lib.rs b/parser/src/lib.rs index 245fd9f..867c2ef 100644 --- a/parser/src/lib.rs +++ b/parser/src/lib.rs @@ -34,8 +34,8 @@ pub fn parse<'a>(source: &'a str) -> Result, ParseError<'a, Vec $body:block) => { - if $pair.as_rule() == $rule + ($pair:expr, $rule:expr $(, $rules:expr)* => $body:block) => { + if $pair.as_rule() == $rule $(|| $pair.as_rule() == $rules)* $body else { Err(AstError { diff --git a/parser/src/parser/items/class.rs b/parser/src/parser/items/class.rs index 47ff6c9..4512d59 100644 --- a/parser/src/parser/items/class.rs +++ b/parser/src/parser/items/class.rs @@ -14,7 +14,7 @@ impl<'a> TryFrom> for ClassConstructor { Ok(Self { visibility: Visibility::try_from(&mut inner).get()?, - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .get()? diff --git a/parser/src/parser/items/function.rs b/parser/src/parser/items/function.rs index cd40024..766de4c 100644 --- a/parser/src/parser/items/function.rs +++ b/parser/src/parser/items/function.rs @@ -1,7 +1,7 @@ use crate::{ Rule, ast::*, - ast_expr, + ast_ensure, ast_expr, error::{AstError, AstResult, IntoErr, collect_recovered}, parser::{consume_rule, listen_rule}, }; @@ -10,64 +10,66 @@ impl<'a> TryFrom> for FunctionDecl { type Error = AstError<'a, Self>; fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result { + ast_ensure!(pair, Rule::function_decl, Rule::method, Rule::method_no_body => { let mut inner = pair.into_inner(); - let visibility = Visibility::try_from(&mut inner); - let return_type = TypeExpr::try_from(inner.next().unwrap()); - let name = Identifier::try_from(inner.next().unwrap()); + let visibility = Visibility::try_from(&mut inner); + let return_type = TypeExpr::try_from(inner.next().unwrap()); + let name = Identifier::try_from(inner.next().unwrap()); - let generics = consume_rule(&mut inner, Rule::generics) - .map(GenericsDecl::try_from) - .transpose() - .map(|v| v.unwrap_or_default()); + let generics = consume_rule(&mut inner, Rule::generics_decl) + .map(GenericsDecl::try_from) + .transpose() + .map(|v| v.unwrap_or_default()); - let self_param = consume_rule(&mut inner, Rule::self_param).map(|param| { - let mut param_inner = param.into_inner(); - let name = Pattern::Id(Identifier(String::from("self"))); + let self_param = consume_rule(&mut inner, Rule::self_param).map(|param| { + let mut param_inner = param.into_inner(); + let name = Pattern::Id(Identifier(String::from("self"))); - let mutable = listen_rule(&mut param_inner, Rule::mutable); + let mutable = listen_rule(&mut param_inner, Rule::mutable); - let is_ref = listen_rule(&mut param_inner, Rule::deref_px); + let is_ref = listen_rule(&mut param_inner, Rule::deref_px); - VarDecl { - mutable: mutable && !is_ref, - name: name.clone(), - type_: Some(TypeExpr( - TypeExprKind::Path(Path(vec![Identifier("Self".to_string())])), - if is_ref { - vec![if mutable { - TypePostfix::RefMut + VarDecl { + mutable: mutable && !is_ref, + name: name.clone(), + type_: Some(TypeExpr( + TypeExprKind::Path(Path(vec![Identifier("Self".to_string())])), + if is_ref { + vec![if mutable { + TypePostfix::RefMut + } else { + TypePostfix::Ref + }] } else { - TypePostfix::Ref - }] - } else { - Vec::new() - }, - )), - } - }); - - let params = consume_rule(&mut inner, Rule::param_list) - .map({ - let self_param = self_param.clone(); - |params_pair| -> AstResult<'a, ParamList> { - let mut params = ParamList::try_from(params_pair)?; - if let Some(x) = self_param { - params.0.insert(0, x); - } - Ok(params) + Vec::new() + }, + )), } + }); + + let params = consume_rule(&mut inner, Rule::param_list) + .map({ + let self_param = self_param.clone(); + |params_pair| -> AstResult<'a, ParamList> { + let mut params = ParamList::try_from(params_pair)?; + if let Some(x) = self_param { + params.0.insert(0, x); + } + Ok(params) + } + }) + .unwrap_or_else(|| Ok(ParamList(self_param.into_iter().collect()))); + + let body = inner.next().map(Block::try_from).transpose(); + + ast_expr!(Self { + visibility: visibility, + return_type: return_type, + name: name, + generics: generics, + params: params, + body: body, }) - .unwrap_or_else(|| Ok(ParamList(self_param.into_iter().collect()))); - - let body = inner.next().map(Block::try_from).transpose(); - - ast_expr!(Self { - visibility: visibility, - return_type: return_type, - name: name, - generics: generics, - params: params, - body: body, }) } } diff --git a/parser/src/parser/items/impl_decl.rs b/parser/src/parser/items/impl_decl.rs index dd2ba98..5e8203a 100644 --- a/parser/src/parser/items/impl_decl.rs +++ b/parser/src/parser/items/impl_decl.rs @@ -14,7 +14,7 @@ impl<'a> TryFrom> for ImplDecl { match rule { Rule::impl_for_decl => Ok(ImplDecl { - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .get()? @@ -25,7 +25,7 @@ impl<'a> TryFrom> for ImplDecl { }), Rule::impl_decl => Ok(ImplDecl { - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .get()? diff --git a/parser/src/parser/items/mod.rs b/parser/src/parser/items/mod.rs index cb8f643..98783cc 100644 --- a/parser/src/parser/items/mod.rs +++ b/parser/src/parser/items/mod.rs @@ -8,7 +8,7 @@ use crate::{ Rule, ast::*, ast_expr, - error::{AstError, IntoErr, collect_recovered}, + error::{AstError, AstResult, IntoErr, collect_recovered}, parser::consume_rule, }; @@ -50,7 +50,7 @@ impl<'a> TryFrom> for TopLevelKind { name: inner.next().unwrap().try_into(), - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .map(|v| v.unwrap_or_default()), @@ -67,7 +67,7 @@ impl<'a> TryFrom> for TopLevelKind { name: inner.next().unwrap().try_into(), - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .map(|v| v.unwrap_or_default()), @@ -84,7 +84,7 @@ impl<'a> TryFrom> for TopLevelKind { name: inner.next().unwrap().try_into(), - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .map(|v| v.unwrap_or_default()), @@ -101,23 +101,23 @@ impl<'a> TryFrom> for TopLevelKind { ast_expr!(TopLevelKind::ImplDecl(pair.try_into())) } - Rule::trait_decl => ast_expr!(TopLevelKind::TraitDecl { + Rule::trait_decl => dbg!(ast_expr!(TopLevelKind::TraitDecl { visibility: Visibility::try_from(&mut inner), name: inner.next().unwrap().try_into(), - generics: consume_rule(&mut inner, Rule::generics) + generics: consume_rule(&mut inner, Rule::generics_decl) .map(GenericsDecl::try_from) .transpose() .map(|v| v.unwrap_or_default()), requirements: consume_rule(&mut inner, Rule::trait_requirements) - .map(|pair| collect_recovered::(pair.into_inner())) + .map(|pair| collect_recovered(pair.into_inner())) .transpose() .map(|v| v.unwrap_or_default()), - items: collect_recovered(inner), - }), + items: Ok(Vec::new()) as AstResult<'_, Vec<_>>, + })), _ => AstError::bug_unimplemented(pair), }