@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/rust/core/debugger/store.rs

@@ -1,25 +1,38 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, preprocessor::module::Module };
-
-pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (path, module) in modules {
-        content.push_str(&format!("--- Module: {} ---\n", path));
-
-        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
-            let var_name = var_value.0.clone();
-            let var_data = var_value.1;
-
-            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
-        }
-
-        content.push_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::debugger::Debugger;
+use devalang_types::{FunctionTable, VariableTable};
+use std::fs::create_dir_all;
+
+pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (var_name, var_data) in variables.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}
+
+pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (_index, function) in functions.functions {
+        content.push_str(&format!(
+            "'{}' = [{:?}] => {:?}\n",
+            function.name, function.parameters, function.body
+        ));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/error/mod.rs

@@ -1,15 +1,50 @@
-use crate::core::parser::{ statement::{ Statement, StatementKind }, driver::Parser };
+use crate::core::parser::{
+    driver::parser::Parser,
+    statement::{Statement, StatementKind},
+};
+use devalang_types::Value;
+use serde::{Deserialize, Serialize};
 
 pub struct ErrorHandler {
     errors: Vec<Error>,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub enum Severity {
+    Warning,
+    Critical,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct StackFrame {
+    pub module: Option<String>,
+    pub context: Option<String>,
+    pub line: usize,
+    pub column: usize,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ErrorResult {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+    pub severity: Severity,
+    pub stack: Vec<StackFrame>,
+}
+
+#[derive(Clone)]
 pub struct Error {
     pub message: String,
     pub line: usize,
     pub column: usize,
 }
 
+impl Default for ErrorHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ErrorHandler {
     pub fn new() -> Self {
         Self { errors: Vec::new() }
@@ -36,25 +71,199 @@ impl ErrorHandler {
         self.errors.clear();
     }
 
-    pub fn detect_from_statements(&mut self, parser: &mut Parser, statements: &[Statement]) {
+    pub fn detect_from_statements(&mut self, _parser: &mut Parser, statements: &[Statement]) {
         for stmt in statements {
             match &stmt.kind {
                 StatementKind::Unknown => {
-                    self.add_error(
-                        "Unknown statement".to_string(),
-                        stmt.line,
-                        stmt.column
-                    );
+                    self.add_error("Unknown statement".to_string(), stmt.line, stmt.column);
                 }
                 StatementKind::Error { message } => {
-                    self.add_error(
-                        message.clone(),
-                        stmt.line,
-                        stmt.column
-                    );
+                    self.add_error(message.clone(), stmt.line, stmt.column);
                 }
                 _ => {}
             }
         }
     }
 }
+
+/// Collects errors recursively from statements (mirrors old utils implementation).
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Warning,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Unknown".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Critical,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Error".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    let nested = collect_errors_recursively(body_statements);
+                    errors.extend(nested.into_iter().map(|mut e| {
+                        e.stack.insert(
+                            0,
+                            StackFrame {
+                                module: None,
+                                context: Some("loop".to_string()),
+                                line: stmt.line,
+                                column: stmt.column,
+                            },
+                        );
+                        e
+                    }));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
+    let mut warnings = Vec::new();
+    let mut criticals = Vec::new();
+    for e in errors {
+        match e.severity {
+            Severity::Warning => warnings.push(e),
+            Severity::Critical => criticals.push(e),
+        }
+    }
+    (warnings, criticals)
+}
+
+pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
+    use devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+
+    let logger = Logger::new();
+    if !warnings.is_empty() {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!("{}: {} warning(s)", prefix, warnings.len()),
+        );
+        for w in warnings {
+            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
+            if let Some(frame) = w.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Debug,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if w.stack.len() > 1 {
+                for (i, f) in w.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Debug,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+    if !criticals.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("{}: {} critical error(s)", prefix, criticals.len()),
+        );
+        for c in criticals {
+            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
+            if let Some(frame) = c.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Error,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if c.stack.len() > 1 {
+                for (i, f) in c.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Error,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Collects errors from all modules and annotates stack frames with module names.
+pub fn collect_all_errors_with_modules(
+    statements_by_module: &std::collections::HashMap<String, Vec<Statement>>,
+) -> Vec<ErrorResult> {
+    let mut all: Vec<ErrorResult> = Vec::new();
+    for (module, stmts) in statements_by_module.iter() {
+        let mut errs = collect_errors_recursively(stmts);
+        for e in errs.iter_mut() {
+            // annotate first stack frame module if missing
+            if let Some(first) = e.stack.first_mut() {
+                if first.module.is_none() {
+                    first.module = Some(module.clone());
+                }
+            }
+        }
+        all.extend(errs.into_iter());
+    }
+    all
+}

package/rust/core/lexer/driver.rs

@@ -0,0 +1,59 @@
+use crate::core::lexer::{handler::driver::handle_content_lexing, token::Token};
+use devalang_utils::path::normalize_path;
+use std::fs;
+use std::path::Path;
+
+pub struct Lexer {}
+
+impl Default for Lexer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Lexer {
+    pub fn new() -> Self {
+        Lexer {}
+    }
+
+    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
+        handle_content_lexing(source.to_string())
+    }
+
+    pub fn lex_tokens(&self, entrypoint: &str) -> Result<Vec<Token>, String> {
+        let path = normalize_path(entrypoint);
+        let resolved_path = Self::resolve_entry_path(&path)?;
+
+        let file_content = fs::read_to_string(&resolved_path).map_err(|e| {
+            format!(
+                "Failed to read the entrypoint file '{}': {}",
+                resolved_path, e
+            )
+        })?;
+
+        handle_content_lexing(file_content).map_err(|e| format!("Failed to lex the content: {}", e))
+    }
+
+    fn resolve_entry_path(path: &str) -> Result<String, String> {
+        let candidate = Path::new(path);
+
+        if candidate.is_dir() {
+            let index_path = candidate.join("index.deva");
+            if index_path.exists() {
+                Ok(index_path.to_string_lossy().replace("\\", "/"))
+            } else {
+                Err(format!(
+                    "Expected 'index.deva' in directory '{}', but it was not found",
+                    path
+                ))
+            }
+        } else if candidate.is_file() {
+            return Ok(path.to_string());
+        } else {
+            return Err(format!(
+                "Provided entrypoint '{}' is not a valid file or directory",
+                path
+            ));
+        }
+    }
+}

package/rust/core/lexer/handler/arrow.rs

@@ -1,29 +1,80 @@
-use crate::core::lexer::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_arrow_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
-    let mut arrow_call = char.to_string();
-
-    while let Some(&c) = chars.peek() {
+    // If next char is '>', this is an arrow '->'.
+    if let Some(&c) = chars.peek() {
         if c == '>' {
+            let mut arrow_call = ch.to_string();
             chars.next();
             arrow_call.push(c);
             *column += 1;
-        } else {
-            break;
+
+            tokens.push(Token {
+                kind: TokenKind::Arrow,
+                lexeme: arrow_call,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
+        }
+    }
+
+    // Otherwise, treat '-' as the start of a negative number if followed by digits.
+    let mut lexeme = String::from("-");
+    if let Some(&next) = chars.peek() {
+        if next.is_ascii_digit() {
+            // consume digits
+            while let Some(&d) = chars.peek() {
+                if d.is_ascii_digit() {
+                    chars.next();
+                    lexeme.push(d);
+                    *column += 1;
+                } else {
+                    break;
+                }
+            }
+            // optional decimal part
+            if let Some(&dot) = chars.peek() {
+                if dot == '.' {
+                    chars.next();
+                    lexeme.push(dot);
+                    *column += 1;
+                    while let Some(&d) = chars.peek() {
+                        if d.is_ascii_digit() {
+                            chars.next();
+                            lexeme.push(d);
+                            *column += 1;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            tokens.push(Token {
+                kind: TokenKind::Number,
+                lexeme,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
         }
     }
 
+    // Fallback: lone '-' not part of '->' or a number; emit Unknown to avoid mis-parsing as Arrow
     tokens.push(Token {
-        kind: TokenKind::Arrow,
-        lexeme: arrow_call,
+        kind: TokenKind::Unknown,
+        lexeme: "-".to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/at.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_at_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     tokens.push(Token {
         kind: TokenKind::At,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/brace.rs

@@ -1,17 +1,17 @@
-use crate::core::lexer::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_rbrace_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     tokens.push(Token {
         kind: TokenKind::RBrace,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,
@@ -21,17 +21,17 @@ pub fn handle_rbrace_lexer(
 }
 
 pub fn handle_lbrace_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     tokens.push(Token {
         kind: TokenKind::LBrace,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/colon.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_colon_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     tokens.push(Token {
         kind: TokenKind::Colon,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/comment.rs

@@ -1,13 +1,13 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_comment_lexer(
-    char: char,
+    _char: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     let mut comment = String::new();
 

package/rust/core/lexer/handler/dot.rs

@@ -1,17 +1,17 @@
-use crate::core::lexer::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_dot_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize
+    column: &mut usize,
 ) {
     tokens.push(Token {
         kind: TokenKind::Dot,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,