@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+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_call(
     stmt: &Statement,
@@ -44,25 +42,51 @@ pub fn resolve_call(
             }
 
             // Otherwise, check if it's a variable (e.g. group)
-            if let Some(variable) = global_store.variables.variables.get(&name) {
-                if let Value::Statement(stmt_box) = variable {
-                    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()));
+            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::Call { name, args },
-                                    value: Value::Map(resolved_map),
-                                    ..stmt.clone()
-                                };
+                            return Statement {
+                                kind: StatementKind::Call { name, args },
+                                value: Value::Map(resolved_map),
+                                ..stmt.clone()
+                            };
+                        }
+                    }
+                }
+                // Pattern case
+                if let StatementKind::Pattern { .. } = stmt_box.kind {
+                    // pattern value may be a string or a map stored on the statement
+                    let mut resolved_map = std::collections::HashMap::new();
+                    resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
+                    // pattern value
+                    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::Call { name, args },
+                        value: Value::Map(resolved_map),
+                        ..stmt.clone()
+                    };
                 }
             }
 

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+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::Logger;
 
 pub fn resolve_condition(
     stmt: &Statement,

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

@@ -1,21 +1,20 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{
-            loader::ModuleLoader,
-            module::Module,
-            resolver::{
-                bank::resolve_bank, call::resolve_call, condition::resolve_condition,
-                function::resolve_function, group::resolve_group, let_::resolve_let,
-                loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo,
-                trigger::resolve_trigger,
-            },
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        loader::ModuleLoader,
+        module::Module,
+        resolver::{
+            bank::resolve_bank, call::resolve_call, condition::resolve_condition,
+        function::resolve_function, group::resolve_group, pattern::resolve_pattern, let_::resolve_let,
+            loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo,
+            trigger::resolve_trigger,
         },
-        shared::value::Value,
-        store::global::GlobalStore,
     },
-    utils::logger::Logger,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
+use devalang_utils::logger::LogLevel;
 use std::collections::HashMap;
 
 pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
@@ -68,7 +67,8 @@ pub fn resolve_statement(
             global_store,
         ),
         StatementKind::If => resolve_condition(stmt, module, path, global_store),
-        StatementKind::Group => resolve_group(stmt, module, path, global_store),
+                StatementKind::Group => resolve_group(stmt, module, path, global_store),
+                StatementKind::Pattern { .. } => resolve_pattern(stmt, module, path, global_store),
         StatementKind::Call { name, args } => {
             resolve_call(stmt, name.clone(), args.clone(), module, path, global_store)
         }
@@ -92,6 +92,7 @@ pub fn resolve_statement(
 }
 
 fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    let logger = Logger::new();
     match value {
         Value::Identifier(name) => {
             if let Some(original_val) = module.variable_table.get(name) {
@@ -109,7 +110,7 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
         Value::String(s) => Value::String(s.clone()),
 
         Value::Beat(beat_str) => {
-            println!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str);
+            logger.log_message(LogLevel::Warning, &format!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str));
             Value::Beat(beat_str.clone())
         }
 
@@ -134,7 +135,7 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
 }
 
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for (_path, module) in &global_store.modules {
+    for module in global_store.modules.values() {
         if let Some(val) = module.export_table.get_export(name) {
             return Some(val.clone());
         }
@@ -143,6 +144,7 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
 }
 
 pub fn resolve_imports(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    let logger = Logger::new();
     for (module_path, module) in global_store.clone().modules.iter_mut() {
         for (name, source_path) in &module.import_table.imports {
             match source_path {
@@ -151,21 +153,14 @@ pub fn resolve_imports(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                         if let Some(value) = source_module.export_table.get_export(name) {
                             module.variable_table.set(name.clone(), value.clone());
                         } else {
-                            println!(
-                                "[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"
-                            );
+                            logger.log_message(LogLevel::Warning, &format!("[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"));
                         }
                     } else {
-                        println!(
-                            "[warn] '{module_path}': cannot find source module '{source_path}'"
-                        );
+                        logger.log_message(LogLevel::Warning, &format!("[warn] '{module_path}': cannot find source module '{source_path}'"));
                     }
                 }
                 _ => {
-                    println!(
-                        "[warn] '{module_path}': expected string for import source, found {:?}",
-                        source_path
-                    );
+                    logger.log_message(LogLevel::Warning, &format!("[warn] '{module_path}': expected string for import source, found {:?}", source_path));
                 }
             }
         }
@@ -288,6 +283,11 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(resolved_stmt);
                 }
 
+                StatementKind::Pattern { .. } => {
+                    let resolved_stmt = resolve_pattern(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
                 StatementKind::Function {
                     name: _,
                     parameters: _,

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

@@ -1,9 +1,9 @@
 use crate::core::{
     parser::statement::{Statement, StatementKind},
     preprocessor::{module::Module, resolver::driver::resolve_statement},
-    shared::value::Value,
     store::{function::FunctionDef, global::GlobalStore},
 };
+use devalang_types::Value;
 
 pub fn resolve_function(
     stmt: &Statement,
@@ -17,7 +17,7 @@ pub fn resolve_function(
         body,
     } = &stmt.kind
     {
-        let resolved_body = resolve_block_statements(body, &module, path, global_store);
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
 
         global_store.functions.add_function(FunctionDef {
             name: name.clone(),
@@ -35,7 +35,7 @@ pub fn resolve_function(
             eprintln!("[resolve_statement] ❌ Module path not found: {path}");
         }
 
-        return Statement {
+        Statement {
             kind: StatementKind::Function {
                 name: name.clone(),
                 parameters: parameters.clone(),
@@ -43,15 +43,15 @@ pub fn resolve_function(
             },
             value: Value::Null,
             ..stmt.clone()
-        };
+        }
     } else {
-        return Statement {
+        Statement {
             kind: StatementKind::Error {
                 message: "Expected a function statement".to_string(),
             },
             value: Value::Null,
             ..stmt.clone()
-        };
+        }
     }
 }
 

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+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_group(
     stmt: &Statement,

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

@@ -1,17 +1,15 @@
 use std::collections::HashMap;
 
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{
-            module::Module,
-            resolver::{driver::resolve_statement, value::resolve_value},
-        },
-        shared::value::Value,
-        store::global::GlobalStore,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        module::Module,
+        resolver::{driver::resolve_statement, value::resolve_value},
     },
-    utils::logger::Logger,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 
 pub fn resolve_loop(
     stmt: &Statement,

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

@@ -7,6 +7,7 @@ pub mod call;
 pub mod condition;
 pub mod function;
 pub mod group;
+pub mod pattern;
 pub mod let_;
 pub mod loop_;
 pub mod spawn;

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

@@ -0,0 +1,75 @@
+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,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+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,
@@ -33,24 +31,49 @@ pub fn resolve_spawn(
     }
 
     // If it's a group stored in variables
-    if let Some(variable) = global_store.variables.variables.get(&name) {
-        if let Value::Statement(stmt_box) = variable {
-            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()));
+    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()
-                        };
+                    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()
+            };
         }
     }
 

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+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,

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+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,

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

@@ -1,14 +1,11 @@
-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,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::{Duration, Value};
+use devalang_utils::logger::Logger;
+use std::collections::HashMap;
 
 pub fn resolve_trigger(
     stmt: &Statement,
@@ -44,15 +41,21 @@ pub fn resolve_trigger(
     // Params value resolution
     let final_value = match &stmt.value {
         Value::Identifier(ident) => {
-            println!("Resolving identifier: {}", ident);
+            logger.log_message(
+                devalang_utils::logger::LogLevel::Debug,
+                &format!("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
-            })
+            match resolve_identifier(ident, module, global_store) {
+                Some(v) => v,
+                None => {
+                    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();
@@ -88,7 +91,7 @@ fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore)
         return Some(resolve_value(val, module, global_store));
     }
 
-    for (_, other_mod) in &global_store.modules {
+    for other_mod in global_store.modules.values() {
         if let Some(val) = other_mod.variable_table.get(ident) {
             return Some(resolve_value(val, other_mod, global_store));
         }