refactor: organize parser into modular components (#263)

Split the large `parser.rs` file into logical submodules within
`front/parser/src/parser/` to improve code structure and maintainability.

Changes:
- **New Module Structure**:
  - `asm.rs`: `parse_asm_block`
  - `control.rs`: `parse_if`, `parse_while`, `parse_for`
  - `decl.rs`: `parse_variable_decl`, `parse_const`, `parse_let`, `parse_var`
  - `expr.rs`: `parse_function_call`, `parse_parentheses`
  - `functions.rs`: `parse_function`, `parse_parameters`, `extract_body`
  - `io.rs`: `parse_println`, `parse_print`, `parse_input`
  - `items.rs`: `parse_import`, `parse_proto`, `parse_struct`
  - `stmt.rs`: `parse_assignment`, `parse_block`, `parse_statement`
  - `types.rs`: Type parsing logic moved from `type_system.rs` (`parse_type`, `parse_type_from_token`, etc.)
  - `parse.rs`: Main `parse()` entry point and module declarations.
- **Cleanup**:
  - Removed `type_system.rs` (logic moved to `types.rs`).
  - Updated `mod.rs` to expose the new structure.
  - Fixed imports across the crate to point to new module locations.
  - Resolved unused import warnings in `main.rs` and `runner.rs`.

This refactoring decouples parser components, making it easier to navigate
and extend individual language features.

Signed-off-by: LunaStev <luna@lunastev.org>

Author: LunaStev

front/parser/src/parser/ast.rs front/parser/src/ast.rsfront/parser/src/parser/ast.rs renamed to front/parser/src/ast.rs

@@ -1,3 +1,9 @@
 pub mod parser;
+pub mod ast;
+pub mod format;
+pub mod import;
+pub mod stdlib;
+pub mod type_system;
+pub mod verification;
 
 pub use parser::*;

front/parser/src/parser/format.rs front/parser/src/format.rsfront/parser/src/parser/format.rs renamed to front/parser/src/format.rs

@@ -0,0 +1,140 @@
+use std::iter::Peekable;
+use std::slice::Iter;
+use lexer::{Token, TokenType};
+use crate::ast::{ASTNode, StatementNode};
+
+pub fn parse_asm_block(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
+    if tokens.peek()?.token_type != TokenType::Lbrace {
+        println!("Expected '{{' after 'asm'");
+        return None;
+    }
+    tokens.next();
+
+    let mut instructions = vec![];
+    let mut inputs = vec![];
+    let mut outputs = vec![];
+
+    while let Some(token) = tokens.next() {
+        match &token.token_type {
+            TokenType::Rbrace => break,
+
+            TokenType::In | TokenType::Out => {
+                let is_input = matches!(token.token_type, TokenType::In);
+
+                if tokens.next().map(|t| t.token_type.clone()) != Some(TokenType::Lparen) {
+                    println!("Expected '(' after in/out");
+                    return None;
+                }
+
+                let reg_token = tokens.next();
+                let reg = match reg_token {
+                    Some(Token {
+                             token_type: TokenType::String(s),
+                             ..
+                         }) => s.clone(),
+                    Some(Token {
+                             token_type: TokenType::Identifier(s),
+                             ..
+                         }) => s.clone(),
+                    Some(other) => {
+                        println!(
+                            "Expected register string or identifier, got {:?}",
+                            other.token_type
+                        );
+                        return None;
+                    }
+                    None => {
+                        println!("Expected register in in/out(...)");
+                        return None;
+                    }
+                };
+
+                if tokens.next().map(|t| t.token_type.clone()) != Some(TokenType::Rparen) {
+                    println!("Expected ')' after in/out");
+                    return None;
+                }
+
+                let value_token = tokens.next();
+                let value = match value_token {
+                    Some(Token {
+                             token_type: TokenType::Minus,
+                             ..
+                         }) => match tokens.next() {
+                        Some(Token {
+                                 token_type: TokenType::Number(n),
+                                 ..
+                             }) => format!("-{}", n),
+                        Some(other) => {
+                            println!("Expected number after '-', got {:?}", other.token_type);
+                            return None;
+                        }
+                        None => {
+                            println!("Expected number after '-'");
+                            return None;
+                        }
+                    },
+                    Some(Token {
+                             token_type: TokenType::AddressOf,
+                             ..
+                         }) => match tokens.next() {
+                        Some(Token {
+                                 token_type: TokenType::Identifier(s),
+                                 ..
+                             }) => format!("&{}", s),
+                        Some(other) => {
+                            println!("Expected identifier after '&', got {:?}", other.token_type);
+                            return None;
+                        }
+                        None => {
+                            println!("Expected identifier after '&'");
+                            return None;
+                        }
+                    },
+                    Some(Token {
+                             token_type: TokenType::Identifier(s),
+                             ..
+                         }) => s.clone(),
+                    Some(Token {
+                             token_type: TokenType::Number(n),
+                             ..
+                         }) => n.to_string(),
+                    Some(Token {
+                             token_type: TokenType::String(n),
+                             ..
+                         }) => n.to_string(),
+                    Some(other) => {
+                        println!(
+                            "Expected identifier or number after in/out(...), got {:?}",
+                            other.token_type
+                        );
+                        return None;
+                    }
+                    None => {
+                        println!("Expected value after in/out(...)");
+                        return None;
+                    }
+                };
+
+                if is_input {
+                    inputs.push((reg.clone(), value));
+                } else {
+                    outputs.push((reg.clone(), value));
+                }
+            }
+
+            TokenType::String(s) => {
+                instructions.push(s.clone());
+            }
+
+            other => {
+                println!("Unexpected token in asm expression {:?}", other);
+            }
+        }
+    }
+
+    Some(ASTNode::Statement(StatementNode::AsmBlock {
+        instructions,
+        inputs,
+        outputs,
+    }))
+}

front/parser/src/parser/import.rs front/parser/src/import.rsfront/parser/src/parser/import.rs renamed to front/parser/src/import.rs

@@ -0,0 +1,149 @@
+use std::iter::Peekable;
+use std::slice::Iter;
+use lexer::{Token, TokenType};
+use crate::ast::{ASTNode, Expression, StatementNode};
+use crate::format::parse_expression;
+use crate::parser::stmt::parse_block;
+
+pub fn parse_if(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
+    if tokens.peek()?.token_type != TokenType::Lparen {
+        println!("Error: Expected '(' after 'if'");
+        return None;
+    }
+    tokens.next(); // Consume '('
+
+    let condition = parse_expression(tokens)?;
+
+    if tokens.peek()?.token_type != TokenType::Rparen {
+        println!("Error: Expected ')' after 'if' condition");
+        return None;
+    }
+    tokens.next(); // Consume ')'
+
+    if tokens.peek()?.token_type != TokenType::Lbrace {
+        println!("Error: Expected '{{' after 'if' condition");
+        return None;
+    }
+    tokens.next(); // Consume '{'
+    let body = parse_block(tokens)?;
+
+    let mut else_if_blocks: Vec<(Expression, Vec<ASTNode>)> = Vec::new(); // Changed to store conditions and bodies
+    let mut else_block = None;
+
+    while let Some(token) = tokens.peek() {
+        if token.token_type != TokenType::Else {
+            break;
+        }
+        tokens.next(); // consume 'else'
+
+        if let Some(Token {
+                        token_type: TokenType::If,
+                        ..
+                    }) = tokens.peek()
+        {
+            tokens.next(); // consume 'if'
+
+            if tokens.peek()?.token_type != TokenType::Lparen {
+                println!("Error: Expected '(' after 'else if'");
+                return None;
+            }
+            tokens.next();
+            let else_if_condition = parse_expression(tokens)?;
+
+            if tokens.peek()?.token_type != TokenType::Rparen {
+                println!("Error: Expected ')' after 'else if' condition");
+                return None;
+            }
+            tokens.next();
+
+            if tokens.peek()?.token_type != TokenType::Lbrace {
+                println!("Error: Expected '{{' after 'else if'");
+                return None;
+            }
+            tokens.next();
+            let else_if_body = parse_block(tokens)?;
+
+            // Store condition and body directly instead of nested If node
+            else_if_blocks.push((else_if_condition, else_if_body));
+        } else {
+            if tokens.peek()?.token_type != TokenType::Lbrace {
+                println!("Error: Expected '{{' after 'else'");
+                return None;
+            }
+            tokens.next();
+            else_block = Some(Box::new(parse_block(tokens)?));
+            break;
+        }
+    }
+
+    Some(ASTNode::Statement(StatementNode::If {
+        condition,
+        body,
+        else_if_blocks: if else_if_blocks.is_empty() {
+            None
+        } else {
+            Some(Box::new(else_if_blocks))
+        },
+        else_block,
+    }))
+}
+
+// FOR parsing
+pub fn parse_for(_tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
+    // TODO: Implement proper for loop parsing
+    /*
+    // Check 'for' keyword and see if there is '()
+    if tokens.peek()?.token_type != TokenType::Lparen {
+        println!("Error: Expected '(' after 'if'");
+        return None;
+    }
+    tokens.next(); // '(' Consumption
+
+    // Conditional parsing (where condition must be made ASTNode)
+    let initialization = parse_expression(tokens)?; // Parsing conditions with expressions
+    let condition = parse_expression(tokens)?;
+    let increment = parse_expression(tokens)?;
+    let body = parse_expression(tokens)?;
+
+    if tokens.peek()?.token_type != TokenType::Rparen {
+        println!("Error: Expected ')' after condition");
+        return None;
+    }
+    tokens.next(); // ')' Consumption
+
+    Some(ASTNode::Statement(StatementNode::For {
+        initialization,
+        condition,
+        increment,
+        body,
+    }))
+     */
+    None
+}
+
+// WHILE parsing
+pub fn parse_while(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
+    if tokens.peek()?.token_type != TokenType::Lparen {
+        println!("Error: Expected '(' after 'while'");
+        return None;
+    }
+    tokens.next(); // Consume '('
+
+    let condition = parse_expression(tokens)?;
+
+    if tokens.peek()?.token_type != TokenType::Rparen {
+        println!("Error: Expected ')' after 'while' condition");
+        return None;
+    }
+    tokens.next(); // Consume ')'
+
+    if tokens.peek()?.token_type != TokenType::Lbrace {
+        println!("Error: Expected '{{' after 'while'");
+        return None;
+    }
+    tokens.next(); // Consume '{'
+
+    let body = parse_block(tokens)?;
+
+    Some(ASTNode::Statement(StatementNode::While { condition, body }))
+}