From ced2d47977c003ed09f94ea6ecbe999c907100f1 Mon Sep 17 00:00:00 2001
From: Klesti Selimaj <klesti.selimay@icloud.com>
Date: Sat, 16 May 2026 06:41:29 +0200
Subject: [PATCH] error system: types

---
 parser/src/ast.rs                 |  6 +++++
 parser/src/parser/common/types.rs | 38 +++++++++++++++----------------
 2 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/parser/src/ast.rs b/parser/src/ast.rs
index bcc5408..d2acb95 100644
--- a/parser/src/ast.rs
+++ b/parser/src/ast.rs
@@ -272,3 +272,9 @@ pub enum Literal {
     Bool(bool),
     Tuple(Vec<Expression>),
 }
+
+impl TypeExpr {
+    pub fn no_px(kind: TypeExprKind) -> Self {
+        Self(kind, Vec::new())
+    }
+}
diff --git a/parser/src/parser/common/types.rs b/parser/src/parser/common/types.rs
index 3145689..2ec02a4 100644
--- a/parser/src/parser/common/types.rs
+++ b/parser/src/parser/common/types.rs
@@ -1,7 +1,8 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, IntoErr, collect_recovered},
+    ast_expr,
+    error::{AstError, GetLength, IntoErr, collect_recovered},
     parser::{consume_rule, listen_rule},
 };
 
@@ -47,15 +48,15 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExprKind {
         let mut inner = pair.into_inner();
 
         match rule {
-            Rule::tuple_type => Ok(TypeExprKind::Tuple(collect_recovered(inner).get()?)),
+            Rule::tuple_type => ast_expr!(TypeExprKind::Tuple(collect_recovered(inner))),
             Rule::path_type => {
-                let path = Path::try_from(inner.next().unwrap()).get()?;
-                let params = collect_recovered(inner).get()?;
+                let path = Path::try_from(inner.next().unwrap());
+                let params = collect_recovered(inner);
 
                 if params.len() == 0 {
-                    Ok(TypeExprKind::Path(path))
+                    ast_expr!(TypeExprKind::Path(path))
                 } else {
-                    Ok(TypeExprKind::PathParams(path, params))
+                    ast_expr!(TypeExprKind::PathParams(path, params))
                 }
             }
             _ => unimplemented!("{rule:#?}"),
@@ -71,15 +72,14 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExpr {
         let mut inner = pair.into_inner();
 
         match rule {
-            Rule::type_expr => Ok(TypeExpr(
-                inner.next().unwrap().try_into().get()?,
-                collect_recovered(inner).get()?,
+            Rule::type_expr => ast_expr!(TypeExpr(
+                inner.next().unwrap().try_into(),
+                collect_recovered(inner),
             )),
             Rule::type_expr_param => Self::try_from(inner.next().unwrap()),
-            Rule::lifetime => Ok(TypeExpr(
-                TypeExprKind::Lifetime(inner.next().unwrap().try_into().get()?),
-                Vec::new(),
-            )),
+            Rule::lifetime => ast_expr!(TypeExprKind::Lifetime(inner.next().unwrap().try_into()))
+                .get_map(TypeExpr::no_px)
+                .map(TypeExpr::no_px),
             _ => unimplemented!("{rule:#?}"),
         }
     }
@@ -93,7 +93,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generics {
         let inner = pair.clone().into_inner();
 
         match rule {
-            Rule::generics => Ok(Generics(collect_recovered(inner).get()?)),
+            Rule::generics => ast_expr!(Generics(collect_recovered(inner))),
             _ => unimplemented!("{rule:#?}"),
         }
     }
@@ -106,13 +106,13 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generic {
         let mut inner = pair.clone().into_inner();
 
         if let Some(pair) = consume_rule(&mut inner, Rule::lifetime) {
-            Ok(Generic::Lifetime(
-                pair.into_inner().next().unwrap().try_into().get()?,
+            ast_expr!(Generic::Lifetime(
+                pair.into_inner().next().unwrap().try_into(),
             ))
         } else {
-            Ok(Generic::Type(
-                inner.next().unwrap().try_into().get()?,
-                collect_recovered(inner).get()?,
+            ast_expr!(Generic::Type(
+                inner.next().unwrap().try_into(),
+                collect_recovered(inner),
             ))
         }
     }