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

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

@@ -3,101 +3,33 @@ use std::collections::HashMap;
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::{condition::resolve_condition, 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();
 
-    let Value::Map(value_map) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Expected a map for group statement".to_string());
+    let Value::Map(group_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map in group statement".to_string());
     };
 
-    let group_name = match value_map.get("identifier") {
-        Some(Value::String(name)) => name.clone(),
-        Some(other) => {
-            return type_error(
-                &logger,
-                module,
-                stmt,
-                format!("Group name must be a string, found {:?}", other)
-            );
-        }
-        None => {
-            return type_error(&logger, module, stmt, "Group name is required".to_string());
-        }
-    };
-
-    let resolved_body = match value_map.get("body") {
-        Some(Value::Block(statements)) => {
-            let mut resolved = Vec::new();
-
-            for stmt in statements {
-                match &stmt.kind {
-                    StatementKind::Trigger { entity, duration } => {
-                        let resolved_trigger = resolve_trigger(
-                            &mut stmt.clone(),
-                            entity,
-                            &mut duration.clone(),
-                            module,
-                            path,
-                            global_store
-                        );
-
-                        resolved.push(resolved_trigger);
-                    }
-
-                    StatementKind::If => {
-                        let resolved_condition = resolve_condition(
-                            &mut stmt.clone(),
-                            module,
-                            path,
-                            global_store
-                        );
-
-                        resolved.push(resolved_condition);
-                    }
-
-                    _ => {
-                        println!("Unhandled group body statement: {:?}", stmt);
-                    }
-                }
-            }
-
-            Value::Block(resolved)
-        }
+    let mut resolved_map = group_map.clone();
 
-        Some(other) => {
-            return type_error(
-                &logger,
-                module,
-                stmt,
-                format!("Unexpected value for group body: {:?}", other)
-            );
-        }
-
-        None => {
-            return type_error(
-                &logger,
-                module,
-                stmt,
-                "Missing 'body' key in group statement".to_string()
-            );
-        }
-    };
-
-    let mut resolved_map = HashMap::new();
-    resolved_map.insert("identifier".to_string(), Value::String(group_name));
-    resolved_map.insert("body".to_string(), resolved_body);
+    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 {
+        logger.log_message(LogLevel::Warning, "group without a body");
+    }
 
     Statement {
         kind: StatementKind::Group,
@@ -106,6 +38,17 @@ pub fn resolve_group(
     }
 }
 
+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);

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()
+    }
 }

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

@@ -1,5 +1,7 @@
 pub mod driver;
 
+pub mod value;
+
 pub mod trigger;
 pub mod loop_;
 pub mod bank;
@@ -7,4 +9,6 @@ pub mod tempo;
 pub mod group;
 pub mod condition;
 pub mod spawn;
-pub mod call;
+pub mod call;
+pub mod synth;
+pub mod let_;

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

@@ -1,53 +1,58 @@
 use crate::{
     core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{
+            module::Module,
+            resolver::driver::resolve_statement,
+            resolver::value::resolve_value,
+        },
         shared::value::Value,
         store::global::GlobalStore,
     },
-    utils::logger::Logger,
+    utils::logger::{ Logger, LogLevel },
 };
 
 pub fn resolve_spawn(
     stmt: &Statement,
     module: &Module,
-    _path: &str,
-    _global_store: &GlobalStore,
+    path: &str,
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    let Value::String(name) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Spawn expects a group name as string.".to_string());
-    };
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
 
-    match module.variable_table.variables.get(name) {
-        Some(Value::Map(group_stmt)) => Statement {
-            kind: StatementKind::Spawn,
-            value: Value::Map(group_stmt.clone()),
-            ..stmt.clone()
-        },
-        Some(other) => type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Expected a group for '{}', but found {:?}", name, other),
-        ),
-        None => type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Group '{}' not found in module '{}'", name, module.path),
-        ),
-    }
-}
+    match resolved_value {
+        Value::Map(mut map) => {
+            if let Some(Value::Block(stmts)) = map.get("body") {
+                let resolved_block = stmts
+                    .iter()
+                    .map(|s| resolve_statement(s, module, path, global_store))
+                    .collect();
+                map.insert("body".to_string(), Value::Block(resolved_block));
+            }
+
+            Statement {
+                kind: StatementKind::Spawn,
+                value: Value::Map(map),
+                ..stmt.clone()
+            }
+        }
 
-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);
+        _ => {
+            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Expected a map in spawn statement\n  → at {stacktrace}")
+            );
 
-    Statement {
-        kind: StatementKind::Error { message },
-        value: Value::Null,
-        ..stmt.clone()
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Invalid spawn value".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
     }
-}
+}

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

@@ -0,0 +1,50 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn resolve_synth(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(synth_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map in synth statement".to_string());
+    };
+
+    let mut resolved_map = synth_map.clone();
+
+    if let Some(Value::Block(body)) = synth_map.get("body") {
+        let resolved_body = body.iter()
+            .map(|s| resolve_statement(s, module, path, global_store))
+            .collect::<Vec<_>>();
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    } else {
+        logger.log_message(LogLevel::Warning, "synth without a body");
+    }
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
+    }
+}
+
+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/trigger.rs

@@ -6,7 +6,6 @@ use crate::{
         preprocessor::module::Module,
         shared::{ duration::Duration, value::Value },
         store::global::GlobalStore,
-        utils::validation::is_valid_entity,
     },
     utils::logger::Logger,
 };
@@ -24,30 +23,17 @@ pub fn resolve_trigger(
     let mut final_duration = duration.clone();
     let mut final_value = stmt.value.clone();
 
-    if !is_valid_entity(entity, module, global_store) {
-        let message = format!("Invalid entity '{}', expected a valid identifier", entity);
-        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-        logger.log_error_with_stacktrace(&message, &stacktrace);
-
-        return Statement {
-            kind: stmt.kind.clone(),
-            value: Value::Null,
-            line: stmt.line,
-            column: stmt.column,
-            indent: stmt.indent,
-        };
-    }
-
+    // Duration resolution
     if let Duration::Identifier(ident) = duration {
-        if let Some(val) = module.variable_table.get(ident) {
+        if let Some(val) = resolve_identifier(ident, module, global_store) {
             match val {
-                Value::Number(num) => {
-                    final_duration = Duration::Number(*num);
+                Value::Number(n) => {
+                    final_duration = Duration::Number(n);
                 }
                 Value::String(s) => {
-                    final_duration = Duration::Identifier(s.clone());
+                    final_duration = Duration::Identifier(s);
                 }
-                Value::Identifier(id) if id == "auto" => {
+                Value::Identifier(s) if s == "auto" => {
                     final_duration = Duration::Auto;
                 }
                 _ => {}
@@ -55,50 +41,34 @@ pub fn resolve_trigger(
         }
     }
 
+    // Params value resolution
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
-            match module.variable_table.get(ident) {
-                Some(val) => val.clone(),
-                None => {
-                    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-                    let message = format!(
-                        "'{path}': value identifier '{ident}' not found in variable table"
-                    );
-                    logger.log_error_with_stacktrace(&message, &stacktrace);
-                    Value::Null
-                }
-            }
+            resolve_identifier(ident, module, global_store).unwrap_or_else(|| {
+                logger.log_error_with_stacktrace(
+                    &format!("'{path}': value identifier '{ident}' not found"),
+                    &format!("{}:{}:{}", module.path, stmt.line, stmt.column)
+                );
+                Value::Null
+            })
         }
         Value::Map(map) => {
             let mut resolved_map = HashMap::new();
-            for (k, v) in map.iter() {
-                let resolved_v = match v {
+            for (k, v) in map {
+                let resolved = match v {
                     Value::Identifier(id) => {
-                        module.variable_table.get(id).cloned().unwrap_or(Value::Null)
+                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
                     }
                     other => other.clone(),
                 };
-                resolved_map.insert(k.clone(), resolved_v);
+                resolved_map.insert(k.clone(), resolved);
             }
             Value::Map(resolved_map)
         }
         other => other.clone(),
     };
 
-    if let StatementKind::Trigger { entity, .. } = &stmt.kind {
-        return Statement {
-            kind: StatementKind::Trigger {
-                entity: entity.to_string(),
-                duration: final_duration,
-            },
-            value: final_value,
-            line: stmt.line,
-            column: stmt.column,
-            indent: stmt.indent,
-        };
-    }
-
-    return Statement {
+    Statement {
         kind: StatementKind::Trigger {
             entity: entity.to_string(),
             duration: final_duration,
@@ -107,5 +77,36 @@ pub fn resolve_trigger(
         line: stmt.line,
         column: stmt.column,
         indent: stmt.indent,
-    };
+    }
+}
+
+fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore) -> Option<Value> {
+    if let Some(val) = module.variable_table.get(ident) {
+        return Some(resolve_value(val, module, global_store));
+    }
+
+    for (_, other_mod) in &global_store.modules {
+        if let Some(val) = other_mod.export_table.get_export(ident) {
+            return Some(resolve_value(val, other_mod, global_store));
+        }
+    }
+
+    None
+}
+
+fn resolve_value(val: &Value, module: &Module, global_store: &GlobalStore) -> Value {
+    match val {
+        Value::Identifier(inner) =>
+            resolve_identifier(inner, module, global_store).unwrap_or(
+                Value::Identifier(inner.clone())
+            ),
+        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)
+        }
+        other => other.clone(),
+    }
 }