@devaloop/devalang 0.0.1-alpha.7 → 0.0.1-alpha.9

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

@@ -0,0 +1,227 @@
+use std::collections::HashMap;
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{
+            loader::ModuleLoader,
+            module::Module,
+            resolver::{
+                bank::resolve_bank,
+                call::resolve_call,
+                condition::resolve_condition,
+                group::resolve_group,
+                let_::resolve_let,
+                loop_::resolve_loop,
+                spawn::resolve_spawn,
+                tempo::resolve_tempo,
+                trigger::resolve_trigger,
+            },
+        },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for module in global_store.clone().modules.values_mut() {
+        resolve_imports(module_loader, global_store);
+    }
+}
+
+pub fn resolve_statement(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    match &stmt.kind {
+        StatementKind::Trigger { entity, duration } =>
+            resolve_trigger(stmt, entity, &mut duration.clone(), module, path, global_store),
+        StatementKind::If => resolve_condition(stmt, module, path, global_store),
+        StatementKind::Group => resolve_group(stmt, module, path, global_store),
+        StatementKind::Call => resolve_call(stmt, module, path, global_store),
+        StatementKind::Spawn => resolve_spawn(stmt, module, path, global_store),
+        StatementKind::Bank => resolve_bank(stmt, module, path, global_store),
+        StatementKind::Tempo => resolve_tempo(stmt, module, path, global_store),
+        StatementKind::Loop => resolve_loop(stmt, module, path, global_store),
+        StatementKind::Let { name, .. } => resolve_let(stmt, name, module, path, global_store),
+
+        _ => {
+            let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+            Statement {
+                value: resolved_value,
+                ..stmt.clone()
+            }
+        }
+    }
+}
+
+fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::Identifier(name) => {
+            if let Some(original_val) = module.variable_table.get(name) {
+                return resolve_value(original_val, module, global_store);
+            }
+
+            if let Some(export_val) = find_export_value(name, global_store) {
+                return resolve_value(&export_val, module, global_store);
+            }
+
+            eprintln!("⚠️ Unresolved identifier '{}'", name);
+            Value::Null
+        }
+
+        Value::Map(map) => {
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+            Value::Map(resolved)
+        }
+
+        Value::Block(stmts) => {
+            let resolved_stmts = stmts
+                .iter()
+                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
+                .collect();
+            Value::Block(resolved_stmts)
+        }
+
+        other => other.clone(),
+    }
+}
+
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for (_path, module) in &global_store.modules {
+        if let Some(val) = module.export_table.get_export(name) {
+            return Some(val.clone());
+        }
+    }
+    None
+}
+
+pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for (module_path, module) in global_store.clone().modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            match source_path {
+                Value::String(source_path) => {
+                    if let Some(source_module) = global_store.modules.get(source_path) {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            println!(
+                                "[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"
+                            );
+                        }
+                    } else {
+                        println!(
+                            "[warn] '{module_path}': cannot find source module '{source_path}'"
+                        );
+                    }
+                }
+                _ => {
+                    println!(
+                        "[warn] '{module_path}': expected string for import source, found {:?}",
+                        source_path
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn resolve_and_flatten_all_modules(
+    global_store: &mut GlobalStore
+) -> HashMap<String, Vec<Statement>> {
+    let logger = Logger::new();
+    let snapshot = global_store.clone();
+
+    // 1. Imports resolution
+    for (module_path, module) in global_store.modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            if let Value::String(source_path_str) = source_path {
+                match snapshot.modules.get(source_path_str) {
+                    Some(source_module) => {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            logger.log_error_with_stacktrace(
+                                &format!("'{name}' not found in exports of '{source_path_str}'"),
+                                module_path
+                            );
+                        }
+                    }
+                    None => {
+                        logger.log_error_with_stacktrace(
+                            &format!("Cannot find source module '{source_path_str}'"),
+                            module_path
+                        );
+                    }
+                }
+            } else {
+                logger.log_error_with_stacktrace(
+                    &format!("Expected string for import source, found {:?}", source_path),
+                    module_path
+                );
+            }
+        }
+    }
+
+    // 2. Statements resolution
+    let mut resolved_map: HashMap<String, Vec<Statement>> = HashMap::new();
+    for (path, module) in global_store.modules.clone() {
+        let mut resolved = Vec::new();
+
+        for stmt in &module.statements {
+            let mut stmt = stmt.clone();
+
+            match &stmt.kind {
+                StatementKind::Trigger { entity, duration } => {
+                    let resolved_stmt = resolve_trigger(
+                        &stmt,
+                        entity.as_str(),
+                        &mut duration.clone(),
+                        &module,
+                        &path,
+                        global_store
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Loop => {
+                    let resolved_stmt = resolve_loop(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Bank => {
+                    let resolved_stmt = resolve_bank(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Tempo => {
+                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Import { .. } | StatementKind::Export { .. } => {
+                    resolved.push(stmt.clone());
+                }
+
+                StatementKind::Group => {
+                    let resolved_stmt = resolve_group(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                _ => {
+                    resolved.push(stmt);
+                }
+            }
+        }
+
+        resolved_map.insert(path.clone(), resolved);
+    }
+
+    resolved_map
+}

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

@@ -3,111 +3,59 @@ use std::collections::HashMap;
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
-        store::global::GlobalStore,
+        store::{ global::GlobalStore, variable::VariableTable },
     },
-    utils::logger::Logger,
+    utils::logger::{ LogLevel, Logger },
 };
 
 pub fn resolve_group(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &GlobalStore
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    if let Value::Map(value_map) = &stmt.value {
-        let group_name = match value_map.get("identifier") {
-            Some(Value::String(name)) => name.clone(),
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Group name must be a string, found {:?}", other)
-                );
-                return stmt.clone();
-            }
-            None => {
-                log_type_error(&logger, module, stmt, "Group name is required".to_string());
-                return stmt.clone();
-            }
-        };
+    let Value::Map(group_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map in group statement".to_string());
+    };
 
-        let body_value = match value_map.get("body") {
-            Some(Value::Block(block)) => {
-                let mut resolved_block = Vec::new();
-                for ref statement in block.clone() {
-                    match &statement.kind {
-                        StatementKind::Trigger { entity, duration } => {
-                            let resolved = resolve_trigger(
-                                &mut statement.clone(),
-                                &entity,
-                                &mut duration.clone(),
-                                module,
-                                path,
-                                global_store
-                            );
-                            resolved_block.push(resolved);
-                        }
-                        _ => {
-                            println!("Unhandled group body statement: {:?}", statement);
-                        }
-                    }
-                }
-                Value::Block(resolved_block)
-            }
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Unexpected value for group body: {:?}", other)
-                );
-                Value::Null
-            }
-            None => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    "Missing 'body' key in group statement map".to_string()
-                );
-                Value::Null
-            }
-        };
+    let mut resolved_map = group_map.clone();
 
-        let mut resolved_map = HashMap::new();
-
-        resolved_map.insert("identifier".to_string(), Value::String(group_name));
-        resolved_map.insert("body".to_string(), body_value);
-
-        return Statement {
-            kind: StatementKind::Group,
-            value: Value::Map(resolved_map),
-            ..stmt.clone()
-        };
+    if let Some(Value::Block(body)) = group_map.get("body") {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
     } else {
-        log_type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Expected Map for group statement, found {:?}", stmt.value)
-        );
+        logger.log_message(LogLevel::Warning, "group without a body");
+    }
 
-        Statement {
-            kind: StatementKind::Error {
-                message: "Expected a map for group statement".to_string(),
-            },
-            value: Value::Null,
-            ..stmt.clone()
-        }
+    Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
     }
 }
 
-fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .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()
+    }
 }

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

@@ -0,0 +1,31 @@
+use crate::
+    core::{
+        parser::statement:: Statement ,
+        preprocessor::{
+            module::Module,
+            resolver:: value::resolve_value ,
+        },
+        store:: global::GlobalStore ,
+    }
+;
+
+pub fn resolve_let(
+    stmt: &Statement,
+    name: &str,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    if let Some(current_mod) = global_store.modules.get_mut(path) {
+        current_mod.variable_table.set(name.to_string(), resolved_value.clone());
+    } else {
+        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+    }
+
+    Statement {
+        value: resolved_value,
+        ..stmt.clone()
+    }
+}

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

@@ -3,7 +3,10 @@ use std::collections::HashMap;
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        preprocessor::{
+            module::Module,
+            resolver::{ driver::resolve_statement, value::resolve_value },
+        },
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -14,132 +17,75 @@ pub fn resolve_loop(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &GlobalStore
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    if let Value::Map(value_map) = &stmt.value {
-        let iterator_value = match value_map.get("iterator") {
-            Some(Value::Identifier(ident)) => {
-                match module.variable_table.get(ident) {
-                    Some(Value::Number(n)) => Value::Number(*n),
-                    Some(_) => {
-                        log_type_error(
-                            &logger,
-                            module,
-                            stmt,
-                            format!("Loop iterator '{ident}' must resolve to a number")
-                        );
-                        Value::Null
-                    }
-                    None => {
-                        // Value is not a variable so we assume it's a number
-                        if let Ok(n) = ident.parse::<f32>() {
-                            Value::Number(n)
-                        } else {
-                            log_type_error(
-                                &logger,
-                                module,
-                                stmt,
-                                format!("Loop iterator '{ident}' is not a valid number")
-                            );
-                            Value::Null
-                        }
-                    }
-                }
-            }
-            Some(Value::Number(n)) => Value::Number(*n),
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Unexpected value for loop iterator: {:?}", other)
-                );
-                Value::Null
-            }
-            None => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    "Missing 'iterator' key in loop statement map".to_string()
-                );
-                Value::Null
-            }
-        };
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
 
-        let body_value = match value_map.get("body") {
-            Some(Value::Block(block)) => {
-                let mut resolved_block = Vec::new();
-                for ref statement in block.clone() {
-                    match &statement.kind {
-                        StatementKind::Trigger { entity, duration } => {
-                            let resolved = resolve_trigger(
-                                &mut statement.clone(),
-                                &entity,
-                                &mut duration.clone(),
-                                module,
-                                path,
-                                global_store
-                            );
-                            resolved_block.push(resolved);
-                        }
-                        _ => {
-                            println!("Unhandled loop body statement: {:?}", statement);
-                        }
-                    }
-                }
-                Value::Block(resolved_block)
-            }
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Unexpected value for loop body: {:?}", other)
-                );
-                Value::Null
-            }
-            None => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    "Missing 'body' key in loop statement map".to_string()
-                );
-                Value::Null
-            }
-        };
+    let Value::Map(value_map) = &resolved_value else {
+        return error_stmt(&logger, module, stmt, "Expected a map for loop value");
+    };
 
-        let mut resolved_map = HashMap::new();
-        resolved_map.insert("iterator".to_string(), iterator_value);
-        resolved_map.insert("body".to_string(), body_value);
+    let mut resolved_map: HashMap<String, Value> = HashMap::new();
+    for (key, val) in value_map {
+        resolved_map.insert(key.clone(), resolve_value(val, module, global_store));
+    }
 
-        Statement {
-            kind: StatementKind::Loop,
-            value: Value::Map(resolved_map),
-            ..stmt.clone()
+    let iterator_value = match resolved_map.get("iterator") {
+        Some(Value::Number(n)) => Value::Number(*n),
+        Some(other) => {
+            error_value(
+                &logger,
+                module,
+                stmt,
+                &format!("Loop iterator must be a number, found: {:?}", other)
+            );
+            Value::Number(1.0)
+        }
+        None => {
+            error_value(&logger, module, stmt, "Missing 'iterator' in loop");
+            Value::Number(1.0)
         }
-    } else {
-        log_type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Expected a map for loop value, found {:?}", stmt.value)
-        );
+    };
 
-        Statement {
-            kind: StatementKind::Error {
-                message: "Expected a map for loop value".to_string(),
-            },
-            value: Value::Null,
-            ..stmt.clone()
+    let body_value = match resolved_map.remove("body") {
+        Some(Value::Block(stmts)) => {
+            let resolved = stmts
+                .iter()
+                .map(|s| resolve_statement(s, module, path, global_store))
+                .collect();
+            Value::Block(resolved)
         }
+        _ => {
+            error_value(&logger, module, stmt, "Invalid or missing loop body");
+            Value::Block(vec![])
+        }
+    };
+
+    let mut final_map = HashMap::new();
+    final_map.insert("iterator".to_string(), iterator_value);
+    final_map.insert("body".to_string(), body_value);
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(final_map),
+        ..stmt.clone()
     }
 }
 
-fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+fn error_value(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) {
     let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
+    logger.log_error_with_stacktrace(msg, &stacktrace);
+}
+
+fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) -> Statement {
+    error_value(logger, module, stmt, msg);
+    Statement {
+        kind: StatementKind::Error {
+            message: msg.to_string(),
+        },
+        value: Value::Null,
+        ..stmt.clone()
+    }
 }