@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/core/preprocessor/{processor.rs → processor/handlers.rs}

@@ -1,12 +1,10 @@
-use std::{collections::HashMap, path::Path};
-
 use crate::core::{
-    parser::statement::StatementKind,
-    preprocessor::loader::ModuleLoader,
+    parser::statement::StatementKind, preprocessor::loader::ModuleLoader,
     store::global::GlobalStore,
-    utils::path::{normalize_path, resolve_relative_path},
 };
 use devalang_types::Value;
+use devalang_utils::path::{normalize_path, resolve_relative_path};
+use std::collections::HashMap;
 
 pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for module in global_store.modules.values_mut() {
@@ -21,12 +19,10 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                             LogLevel::Error,
                             &format!("Variable '{}' is declared but not initialized.", name),
                         );
-
                         module.variable_table.variables.insert(
                             name.clone(),
                             Value::StatementKind(Box::new(stmt.kind.clone())),
                         );
-
                         continue;
                     }
 
@@ -56,10 +52,10 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                 }
 
                 StatementKind::Load { source, alias } => {
-                    let module_dir = Path::new(&module.path).parent().unwrap_or(Path::new(""));
-
+                    let module_dir = std::path::Path::new(&module.path)
+                        .parent()
+                        .unwrap_or(std::path::Path::new(""));
                     let resolved_path = normalize_path(module_dir.join(source));
-
                     module
                         .variable_table
                         .variables
@@ -89,12 +85,9 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                             (map.get("identifier"), map.get("body"))
                         {
                             let mut stored_map = HashMap::new();
-
                             stored_map
                                 .insert("identifier".to_string(), Value::String(name.clone()));
-
                             stored_map.insert("body".to_string(), Value::Block(body.clone()));
-
                             module
                                 .variable_table
                                 .set(name.to_string(), Value::Map(stored_map));

package/rust/core/preprocessor/processor/mod.rs

@@ -0,0 +1 @@
+pub mod handlers;

package/rust/core/preprocessor/resolver/bank.rs

@@ -1,49 +1,49 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::Logger;
-
-pub fn resolve_bank(
-    stmt: &Statement,
-    module: &Module,
-    _path: &str,
-    _global_store: &GlobalStore,
-) -> Statement {
-    let mut new_stmt = stmt.clone();
-    let logger = Logger::new();
-    match &stmt.value {
-        Value::Identifier(ident) => {
-            if let Some(val) = module.variable_table.get(ident) {
-                new_stmt.value = val.clone();
-            } else {
-                let message = format!("Bank identifier '{ident}' not found in variable table");
-                logger.log_error_with_stacktrace(&message, &module.path);
-                new_stmt.kind = StatementKind::Error {
-                    message: message.clone(),
-                };
-                new_stmt.value = Value::Null;
-            }
-        }
-
-        Value::String(_) => {}
-
-        Value::Number(_) => {}
-
-        other => {
-            let message = format!(
-                "Expected a string or identifier for bank, found {:?}",
-                other
-            );
-            logger.log_error_with_stacktrace(&message, &module.path);
-            new_stmt.kind = StatementKind::Error {
-                message: "Expected a string or identifier for bank".to_string(),
-            };
-            new_stmt.value = Value::Null;
-        }
-    }
-
-    new_stmt
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
+
+pub fn resolve_bank(
+    stmt: &Statement,
+    module: &Module,
+    _path: &str,
+    _global_store: &GlobalStore,
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                let message = format!("Bank identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message: message.clone(),
+                };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::String(_) => {}
+
+        Value::Number(_) => {}
+
+        other => {
+            let message = format!(
+                "Expected a string or identifier for bank, found {:?}",
+                other
+            );
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a string or identifier for bank".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

package/rust/core/preprocessor/resolver/call.rs

@@ -1,124 +1,124 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-pub fn resolve_call(
-    stmt: &Statement,
-    name: String,
-    args: Vec<Value>,
-    module: &Module,
-    _path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    match &stmt.kind {
-        StatementKind::Call { .. } => {
-            // Check if it's a function
-            if let Some(func) = global_store.functions.functions.get(&name) {
-                let mut call_map = std::collections::HashMap::new();
-                call_map.insert("name".to_string(), Value::Identifier(name.clone()));
-                call_map.insert(
-                    "parameters".to_string(),
-                    Value::Array(
-                        func.parameters
-                            .iter()
-                            .map(|p| Value::Identifier(p.clone()))
-                            .collect(),
-                    ),
-                );
-                call_map.insert("args".to_string(), Value::Array(args.clone()));
-                call_map.insert("body".to_string(), Value::Block(func.body.clone()));
-
-                return Statement {
-                    kind: StatementKind::Call { name, args },
-                    value: Value::Map(call_map),
-                    ..stmt.clone()
-                };
-            }
-
-            // Otherwise, check if it's a variable (e.g. group)
-            if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(&name) {
-                if let StatementKind::Group = stmt_box.kind {
-                    if let Value::Map(map) = &stmt_box.value {
-                        if let Some(Value::Block(body)) = map.get("body") {
-                            let mut resolved_map = std::collections::HashMap::new();
-                            resolved_map
-                                .insert("identifier".to_string(), Value::String(name.clone()));
-                            resolved_map.insert("args".to_string(), Value::Array(args.clone()));
-                            resolved_map.insert("body".to_string(), Value::Block(body.clone()));
-
-                            return Statement {
-                                kind: StatementKind::Call { name, args },
-                                value: Value::Map(resolved_map),
-                                ..stmt.clone()
-                            };
-                        }
-                    }
-                }
-                // Pattern case
-                if let StatementKind::Pattern { .. } = stmt_box.kind {
-                    // pattern value may be a string or a map stored on the statement
-                    let mut resolved_map = std::collections::HashMap::new();
-                    resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
-                    // pattern value
-                    match &stmt_box.value {
-                        Value::String(s) => {
-                            resolved_map.insert("pattern".to_string(), Value::String(s.clone()));
-                        }
-                        Value::Map(m) => {
-                            if let Some(val) = m.get("pattern") {
-                                resolved_map.insert("pattern".to_string(), val.clone());
-                            }
-                            if let Some(val) = m.get("target") {
-                                resolved_map.insert("target".to_string(), val.clone());
-                            }
-                        }
-                        _ => {}
-                    }
-                    resolved_map.insert("args".to_string(), Value::Array(args.clone()));
-
-                    return Statement {
-                        kind: StatementKind::Call { name, args },
-                        value: Value::Map(resolved_map),
-                        ..stmt.clone()
-                    };
-                }
-            }
-
-            // Otherwise, log an error
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Function or group '{}' not found", name),
-            );
-            Statement {
-                kind: StatementKind::Error {
-                    message: format!("Function or group '{}' not found", name),
-                },
-                value: Value::Null,
-                ..stmt.clone()
-            }
-        }
-        _ => {
-            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Expected StatementKind::Call in resolve_call()\n  → at {stacktrace}"),
-            );
-
-            Statement {
-                kind: StatementKind::Error {
-                    message: "Expected StatementKind::Call in resolve_call()".to_string(),
-                },
-                value: Value::Null,
-                ..stmt.clone()
-            }
-        }
-    }
-}
-
-// (removed unused helpers get_group_body, error_stmt)
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn resolve_call(
+    stmt: &Statement,
+    name: String,
+    args: Vec<Value>,
+    module: &Module,
+    _path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    match &stmt.kind {
+        StatementKind::Call { .. } => {
+            // Check if it's a function
+            if let Some(func) = global_store.functions.functions.get(&name) {
+                let mut call_map = std::collections::HashMap::new();
+                call_map.insert("name".to_string(), Value::Identifier(name.clone()));
+                call_map.insert(
+                    "parameters".to_string(),
+                    Value::Array(
+                        func.parameters
+                            .iter()
+                            .map(|p| Value::Identifier(p.clone()))
+                            .collect(),
+                    ),
+                );
+                call_map.insert("args".to_string(), Value::Array(args.clone()));
+                call_map.insert("body".to_string(), Value::Block(func.body.clone()));
+
+                return Statement {
+                    kind: StatementKind::Call { name, args },
+                    value: Value::Map(call_map),
+                    ..stmt.clone()
+                };
+            }
+
+            // Otherwise, check if it's a variable (e.g. group)
+            if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(&name) {
+                if let StatementKind::Group = stmt_box.kind {
+                    if let Value::Map(map) = &stmt_box.value {
+                        if let Some(Value::Block(body)) = map.get("body") {
+                            let mut resolved_map = std::collections::HashMap::new();
+                            resolved_map
+                                .insert("identifier".to_string(), Value::String(name.clone()));
+                            resolved_map.insert("args".to_string(), Value::Array(args.clone()));
+                            resolved_map.insert("body".to_string(), Value::Block(body.clone()));
+
+                            return Statement {
+                                kind: StatementKind::Call { name, args },
+                                value: Value::Map(resolved_map),
+                                ..stmt.clone()
+                            };
+                        }
+                    }
+                }
+                // Pattern case
+                if let StatementKind::Pattern { .. } = stmt_box.kind {
+                    // pattern value may be a string or a map stored on the statement
+                    let mut resolved_map = std::collections::HashMap::new();
+                    resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
+                    // pattern value
+                    match &stmt_box.value {
+                        Value::String(s) => {
+                            resolved_map.insert("pattern".to_string(), Value::String(s.clone()));
+                        }
+                        Value::Map(m) => {
+                            if let Some(val) = m.get("pattern") {
+                                resolved_map.insert("pattern".to_string(), val.clone());
+                            }
+                            if let Some(val) = m.get("target") {
+                                resolved_map.insert("target".to_string(), val.clone());
+                            }
+                        }
+                        _ => {}
+                    }
+                    resolved_map.insert("args".to_string(), Value::Array(args.clone()));
+
+                    return Statement {
+                        kind: StatementKind::Call { name, args },
+                        value: Value::Map(resolved_map),
+                        ..stmt.clone()
+                    };
+                }
+            }
+
+            // Otherwise, log an error
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Function or group '{}' not found", name),
+            );
+            Statement {
+                kind: StatementKind::Error {
+                    message: format!("Function or group '{}' not found", name),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
+        _ => {
+            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Expected StatementKind::Call in resolve_call()\n  → at {stacktrace}"),
+            );
+
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Expected StatementKind::Call in resolve_call()".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
+    }
+}
+
+// (removed unused helpers get_group_body, error_stmt)

package/rust/core/preprocessor/resolver/condition.rs

@@ -1,95 +1,95 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::{module::Module, resolver::driver::resolve_statement},
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::Logger;
-
-pub fn resolve_condition(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    let Value::Map(condition_map) = &stmt.value else {
-        return type_error(
-            &logger,
-            module,
-            stmt,
-            "Expected a map in condition statement".to_string(),
-        );
-    };
-
-    let mut resolved_map = condition_map.clone();
-
-    // Main body resolution
-    if let Some(Value::Block(body)) = condition_map.get("body") {
-        let resolved_body = resolve_block_statements(body, module, path, global_store);
-        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
-    }
-
-    // Recursive resolution of next condition
-    if let Some(Value::Map(next_map)) = condition_map.get("next") {
-        let next_stmt = Statement {
-            kind: StatementKind::If,
-            value: Value::Map(next_map.clone()),
-            ..stmt.clone()
-        };
-
-        let resolved_next = resolve_condition(&next_stmt, module, path, global_store);
-
-        if let Value::Map(mut resolved_next_map) = resolved_next.value {
-            // Body next resolution
-            if let Some(Value::Block(body)) = resolved_next_map.get("body") {
-                let resolved_body = resolve_block_statements(body, module, path, global_store);
-                resolved_next_map.insert("body".to_string(), Value::Block(resolved_body));
-            }
-
-            resolved_map.insert("next".to_string(), Value::Map(resolved_next_map));
-        }
-    }
-
-    Statement {
-        kind: StatementKind::If,
-        value: Value::Map(resolved_map),
-        ..stmt.clone()
-    }
-}
-
-fn resolve_block_statements(
-    body: &[Statement],
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Vec<Statement> {
-    body.iter()
-        .flat_map(|stmt| {
-            let resolved = resolve_statement(stmt, module, path, global_store);
-
-            if let StatementKind::Call { .. } = resolved.kind {
-                if let Value::Block(inner) = &resolved.value {
-                    return inner
-                        .iter()
-                        .map(|s| resolve_statement(s, module, path, global_store))
-                        .collect();
-                }
-            }
-
-            vec![resolved]
-        })
-        .collect()
-}
-
-fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
-
-    Statement {
-        kind: StatementKind::Error { message },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
+
+pub fn resolve_condition(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(condition_map) = &stmt.value else {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in condition statement".to_string(),
+        );
+    };
+
+    let mut resolved_map = condition_map.clone();
+
+    // Main body resolution
+    if let Some(Value::Block(body)) = condition_map.get("body") {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    }
+
+    // Recursive resolution of next condition
+    if let Some(Value::Map(next_map)) = condition_map.get("next") {
+        let next_stmt = Statement {
+            kind: StatementKind::If,
+            value: Value::Map(next_map.clone()),
+            ..stmt.clone()
+        };
+
+        let resolved_next = resolve_condition(&next_stmt, module, path, global_store);
+
+        if let Value::Map(mut resolved_next_map) = resolved_next.value {
+            // Body next resolution
+            if let Some(Value::Block(body)) = resolved_next_map.get("body") {
+                let resolved_body = resolve_block_statements(body, module, path, global_store);
+                resolved_next_map.insert("body".to_string(), Value::Block(resolved_body));
+            }
+
+            resolved_map.insert("next".to_string(), Value::Map(resolved_next_map));
+        }
+    }
+
+    Statement {
+        kind: StatementKind::If,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
+    }
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Vec<Statement> {
+    body.iter()
+        .flat_map(|stmt| {
+            let resolved = resolve_statement(stmt, module, path, global_store);
+
+            if let StatementKind::Call { .. } = resolved.kind {
+                if let Value::Block(inner) = &resolved.value {
+                    return inner
+                        .iter()
+                        .map(|s| resolve_statement(s, module, path, global_store))
+                        .collect();
+                }
+            }
+
+            vec![resolved]
+        })
+        .collect()
+}
+
+fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+
+    Statement {
+        kind: StatementKind::Error { message },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}