@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.10

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/tempo.rs

@@ -1,70 +1,49 @@
-use crate::core::types::{module::Module, statement::{Statement, StatementKind, StatementResolved, StatementResolvedValue}, variable::VariableValue};
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
 
-pub fn resolve_tempo_statement(
-    tempo_statement: &Statement,
-    module: &Module
-) -> StatementResolved {
-    match &tempo_statement.value {
-        VariableValue::Number(num) => {
-            if *num > 0.0 {
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Number(*num),
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
+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 {
-                eprintln!("⚠️ Invalid tempo value: {}", num);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
+                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;
             }
         }
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let variable_value: StatementResolvedValue = match value {
-                    VariableValue::Number(num) if *num > 0.0 => {
-                        StatementResolvedValue::Number(*num)
-                    }
-                    VariableValue::Text(t) => StatementResolvedValue::String(t.clone()),
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Tempo: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
 
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: variable_value,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            } else {
-                eprintln!("⚠️ Tempo variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            }
+        Value::Number(_) => {
+            // Already resolved, no modification needed
         }
-        _ => {
-            eprintln!("⚠️ Invalid value type for Tempo statement: {:?}", tempo_statement.value);
-            StatementResolved {
-                kind: StatementKind::Tempo,
-                value: StatementResolvedValue::Unknown,
-                indent: tempo_statement.indent,
-                line: tempo_statement.line,
-                column: tempo_statement.column,
-            }
+
+        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,176 +1,112 @@
 use std::collections::HashMap;
 
-use crate::core::{
-    parser::parse_with_resolving_with_module,
-    types::{
-        module::Module,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        token::{ TokenDuration, TokenParamValue },
-        variable::VariableValue,
+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_statement(
+pub fn resolve_trigger(
     stmt: &Statement,
-    entity: String,
-    duration: TokenDuration,
-    module: &Module
-) -> StatementResolved {
-    let mut entity_value = VariableValue::Unknown;
-
-    if let Some(value) = module.variable_table.variables.get(&entity) {
-        entity_value = value.clone();
-    } else {
-        entity_value = VariableValue::Text(entity.clone());
-    }
-
-    let duration_raw_value = match duration {
-        TokenDuration::Auto => "auto",
-        TokenDuration::Infinite => "infinite",
-        TokenDuration::Number(n) => &n.to_string(),
-        TokenDuration::Identifier(ref id) => id.as_str(),
-        _ => "unknown",
-    };
-
-    let duration_variable_value = module.variable_table.variables.get(duration_raw_value);
-    let mut parsed_duration_value = TokenDuration::Unknown;
-
-    if duration_variable_value.is_some() {
-        parsed_duration_value = duration_variable_value
-            .as_ref()
-            .map_or(TokenDuration::Unknown, |value| {
-                match value {
-                    VariableValue::Text(text) => TokenDuration::Identifier(text.clone()),
-                    VariableValue::Number(num) => TokenDuration::Number(*num),
-                    VariableValue::Boolean(_) => TokenDuration::Unknown,
-                    _ => {
-                        eprintln!("⚠️ Invalid duration type for Trigger: {:?}", value);
-                        TokenDuration::Unknown
-                    }
+    entity: &str,
+    duration: &mut Duration,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+    let mut final_value = stmt.value.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);
                 }
-            });
-    } else if let Ok(num) = duration_raw_value.parse::<f32>() {
-        parsed_duration_value = TokenDuration::Number(num);
-    } else if duration_raw_value == "auto" {
-        parsed_duration_value = TokenDuration::Auto;
-    } else if duration_raw_value == "infinite" {
-        parsed_duration_value = TokenDuration::Infinite;
-    } else {
-        eprintln!("⚠️ Invalid duration format: {}", duration_raw_value);
-    }
-
-    match &stmt.value {
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let parsed_entity_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Map(map) => {
-                        let mut resolved_map = HashMap::new();
-
-                        for (key, value) in map {
-                            let resolved_value = match value {
-                                TokenParamValue::String(text) =>
-                                    StatementResolvedValue::String(text.clone()),
-                                TokenParamValue::Number(num) =>
-                                    StatementResolvedValue::Number(*num),
-                                TokenParamValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                                _ => {
-                                    eprintln!(
-                                        "⚠️ Unsupported variable type for Trigger map: {:?}",
-                                        value
-                                    );
-                                    StatementResolvedValue::Unknown
-                                }
-                            };
-                            resolved_map.insert(key.clone(), resolved_value);
-                        }
-
-                        StatementResolvedValue::Map(resolved_map)
-                    }
-
-                    | VariableValue::Text(_)
-                    | VariableValue::Number(_)
-                    | VariableValue::Boolean(_) => {
-                        StatementResolvedValue::String(text.clone())
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Trigger entity: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: parsed_entity_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s);
                 }
-            } else {
-                eprintln!("⚠️ Trigger variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::Identifier(s) if s == "auto" => {
+                    final_duration = Duration::Auto;
                 }
+                _ => {}
             }
         }
-        VariableValue::Map(map) => {
-            let mut resolved_map = HashMap::new();
-
-            // TODO Handle nested maps and arrays
+    }
 
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(resolved_map),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
+    // Params value resolution
+    final_value = match &stmt.value {
+        Value::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
+            })
         }
-        VariableValue::Null => {
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(HashMap::new()),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+        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(),
+    };
 
-        // TODO Parse other parameters
+    Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration,
+        },
+        value: final_value,
+        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));
+    }
 
-        _ => {
-            eprintln!("⚠️ Invalid value type for Trigger statement: {:?}", stmt.value);
+    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
+}
 
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+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

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::{ global::GlobalStore, variable::VariableTable },
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+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::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) => {
+            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

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

package/rust/core/shared/mod.rs

@@ -0,0 +1,2 @@
+pub mod value;
+pub mod duration;

package/rust/core/shared/value.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+use serde::{ Deserialize, Serialize };
+
+use crate::core::parser::statement::Statement;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Unknown,
+    Null,
+}
+
+impl Value {
+    pub fn get(&self, key: &str) -> Option<&Value> {
+        if let Value::Map(map) = self {
+            map.get(key)
+        } else {
+            None
+        }
+    }
+}

package/rust/core/store/export.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -0,0 +1,39 @@
+use std::collections::HashMap;
+use crate::core::preprocessor::module::Module;
+
+#[derive(Debug, Default, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+        }
+    }
+
+    pub fn resolve_all_imports(&mut self) {
+        for module in self.modules.values_mut() {
+            for (name, source_path) in &module.import_table.imports {
+                println!("Resolving import: {} from {:?}", name, source_path);
+            }
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
+        &mut self.modules
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+}

package/rust/core/store/import.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}

package/rust/core/store/mod.rs

@@ -0,0 +1,4 @@
+pub mod global;
+pub mod export;
+pub mod import;
+pub mod variable;