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

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

@@ -1,82 +1,91 @@
-use crate::core::{
-    parser::parse_without_resolving_with_module,
-    preprocessor::resolver::resolve_statement,
-    types::{
-        module::Module,
-        statement::{
-            Statement,
-            StatementIterator,
-            StatementKind,
-            StatementResolved,
-            StatementResolvedValue,
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{
+            module::Module,
+            resolver::{ driver::resolve_statement, value::resolve_value },
         },
-        variable::VariableValue,
+        shared::value::Value,
+        store::global::GlobalStore,
     },
+    utils::logger::Logger,
 };
 
-pub fn resolve_loop_statement(
-    loop_statement: &Statement,
-    iterator: StatementIterator,
-    module: &Module
-) -> StatementResolved {
-    let mut resolved_iterator = StatementIterator::Unknown;
+pub fn resolve_loop(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let logger = Logger::new();
 
-    match iterator.clone() {
-        StatementIterator::Identifier(id) => {
-            if let Some(value) = module.variable_table.variables.get(&id) {
-                match value {
-                    VariableValue::Array(arr) => {
-                        resolved_iterator = StatementIterator::Array(
-                            parse_without_resolving_with_module(arr.clone(), module)
-                        );
-                    }
-                    VariableValue::Number(num) => {
-                        resolved_iterator = StatementIterator::Number(*num);
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for loop iterator: {:?}", value);
-                        resolved_iterator = StatementIterator::Unknown;
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Loop iterator variable '{}' not found", id);
-                resolved_iterator = StatementIterator::Unknown;
-            }
-        }
-        StatementIterator::Number(num) => {
-            resolved_iterator = StatementIterator::Number(num);
-        }
-        _ => {
-            resolved_iterator = iterator.clone();
-        }
-    }
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
 
-    let mut resolved_body: StatementResolvedValue = StatementResolvedValue::Unknown;
-
-    match &loop_statement.value {
-        VariableValue::Array(arr) => {
-            let raw_statements = parse_without_resolving_with_module(arr.clone(), &module.clone());
+    let Value::Map(value_map) = &resolved_value else {
+        return error_stmt(&logger, module, stmt, "Expected a map for loop value");
+    };
 
-            let mut resolved_statements = Vec::new();
+    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));
+    }
 
-            for raw_stmt in raw_statements {
-                let resolved_stmt = resolve_statement(&raw_stmt, &mut module.clone());
-                resolved_statements.push(resolved_stmt);
-            }
+    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)
+        }
+    };
 
-            resolved_body = StatementResolvedValue::Array(resolved_statements);
+    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)
         }
         _ => {
-            resolved_body = StatementResolvedValue::Unknown;
-            eprintln!("⚠️ Unsupported value type for loop body: {:?}", loop_statement.value);
+            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()
     }
+}
 
-    return StatementResolved {
-        kind: StatementKind::Loop { iterator: resolved_iterator },
-        value: resolved_body,
-        indent: loop_statement.indent,
-        line: loop_statement.line,
-        column: loop_statement.column,
-    };
+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(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,113 +1,14 @@
-pub mod bank;
-pub mod loop_;
-pub mod tempo;
-pub mod trigger;
-pub mod at;
-
-use crate::core::{
-    preprocessor::resolver::{
-        bank::resolve_bank_statement,
-        loop_::resolve_loop_statement,
-        tempo::resolve_tempo_statement,
-        trigger::resolve_trigger_statement,
-        at::{ resolve_load_statement },
-    },
-    types::{
-        module::Module,
-        parser::Parser,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        store::{ ExportTable, GlobalStore, ImportTable },
-        variable::VariableValue,
-    },
-};
-
-pub fn resolve_exports(statements: &[Statement], parser: &Parser) -> ExportTable {
-    let mut export_table = parser.export_table.clone();
-
-    for stmt in statements {
-        if let StatementKind::Export = &stmt.kind {
-            if let VariableValue::Array(tokens) = &stmt.value {
-                for token in tokens {
-                    let var_name = &token.lexeme;
-                    if let Some(value) = parser.variable_table.variables.get(var_name) {
-                        export_table.add_export(var_name.clone(), value.clone());
-                    } else {
-                        eprintln!("⚠️ Variable '{}' not found in scope, export skipped", var_name);
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Unexpected value type in export: {:?}", stmt.value);
-            }
-        }
-    }
-
-    export_table
-}
-
-pub fn resolve_imports(module: &mut Module, global_store: &GlobalStore) -> ImportTable {
-    let mut import_table = ImportTable::default();
-
-    for stmt in &module.statements {
-        if let StatementKind::Import { names, source } = &stmt.kind {
-            if let Some(from_module) = global_store.modules.get(source) {
-                for name in names {
-                    if let Some(value) = from_module.export_table.exports.get(name) {
-                        module.variable_table.variables.insert(name.clone(), value.clone());
-                        import_table.add_import(name.clone(), value.clone());
-                    } else {
-                        eprintln!("⚠️ '{}' not found in exports of '{}'", name, source);
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Module '{}' not found", source);
-            }
-        }
-    }
-
-    import_table
-}
+pub mod driver;
 
-pub fn resolve_statement(stmt: &Statement, module: &mut Module) -> StatementResolved {
-    match &stmt.kind {
-        StatementKind::Loop { iterator } => {
-            resolve_loop_statement(stmt, iterator.clone(), module)
-        }
+pub mod value;
 
-        StatementKind::Trigger { entity, duration } => {
-            resolve_trigger_statement(stmt, entity.clone(), duration.clone(), module)
-        }
-
-        StatementKind::Bank { .. } => { resolve_bank_statement(stmt, module) }
-
-        StatementKind::Tempo { .. } => { resolve_tempo_statement(stmt, module) }
-
-        StatementKind::Load { source, alias } => {
-            resolve_load_statement(stmt, source, alias, module)
-        }
-
-        // TODO Handle other statement kinds
-
-        StatementKind::Error => {
-            StatementResolved {
-                kind: StatementKind::Error,
-                value: match stmt.value {
-                    VariableValue::Text(ref msg) => StatementResolvedValue::String(msg.clone()),
-                    _ => StatementResolvedValue::Unknown,
-                },
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-
-        _ => {
-            StatementResolved {
-                kind: StatementKind::Unknown,
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-    }
-}
+pub mod trigger;
+pub mod loop_;
+pub mod bank;
+pub mod tempo;
+pub mod group;
+pub mod condition;
+pub mod spawn;
+pub mod call;
+pub mod synth;
+pub mod let_;

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

@@ -0,0 +1,58 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{
+            module::Module,
+            resolver::driver::resolve_statement,
+            resolver::value::resolve_value,
+        },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ Logger, LogLevel },
+};
+
+pub fn resolve_spawn(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    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()
+            }
+        }
+
+        _ => {
+            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: "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/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
 }