@devaloop/devalang 0.0.1-alpha.15 → 0.0.1-alpha.16

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

@@ -1,50 +1,56 @@
-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()
-    }
-}
+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/tempo.rs

@@ -1,49 +1,50 @@
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_tempo(
-    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!("Tempo identifier '{ident}' not found in variable table");
-                logger.log_error_with_stacktrace(&message, &module.path);
-                new_stmt.kind = StatementKind::Error {
-                    message,
-                };
-                new_stmt.value = Value::Null;
-            }
-        }
-
-        Value::Number(_) => {
-            // Already resolved, no modification needed
-        }
-
-        other => {
-            let message = format!("Expected a number or identifier for tempo, found {:?}", other);
-            logger.log_error_with_stacktrace(&message, &module.path);
-            new_stmt.kind = StatementKind::Error {
-                message: "Expected a number or identifier for tempo".to_string(),
-            };
-            new_stmt.value = Value::Null;
-        }
-    }
-
-    new_stmt
-}
+use crate::{
+    core::{
+        parser::statement::{Statement, StatementKind},
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_tempo(
+    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!("Tempo identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error { message };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::Number(_) => {
+            // Already resolved, no modification needed
+        }
+
+        other => {
+            let message = format!(
+                "Expected a number or identifier for tempo, found {:?}",
+                other
+            );
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a number or identifier for tempo".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

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

@@ -1,115 +1,113 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::module::Module,
-        shared::{ duration::Duration, value::Value },
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_trigger(
-    stmt: &Statement,
-    entity: &str,
-    duration: &mut Duration,
-    _effects: Option<Value>,
-    module: &Module,
-    path: &str,
-    global_store: &GlobalStore
-) -> Statement {
-    let logger = Logger::new();
-
-    let mut final_duration = duration.clone();
-
-    // Duration resolution
-    if let Duration::Identifier(ident) = duration {
-        if let Some(val) = resolve_identifier(ident, module, global_store) {
-            match val {
-                Value::Number(n) => {
-                    final_duration = Duration::Number(n);
-                }
-                Value::String(s) => {
-                    final_duration = Duration::Identifier(s);
-                }
-                Value::Identifier(s) if s == "auto" => {
-                    final_duration = Duration::Auto;
-                }
-                _ => {}
-            }
-        }
-    }
-
-    // Params value resolution
-    let final_value = match &stmt.value {
-        Value::Identifier(ident) => {
-            println!("Resolving identifier: {}", ident);
-
-            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 {
-                let resolved = match v {
-                    Value::Identifier(id) => {
-                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
-                    }
-                    other => other.clone(),
-                };
-                resolved_map.insert(k.clone(), resolved);
-            }
-            Value::Map(resolved_map)
-        }
-        other => other.clone(),
-    };
-
-    Statement {
-        kind: StatementKind::Trigger {
-            entity: entity.to_string(),
-            duration: final_duration.clone(),
-            effects: Some(final_value.clone()),
-        },
-        value: Value::Null,
-        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.variable_table.get(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(),
-    }
-}
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{Statement, StatementKind},
+        preprocessor::module::Module,
+        shared::{duration::Duration, value::Value},
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_trigger(
+    stmt: &Statement,
+    entity: &str,
+    duration: &mut Duration,
+    _effects: Option<Value>,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+
+    // Duration resolution
+    if let Duration::Identifier(ident) = duration {
+        if let Some(val) = resolve_identifier(ident, module, global_store) {
+            match val {
+                Value::Number(n) => {
+                    final_duration = Duration::Number(n);
+                }
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s);
+                }
+                Value::Identifier(s) if s == "auto" => {
+                    final_duration = Duration::Auto;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Params value resolution
+    let final_value = match &stmt.value {
+        Value::Identifier(ident) => {
+            println!("Resolving identifier: {}", ident);
+
+            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 {
+                let resolved = match v {
+                    Value::Identifier(id) => {
+                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved);
+            }
+            Value::Map(resolved_map)
+        }
+        other => other.clone(),
+    };
+
+    Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration.clone(),
+            effects: Some(final_value.clone()),
+        },
+        value: Value::Null,
+        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.variable_table.get(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(),
+    }
+}

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

@@ -1,81 +1,81 @@
-use std::collections::HashMap;
-
-use crate::core::{
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
-        shared::value::Value,
-        store::global::GlobalStore,
-    };
-
-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_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
-    match value {
-        Value::String(s) => {
-            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
-            Value::String(s.clone())
-        },
-
-        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);
-            }
-
-            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
-            Value::Identifier(name.clone())
-        }
-
-        Value::Map(map) => {
-            if let Some(Value::Identifier(entity)) = map.get("entity") {
-                // SECTION Synth
-                if entity == "synth" {
-                    if let Some(Value::Map(synth_data)) = map.get("value") {
-                        let resolved_waveform = synth_data
-                            .get("waveform")
-                            .map(|wf| resolve_value(wf, module, global_store))
-                            .unwrap_or(Value::Null);
-
-                        let resolved_params = synth_data
-                            .get("parameters")
-                            .map(|p| resolve_value(p, module, global_store))
-                            .unwrap_or(Value::Map(HashMap::new()));
-
-                        let mut result = HashMap::new();
-                        result.insert("waveform".to_string(), resolved_waveform);
-                        result.insert("parameters".to_string(), resolved_params);
-
-                        return Value::Map(result);
-                    }
-                }
-            }
-
-            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(),
-    }
-}
+use std::collections::HashMap;
+
+use crate::core::{
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+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_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::String(s) => {
+            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
+            Value::String(s.clone())
+        }
+
+        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);
+            }
+
+            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
+            Value::Identifier(name.clone())
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::Identifier(entity)) = map.get("entity") {
+                // SECTION Synth
+                if entity == "synth" {
+                    if let Some(Value::Map(synth_data)) = map.get("value") {
+                        let resolved_waveform = synth_data
+                            .get("waveform")
+                            .map(|wf| resolve_value(wf, module, global_store))
+                            .unwrap_or(Value::Null);
+
+                        let resolved_params = synth_data
+                            .get("parameters")
+                            .map(|p| resolve_value(p, module, global_store))
+                            .unwrap_or(Value::Map(HashMap::new()));
+
+                        let mut result = HashMap::new();
+                        result.insert("waveform".to_string(), resolved_waveform);
+                        result.insert("parameters".to_string(), resolved_params);
+
+                        return Value::Map(result);
+                    }
+                }
+            }
+
+            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(),
+    }
+}

package/rust/core/shared/duration.rs

@@ -1,9 +1,9 @@
-use serde::{ Deserialize, Serialize };
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum Duration {
-    Number(f32),
-    Identifier(String),
-    Beat(String),
-    Auto,
-}
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum Duration {
+    Number(f32),
+    Identifier(String),
+    Beat(String),
+    Auto,
+}

package/rust/core/shared/mod.rs

@@ -1,3 +1,3 @@
-pub mod value;
-pub mod duration;
-pub mod bank;
+pub mod bank;
+pub mod duration;
+pub mod value;