Fix: Generics decl not working

parser/src/lib.rs

@@ -34,8 +34,8 @@ pub fn parse<'a>(source: &'a str) -> Result<Vec<TopLevel>, ParseError<'a, Vec<To
 
 #[macro_export]
 macro_rules! ast_ensure {
-    ($pair:expr, $rule:expr => $body:block) => {
+    ($pair:expr, $rule:expr $(, $rules:expr)* => $body:block) => {
-        if $pair.as_rule() == $rule
+        if $pair.as_rule() == $rule $(|| $pair.as_rule() == $rules)*
             $body
         else {
             Err(AstError {

parser/src/parser/items/class.rs

@@ -14,7 +14,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> 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()?

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,12 +10,13 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
     type Error = AstError<'a, Self>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        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 generics = consume_rule(&mut inner, Rule::generics)
+            let generics = consume_rule(&mut inner, Rule::generics_decl)
                 .map(GenericsDecl::try_from)
                 .transpose()
                 .map(|v| v.unwrap_or_default());
@@ -69,6 +70,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
                 params: params,
                 body: body,
             })
+        })
     }
 }
 

parser/src/parser/items/impl_decl.rs

@@ -14,7 +14,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> 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<pest::iterators::Pair<'a, Rule>> 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()?

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<pest::iterators::Pair<'a, Rule>> 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<pest::iterators::Pair<'a, Rule>> 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<pest::iterators::Pair<'a, Rule>> 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<pest::iterators::Pair<'a, Rule>> 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::<TypeExpr, TypeExpr>(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),
         }