@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.1

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

@@ -0,0 +1,83 @@
+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
+        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,58 +1,99 @@
-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()
-            }
-        }
-    }
-}
+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,50 +1,54 @@
-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},
+    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,49 +1,48 @@
-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,
+    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
+}