From 5912032dfffe51ccdd26b734f0a9a3ba18ba39be Mon Sep 17 00:00:00 2001
From: Klesti Selimaj <klesti.selimay@icloud.com>
Date: Thu, 14 May 2026 21:44:00 +0200
Subject: [PATCH] Enums and impl decl

---
 parser/src/lib.rs                    | 77 ----------------------------
 parser/src/parser/items/enums.rs     | 45 ++++++++++++++++
 parser/src/parser/items/impl_decl.rs | 43 ++++++++++++++++
 parser/src/parser/items/mod.rs       |  2 +
 4 files changed, 90 insertions(+), 77 deletions(-)
 create mode 100644 parser/src/parser/items/enums.rs
 create mode 100644 parser/src/parser/items/impl_decl.rs

diff --git a/parser/src/lib.rs b/parser/src/lib.rs
index b95c367..ee0a859 100644
--- a/parser/src/lib.rs
+++ b/parser/src/lib.rs
@@ -91,83 +91,6 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generics {
     }
 }
 
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ImplDecl {
-    type Error = ParseError<'a>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let rule = pair.as_rule();
-        let mut inner = pair.clone().into_inner();
-
-        match rule {
-            Rule::impl_for_decl => Ok(ImplDecl {
-                generics: consume_rule(&mut inner, Rule::generics)
-                    .map(Generics::try_from)
-                    .transpose()?
-                    .unwrap_or_default(),
-                trait_: Some(TypeExpr::try_from(inner.next().unwrap())?),
-                target: TypeExpr::try_from(inner.next().unwrap())?,
-                methods: inner
-                    .map(FunctionDecl::try_from)
-                    .collect::<ParseResult<'a, Vec<_>>>()?,
-            }),
-
-            Rule::impl_decl => Ok(ImplDecl {
-                generics: consume_rule(&mut inner, Rule::generics)
-                    .map(Generics::try_from)
-                    .transpose()?
-                    .unwrap_or_default(),
-                trait_: None,
-                target: TypeExpr::try_from(inner.next().unwrap())?,
-                methods: inner
-                    .map(FunctionDecl::try_from)
-                    .collect::<ParseResult<'a, Vec<_>>>()?,
-            }),
-
-            _ => unimplemented!("{rule:#?}"),
-        }
-    }
-}
-
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for EnumItem {
-    type Error = ParseError<'a>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let rule = pair.as_rule();
-        let mut inner = pair.clone().into_inner();
-
-        match rule {
-            Rule::enum_named => Ok(EnumItem::Named(Identifier::try_from(
-                inner.next().unwrap(),
-            )?)),
-
-            Rule::enum_tuple => Ok(EnumItem::Tuple(
-                Identifier::try_from(inner.next().unwrap())?,
-                inner
-                    .next()
-                    .unwrap()
-                    .into_inner()
-                    .map(TypeExpr::try_from)
-                    .collect::<ParseResult<'a, Vec<_>>>()?,
-            )),
-
-            Rule::enum_struct => Ok(EnumItem::Struct(
-                Identifier::try_from(inner.next().unwrap())?,
-                inner
-                    .next()
-                    .map(|pair| {
-                        pair.into_inner()
-                            .map(FieldDecl::try_from)
-                            .collect::<ParseResult<'a, Vec<_>>>()
-                    })
-                    .transpose()?
-                    .unwrap_or_default(),
-            )),
-
-            _ => unimplemented!("{rule:#?}"),
-        }
-    }
-}
-
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Block {
     type Error = ParseError<'a>;
 
diff --git a/parser/src/parser/items/enums.rs b/parser/src/parser/items/enums.rs
new file mode 100644
index 0000000..883ee77
--- /dev/null
+++ b/parser/src/parser/items/enums.rs
@@ -0,0 +1,45 @@
+use crate::{
+    Rule,
+    ast::*,
+    error::{ParseError, ParseResult},
+};
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for EnumItem {
+    type Error = ParseError<'a>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        let rule = pair.as_rule();
+        let mut inner = pair.clone().into_inner();
+
+        match rule {
+            Rule::enum_named => Ok(EnumItem::Named(Identifier::try_from(
+                inner.next().unwrap(),
+            )?)),
+
+            Rule::enum_tuple => Ok(EnumItem::Tuple(
+                Identifier::try_from(inner.next().unwrap())?,
+                inner
+                    .next()
+                    .unwrap()
+                    .into_inner()
+                    .map(TypeExpr::try_from)
+                    .collect::<ParseResult<'a, Vec<_>>>()?,
+            )),
+
+            Rule::enum_struct => Ok(EnumItem::Struct(
+                Identifier::try_from(inner.next().unwrap())?,
+                inner
+                    .next()
+                    .map(|pair| {
+                        pair.into_inner()
+                            .map(FieldDecl::try_from)
+                            .collect::<ParseResult<'a, Vec<_>>>()
+                    })
+                    .transpose()?
+                    .unwrap_or_default(),
+            )),
+
+            _ => unimplemented!("{rule:#?}"),
+        }
+    }
+}
diff --git a/parser/src/parser/items/impl_decl.rs b/parser/src/parser/items/impl_decl.rs
new file mode 100644
index 0000000..76952a1
--- /dev/null
+++ b/parser/src/parser/items/impl_decl.rs
@@ -0,0 +1,43 @@
+use crate::{
+    Rule,
+    ast::*,
+    error::{ParseError, ParseResult},
+    parser::consume_rule,
+};
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ImplDecl {
+    type Error = ParseError<'a>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        let rule = pair.as_rule();
+        let mut inner = pair.clone().into_inner();
+
+        match rule {
+            Rule::impl_for_decl => Ok(ImplDecl {
+                generics: consume_rule(&mut inner, Rule::generics)
+                    .map(Generics::try_from)
+                    .transpose()?
+                    .unwrap_or_default(),
+                trait_: Some(TypeExpr::try_from(inner.next().unwrap())?),
+                target: TypeExpr::try_from(inner.next().unwrap())?,
+                methods: inner
+                    .map(FunctionDecl::try_from)
+                    .collect::<ParseResult<'a, Vec<_>>>()?,
+            }),
+
+            Rule::impl_decl => Ok(ImplDecl {
+                generics: consume_rule(&mut inner, Rule::generics)
+                    .map(Generics::try_from)
+                    .transpose()?
+                    .unwrap_or_default(),
+                trait_: None,
+                target: TypeExpr::try_from(inner.next().unwrap())?,
+                methods: inner
+                    .map(FunctionDecl::try_from)
+                    .collect::<ParseResult<'a, Vec<_>>>()?,
+            }),
+
+            _ => unimplemented!("{rule:#?}"),
+        }
+    }
+}
diff --git a/parser/src/parser/items/mod.rs b/parser/src/parser/items/mod.rs
index 8db6a16..540dd2d 100644
--- a/parser/src/parser/items/mod.rs
+++ b/parser/src/parser/items/mod.rs
@@ -1,6 +1,8 @@
 pub mod attribute;
 pub mod class;
+pub mod enums;
 pub mod function;
+pub mod impl_decl;
 
 use crate::{
     Rule,