@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,318 +0,0 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::{
-        module::Module,
-        resolver::{driver::resolve_statement, value::resolve_value},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::Logger;
-
-pub fn resolve_loop(
-    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);
-
-    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<String, Value> = HashMap::new();
-    for (key, val) in value_map {
-        resolved_map.insert(key.clone(), resolve_value(val, module, global_store));
-    }
-
-    // Foreach form takes precedence if present
-    if let (Some(Value::Identifier(var_name)), Some(array_val)) =
-        (resolved_map.get("foreach"), resolved_map.get("array"))
-    {
-        // Normalize array_val into an iterable Array
-        let resolved_array = match array_val {
-            Value::Array(items) => Value::Array(
-                items
-                    .iter()
-                    .map(|v| resolve_value(v, module, global_store))
-                    .collect(),
-            ),
-            Value::Number(n) => {
-                // Iterate 0..n-1
-                let count = (*n).max(0.0) as usize;
-                let mut items = Vec::with_capacity(count);
-                for i in 0..count {
-                    items.push(Value::Number(i as f32));
-                }
-                Value::Array(items)
-            }
-            Value::String(s) => {
-                // Try to parse a simple comma-separated list: "a,b,c" -> ["a","b","c"]
-                // If numeric string: iterate 0..n-1
-                if let Ok(n) = s.parse::<f32>() {
-                    let count = n.max(0.0) as usize;
-                    let mut items = Vec::with_capacity(count);
-                    for i in 0..count {
-                        items.push(Value::Number(i as f32));
-                    }
-                    Value::Array(items)
-                } else if s.contains(',') {
-                    let parts: Vec<Value> = s
-                        .split(',')
-                        .map(|p| Value::String(p.trim().to_string()))
-                        .collect();
-                    Value::Array(parts)
-                } else {
-                    // Fallback: iterate characters
-                    let parts: Vec<Value> =
-                        s.chars().map(|c| Value::String(c.to_string())).collect();
-                    Value::Array(parts)
-                }
-            }
-            Value::Identifier(name) => {
-                // Resolve identifier from module variables (already resolved map above)
-                let v = if let Some(v) = module.variable_table.get(name) {
-                    v.clone()
-                } else {
-                    Value::Null
-                };
-                match v {
-                    Value::Array(items) => Value::Array(
-                        items
-                            .iter()
-                            .map(|v| resolve_value(v, module, global_store))
-                            .collect(),
-                    ),
-                    Value::Number(n) => {
-                        let count = n.max(0.0) as usize;
-                        let mut items = Vec::with_capacity(count);
-                        for i in 0..count {
-                            items.push(Value::Number(i as f32));
-                        }
-                        Value::Array(items)
-                    }
-                    Value::String(s) => {
-                        if let Ok(n) = s.parse::<f32>() {
-                            let count = n.max(0.0) as usize;
-                            let mut items = Vec::with_capacity(count);
-                            for i in 0..count {
-                                items.push(Value::Number(i as f32));
-                            }
-                            Value::Array(items)
-                        } else if s.contains(',') {
-                            let parts: Vec<Value> = s
-                                .split(',')
-                                .map(|p| Value::String(p.trim().to_string()))
-                                .collect();
-                            Value::Array(parts)
-                        } else {
-                            let parts: Vec<Value> =
-                                s.chars().map(|c| Value::String(c.to_string())).collect();
-                            Value::Array(parts)
-                        }
-                    }
-                    other => {
-                        error_value(
-                            &logger,
-                            module,
-                            stmt,
-                            &format!(
-                                "Foreach identifier '{}' resolves to unsupported value: {:?}",
-                                name, other
-                            ),
-                        );
-                        Value::Array(vec![])
-                    }
-                }
-            }
-            other => {
-                // Resolve and normalize if possible
-                let v = resolve_value(other, module, global_store);
-                match v {
-                    Value::Array(items) => Value::Array(items),
-                    Value::Number(n) => {
-                        let count = n.max(0.0) as usize;
-                        let mut items = Vec::with_capacity(count);
-                        for i in 0..count {
-                            items.push(Value::Number(i as f32));
-                        }
-                        Value::Array(items)
-                    }
-                    Value::String(s) => {
-                        if let Ok(n) = s.parse::<f32>() {
-                            let count = n.max(0.0) as usize;
-                            let mut items = Vec::with_capacity(count);
-                            for i in 0..count {
-                                items.push(Value::Number(i as f32));
-                            }
-                            Value::Array(items)
-                        } else if s.contains(',') {
-                            let parts: Vec<Value> = s
-                                .split(',')
-                                .map(|p| Value::String(p.trim().to_string()))
-                                .collect();
-                            Value::Array(parts)
-                        } else {
-                            let parts: Vec<Value> =
-                                s.chars().map(|c| Value::String(c.to_string())).collect();
-                            Value::Array(parts)
-                        }
-                    }
-                    other => {
-                        error_value(
-                            &logger,
-                            module,
-                            stmt,
-                            &format!("Unsupported foreach array value: {:?}", other),
-                        );
-                        Value::Array(vec![])
-                    }
-                }
-            }
-        };
-
-        let body_value = match resolved_map.get("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("foreach".to_string(), Value::Identifier(var_name.clone()));
-        final_map.insert("array".to_string(), resolved_array);
-        final_map.insert("body".to_string(), body_value);
-
-        return Statement {
-            kind: StatementKind::Loop,
-            value: Value::Map(final_map),
-            ..stmt.clone()
-        };
-    }
-
-    let iterator_value = match resolved_map.get("iterator") {
-        Some(Value::Number(n)) => Value::Number(*n),
-        Some(Value::String(s)) => {
-            if let Ok(n) = s.parse::<f32>() {
-                Value::Number(n)
-            } else {
-                error_value(
-                    &logger,
-                    module,
-                    stmt,
-                    &format!("Loop iterator string not numeric: '{}'", s),
-                );
-                Value::Number(1.0)
-            }
-        }
-        Some(Value::Identifier(name)) => {
-            // Try resolving from module vars (may be number or numeric string)
-            if let Some(v) = module.variable_table.get(name) {
-                match v {
-                    Value::Number(n) => Value::Number(*n),
-                    Value::String(s) => {
-                        if let Ok(n) = s.parse::<f32>() {
-                            Value::Number(n)
-                        } else {
-                            error_value(
-                                &logger,
-                                module,
-                                stmt,
-                                &format!(
-                                    "Loop iterator '{}' resolves to non-numeric string: '{}'",
-                                    name, s
-                                ),
-                            );
-                            Value::Number(1.0)
-                        }
-                    }
-                    other => {
-                        error_value(
-                            &logger,
-                            module,
-                            stmt,
-                            &format!(
-                                "Loop iterator '{}' resolves to non-number: {:?}",
-                                name, other
-                            ),
-                        );
-                        Value::Number(1.0)
-                    }
-                }
-            } else {
-                error_value(
-                    &logger,
-                    module,
-                    stmt,
-                    &format!("Loop iterator identifier '{}' not found", name),
-                );
-                Value::Number(1.0)
-            }
-        }
-        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)
-        }
-    };
-
-    let body_value = match resolved_map.get("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 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,16 +0,0 @@
-pub mod driver;
-
-pub mod value;
-
-pub mod bank;
-pub mod call;
-pub mod condition;
-pub mod function;
-pub mod group;
-pub mod let_;
-pub mod loop_;
-pub mod pattern;
-pub mod spawn;
-pub mod synth;
-pub mod tempo;
-pub mod trigger;

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

@@ -1,95 +0,0 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-pub fn resolve_pattern(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    // Expecting pattern name stored on the Statement.kind; value may contain the string
-    if let StatementKind::Pattern { name, target } = &stmt.kind {
-        // Ensure name doesn't already exist
-        if global_store.variables.variables.contains_key(name) {
-            logger.log_error_with_stacktrace(
-                &format!("Pattern identifier '{}' already exists", name),
-                path,
-            );
-            return Statement {
-                kind: StatementKind::Error {
-                    message: format!("Pattern '{}' already exists", name),
-                },
-                ..stmt.clone()
-            };
-        }
-
-        // Resolve potential target and pattern string value
-        let resolved_value = resolve_value(&stmt.value, module, global_store);
-
-        // Build a map to store the pattern definition
-        let mut map = std::collections::HashMap::new();
-        map.insert("identifier".to_string(), Value::String(name.clone()));
-        if let Some(t) = target {
-            map.insert("target".to_string(), Value::String(t.clone()));
-        }
-        // Keep raw pattern in 'pattern' key if it's a string, or merge options map
-        match resolved_value.clone() {
-            Value::String(s) => {
-                map.insert("pattern".to_string(), Value::String(s));
-            }
-            Value::Map(m) => {
-                for (k, v) in m {
-                    map.insert(k, v);
-                }
-            }
-            _ => {
-                map.insert("pattern".to_string(), resolved_value.clone());
-            }
-        }
-
-        let resolved_stmt = Statement {
-            kind: StatementKind::Pattern {
-                name: name.clone(),
-                target: target.clone(),
-            },
-            value: resolved_value,
-            ..stmt.clone()
-        };
-
-        // Store into global variables as a Statement
-        global_store.variables.variables.insert(
-            name.clone(),
-            Value::Statement(Box::new(resolved_stmt.clone())),
-        );
-
-        return resolved_stmt;
-    }
-
-    logger.log_message(
-        LogLevel::Warning,
-        "resolve_pattern called on non-pattern statement",
-    );
-    stmt.clone()
-}
-
-fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
-    // reuse driver::resolve_value logic; simple local resolution for pattern value
-    match value {
-        Value::String(s) => Value::String(s.clone()),
-        Value::Map(m) => {
-            let mut resolved = std::collections::HashMap::new();
-            for (k, v) in m {
-                resolved.insert(k.clone(), resolve_value(v, module, global_store));
-            }
-            Value::Map(resolved)
-        }
-        other => other.clone(),
-    }
-}

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

@@ -1,99 +0,0 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-pub fn resolve_spawn(
-    stmt: &Statement,
-    name: String,
-    args: Vec<Value>,
-    module: &Module,
-    _path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    // If it's a function
-    if let Some(func) = global_store.functions.functions.get(&name) {
-        let mut resolved_map = std::collections::HashMap::new();
-        resolved_map.insert("name".to_string(), Value::String(name.clone()));
-        resolved_map.insert("args".to_string(), Value::Array(args.clone()));
-        resolved_map.insert("body".to_string(), Value::Block(func.body.clone()));
-
-        return Statement {
-            kind: StatementKind::Spawn { name, args },
-            value: Value::Map(resolved_map),
-            ..stmt.clone()
-        };
-    }
-
-    // If it's a group stored in variables
-    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(&name) {
-        if let StatementKind::Group = stmt_box.kind {
-            if let Value::Map(map) = &stmt_box.value {
-                if let Some(Value::Block(body)) = map.get("body") {
-                    let mut resolved_map = std::collections::HashMap::new();
-                    resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
-                    resolved_map.insert("args".to_string(), Value::Array(args.clone()));
-                    resolved_map.insert("body".to_string(), Value::Block(body.clone()));
-
-                    return Statement {
-                        kind: StatementKind::Spawn { name, args },
-                        value: Value::Map(resolved_map),
-                        ..stmt.clone()
-                    };
-                }
-            }
-        }
-        // Pattern case (make spawn accept patterns stored as variables)
-        if let StatementKind::Pattern { .. } = stmt_box.kind {
-            let mut resolved_map = std::collections::HashMap::new();
-            resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
-            // pattern value may be a string or a map stored on the statement
-            match &stmt_box.value {
-                Value::String(s) => {
-                    resolved_map.insert("pattern".to_string(), Value::String(s.clone()));
-                }
-                Value::Map(m) => {
-                    if let Some(val) = m.get("pattern") {
-                        resolved_map.insert("pattern".to_string(), val.clone());
-                    }
-                    if let Some(val) = m.get("target") {
-                        resolved_map.insert("target".to_string(), val.clone());
-                    }
-                }
-                _ => {}
-            }
-            resolved_map.insert("args".to_string(), Value::Array(args.clone()));
-
-            return Statement {
-                kind: StatementKind::Spawn { name, args },
-                value: Value::Map(resolved_map),
-                ..stmt.clone()
-            };
-        }
-    }
-
-    // Otherwise, log an error
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(
-        LogLevel::Error,
-        &format!(
-            "Function or group '{}' not found for spawn\n  → at {stacktrace}",
-            name
-        ),
-    );
-
-    Statement {
-        kind: StatementKind::Error {
-            message: format!("Function or group '{}' not found for spawn", name),
-        },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
-
-// (removed unused helpers get_group_body, error_stmt)

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

@@ -1,54 +0,0 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::{module::Module, resolver::driver::resolve_statement},
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_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,48 +0,0 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_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
-}