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

package/rust/core/preprocessor/module.rs

@@ -1,50 +1,55 @@
-use crate::core::{
-    lexer::token::Token,
-    parser::statement::Statement,
-    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
-};
-
-#[derive(Debug, Clone)]
-pub struct Module {
-    pub path: String,
-    pub resolved: bool,
-    pub tokens: Vec<Token>,
-    pub statements: Vec<Statement>,
-    pub variable_table: VariableTable,
-    pub export_table: ExportTable,
-    pub import_table: ImportTable,
-    pub content: String,
-    pub current_dir: String,
-}
-
-impl Module {
-    pub fn new(path: &str) -> Self {
-        Module {
-            path: path.to_string(),
-            tokens: Vec::new(),
-            statements: Vec::new(),
-            variable_table: VariableTable::new(),
-            export_table: ExportTable::new(),
-            import_table: ImportTable::new(),
-            resolved: false,
-            content: String::new(),
-            current_dir: String::new(),
-        }
-    }
-
-    pub fn is_resolved(&self) -> bool {
-        self.resolved
-    }
-
-    pub fn set_resolved(&mut self, resolved: bool) {
-        self.resolved = resolved;
-    }
-
-    pub fn add_token(&mut self, token: Token) {
-        self.tokens.push(token);
-    }
-
-    pub fn add_statement(&mut self, statement: Statement) {
-        self.statements.push(statement);
-    }
-}
+use crate::core::{lexer::token::Token, parser::statement::Statement};
+use devalang_types::{ExportTable, FunctionTable, ImportTable, VariableTable};
+
+#[derive(Debug, Clone)]
+pub struct Module {
+    pub path: String,
+    pub resolved: bool,
+    pub tokens: Vec<Token>,
+    pub statements: Vec<Statement>,
+    pub variable_table: VariableTable,
+    pub function_table: FunctionTable,
+    pub export_table: ExportTable,
+    pub import_table: ImportTable,
+    pub content: String,
+    pub current_dir: String,
+}
+
+impl Module {
+    pub fn new(path: &str) -> Self {
+        Module {
+            path: path.to_string(),
+            tokens: Vec::new(),
+            statements: Vec::new(),
+            variable_table: VariableTable::new(),
+            function_table: FunctionTable::new(),
+            export_table: ExportTable::new(),
+            import_table: ImportTable::new(),
+            resolved: false,
+            content: String::new(),
+            current_dir: String::new(),
+        }
+    }
+
+    pub fn is_resolved(&self) -> bool {
+        self.resolved
+    }
+
+    pub fn set_resolved(&mut self, resolved: bool) {
+        self.resolved = resolved;
+    }
+
+    pub fn add_token(&mut self, token: Token) {
+        self.tokens.push(token);
+    }
+
+    pub fn add_statement(&mut self, statement: Statement) {
+        self.statements.push(statement);
+    }
+
+    pub fn from_existing(path: &str, content: String) -> Self {
+        let mut module = Module::new(path);
+        module.content = content;
+        module
+    }
+}

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

@@ -0,0 +1,107 @@
+use crate::core::{
+    parser::statement::StatementKind, preprocessor::loader::ModuleLoader,
+    store::global::GlobalStore,
+};
+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() {
+        let logger = devalang_utils::logger::Logger::new();
+        use devalang_utils::logger::LogLevel;
+
+        for stmt in &module.statements {
+            match &stmt.kind {
+                StatementKind::Let { name } => {
+                    if let Value::Null = stmt.value {
+                        logger.log_message(
+                            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;
+                    }
+
+                    if module.variable_table.get(name).is_some() {
+                        logger.log_message(
+                            LogLevel::Error,
+                            &format!("Variable '{}' is already defined in this scope.", name),
+                        );
+                        continue;
+                    }
+
+                    if let Some(module_variable) = module.variable_table.variables.get(name) {
+                        logger.log_message(
+                            LogLevel::Error,
+                            &format!(
+                                "Variable '{}' is already defined globally with value: {:?}",
+                                name, module_variable
+                            ),
+                        );
+                        continue;
+                    }
+
+                    module
+                        .variable_table
+                        .variables
+                        .insert(name.clone(), stmt.value.clone());
+                }
+
+                StatementKind::Load { source, alias } => {
+                    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
+                        .insert(alias.clone(), Value::Sample(resolved_path));
+                }
+
+                StatementKind::Export { names, source: _ } => {
+                    for name in names {
+                        if let Some(val) = module.variable_table.get(name) {
+                            module.export_table.add_export(name.clone(), val.clone());
+                        }
+                    }
+                }
+
+                StatementKind::Import { names, source } => {
+                    let resolved = resolve_relative_path(&module.path, source);
+                    for name in names {
+                        module
+                            .import_table
+                            .add_import(name.clone(), Value::String(resolved.clone()));
+                    }
+                }
+
+                StatementKind::Group => {
+                    if let Value::Map(map) = &stmt.value {
+                        if let (Some(Value::String(name)), Some(Value::Block(body))) =
+                            (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));
+                        } else {
+                            logger.log_message(
+                                LogLevel::Error,
+                                &format!("Invalid group definition: {:?}", stmt.value),
+                            );
+                        }
+                    }
+                }
+
+                _ => {}
+            }
+        }
+    }
+}

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

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

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

@@ -1,22 +1,19 @@
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+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
+    _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) {
@@ -33,8 +30,13 @@ pub fn resolve_bank(
 
         Value::String(_) => {}
 
+        Value::Number(_) => {}
+
         other => {
-            let message = format!("Expected a string or identifier for bank, found {:?}", 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(),

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

@@ -1,123 +1,124 @@
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{ Logger, LogLevel },
+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
+    _path: &str,
+    global_store: &mut GlobalStore,
 ) -> Statement {
     let logger = Logger::new();
 
-    match &stmt.value {
-        Value::Identifier(ident) => {
-            match module.variable_table.get(ident) {
-                Some(Value::String(group_name)) =>
-                    resolve_group_by_name(group_name, stmt, module, path, global_store, &logger),
-                Some(Value::Map(group_map)) =>
-                    resolved_call(stmt, group_map, module, path, global_store),
-                Some(other) =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!(
-                            "Identifier '{ident}' must resolve to a group name or map, found {:?}",
-                            other
-                        )
-                    ),
-                None =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!("Identifier '{ident}' not found in variable table")
+    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()));
 
-        Value::String(name) =>
-            resolve_group_by_name(name, stmt, module, path, global_store, &logger),
+                return Statement {
+                    kind: StatementKind::Call { name, args },
+                    value: Value::Map(call_map),
+                    ..stmt.clone()
+                };
+            }
 
-        Value::Map(group_map) => resolved_call(stmt, group_map, module, path, global_store),
+            // 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()));
 
-        other =>
-            error_stmt(
-                &logger,
-                module,
-                stmt,
-                &format!("Call expects a group name as string or identifier, found {:?}", other)
-            ),
-    }
-}
-
-fn resolve_group_by_name(
-    name: &str,
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-    logger: &Logger
-) -> Statement {
-    match module.variable_table.get(name) {
-        Some(Value::Map(group_map)) => resolved_call(stmt, group_map, module, path, global_store),
-        Some(other) =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Expected a group for '{}', but found {:?}", name, other)
-            ),
-        None =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Group '{}' not found in module '{}'", name, module.path)
-            ),
-    }
-}
+                            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()));
 
-fn resolved_call(
-    stmt: &Statement,
-    group_map: &std::collections::HashMap<String, Value>,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let mut cloned_map = group_map.clone();
+                    return Statement {
+                        kind: StatementKind::Call { name, args },
+                        value: Value::Map(resolved_map),
+                        ..stmt.clone()
+                    };
+                }
+            }
 
-    if let Some(Value::Block(stmts)) = group_map.get("body") {
-        let resolved = stmts
-            .iter()
-            .map(|s| resolve_statement(s, module, path, global_store))
-            .collect();
-        cloned_map.insert("body".to_string(), Value::Block(resolved));
-    }
+            // 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::Call,
-        value: Value::Map(cloned_map),
-        ..stmt.clone()
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Expected StatementKind::Call in resolve_call()".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
     }
 }
 
-fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
-
-    Statement {
-        kind: StatementKind::Error {
-            message: message.to_string(),
-        },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+// (removed unused helpers get_group_body, error_stmt)

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+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,
@@ -17,7 +15,12 @@ pub fn resolve_condition(
     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());
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in condition statement".to_string(),
+        );
     };
 
     let mut resolved_map = condition_map.clone();
@@ -66,7 +69,7 @@ fn resolve_block_statements(
         .flat_map(|stmt| {
             let resolved = resolve_statement(stmt, module, path, global_store);
 
-            if let StatementKind::Call = resolved.kind {
+            if let StatementKind::Call { .. } = resolved.kind {
                 if let Value::Block(inner) = &resolved.value {
                     return inner
                         .iter()