@devaloop/devalang 0.0.1-alpha.17 → 0.0.1-alpha.18

package/rust/core/preprocessor/loader.rs

@@ -1,26 +1,23 @@
 #[cfg(feature = "cli")]
 use crate::core::preprocessor::resolver::driver::{
-    resolve_all_modules, resolve_and_flatten_all_modules,
+    resolve_all_modules,
+    resolve_and_flatten_all_modules,
 };
 #[cfg(feature = "cli")]
 use crate::core::utils::path::resolve_relative_path;
 #[cfg_attr(not(feature = "cli"), allow(unused_imports))]
 use crate::core::{
     error::ErrorHandler,
-    lexer::{Lexer, token::Token},
-    parser::{
-        driver::Parser,
-        statement::{Statement, StatementKind},
-    },
+    lexer::{ token::Token, driver::Lexer },
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
     plugin::loader::load_plugin,
-    preprocessor::{module::Module, processor::process_modules},
+    preprocessor::{ module::Module, processor::process_modules },
     store::global::GlobalStore,
     utils::path::normalize_path,
 };
-use devalang_types::{BankFile, Value};
-#[cfg(feature = "cli")]
-use devalang_utils::logger::{LogLevel, Logger};
-use std::{collections::HashMap, path::Path};
+use devalang_types::{ BankFile, Value };
+use devalang_utils::logger::{ LogLevel, Logger };
+use std::{ collections::HashMap, path::Path };
 
 pub struct ModuleLoader {
     pub entry: String,
@@ -47,7 +44,7 @@ impl ModuleLoader {
         entry_path: &str,
         output_path: &str,
         content: &str,
-        global_store: &mut GlobalStore,
+        global_store: &mut GlobalStore
     ) -> Self {
         let normalized_entry_path = normalize_path(entry_path);
 
@@ -68,18 +65,16 @@ impl ModuleLoader {
 
     pub fn extract_statements_map(
         &self,
-        global_store: &GlobalStore,
+        global_store: &GlobalStore
     ) -> HashMap<String, Vec<Statement>> {
-        global_store
-            .modules
+        global_store.modules
             .iter()
             .map(|(path, module)| (path.clone(), module.statements.clone()))
             .collect()
     }
 
     pub fn load_single_module(&self, global_store: &mut GlobalStore) -> Result<Module, String> {
-        let mut module = global_store
-            .modules
+        let mut module = global_store.modules
             .remove(&self.entry)
             .ok_or_else(|| format!("Module not found in store for path: {}", self.entry))?;
 
@@ -106,9 +101,7 @@ impl ModuleLoader {
             self.load_plugin_and_register(&mut module, &plugin_name, &alias, global_store);
         }
 
-        global_store
-            .modules
-            .insert(self.entry.clone(), module.clone());
+        global_store.modules.insert(self.entry.clone(), module.clone());
 
         // SECTION Error handling
         let mut error_handler = ErrorHandler::new();
@@ -120,8 +113,7 @@ impl ModuleLoader {
     pub fn load_wasm_module(&self, global_store: &mut GlobalStore) -> Result<(), String> {
         // Step one : Load the module from the global store
         let module = {
-            let module_ref = global_store
-                .modules
+            let module_ref = global_store.modules
                 .get(&self.entry)
                 .ok_or_else(|| format!("❌ Module not found for path: {}", self.entry))?;
 
@@ -152,9 +144,7 @@ impl ModuleLoader {
         // Insert the updated module into the global store before processing so
         // process_modules can operate on it and populate variable_table, imports,
         // and other derived structures.
-        global_store
-            .modules
-            .insert(self.entry.clone(), updated_module.clone());
+        global_store.modules.insert(self.entry.clone(), updated_module.clone());
 
         // Process modules to populate module.variable_table, import/export tables,
         // and other derived structures so runtime execution can resolve groups/synths.
@@ -174,25 +164,17 @@ impl ModuleLoader {
         // (it lives in `global_store.modules`) because `updated_module` is a local
         // clone and won't contain the mutations applied by `process_modules`.
         if let Some(stored_module) = global_store.modules.get(&self.entry) {
-            global_store
-                .variables
-                .variables
-                .extend(stored_module.variable_table.variables.clone());
-            global_store
-                .functions
-                .functions
-                .extend(stored_module.function_table.functions.clone());
+            global_store.variables.variables.extend(stored_module.variable_table.variables.clone());
+            global_store.functions.functions.extend(stored_module.function_table.functions.clone());
         } else {
             // Fallback to the local updated_module if for any reason the module
             // wasn't inserted into the store (defensive programming).
-            global_store
-                .variables
-                .variables
-                .extend(updated_module.variable_table.variables.clone());
-            global_store
-                .functions
-                .functions
-                .extend(updated_module.function_table.functions.clone());
+            global_store.variables.variables.extend(
+                updated_module.variable_table.variables.clone()
+            );
+            global_store.functions.functions.extend(
+                updated_module.function_table.functions.clone()
+            );
         }
 
         Ok(())
@@ -201,7 +183,7 @@ impl ModuleLoader {
     #[cfg(feature = "cli")]
     pub fn load_all_modules(
         &self,
-        global_store: &mut GlobalStore,
+        global_store: &mut GlobalStore
     ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
         // SECTION Load the entry module and its dependencies
         let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
@@ -220,7 +202,7 @@ impl ModuleLoader {
     fn load_module_recursively(
         &self,
         raw_path: &str,
-        global_store: &mut GlobalStore,
+        global_store: &mut GlobalStore
     ) -> HashMap<String, Vec<Token>> {
         let path = normalize_path(raw_path);
 
@@ -261,14 +243,8 @@ impl ModuleLoader {
         }
 
         // Inject module variables and functions into global store
-        global_store
-            .variables
-            .variables
-            .extend(module.variable_table.variables.clone());
-        global_store
-            .functions
-            .functions
-            .extend(module.function_table.functions.clone());
+        global_store.variables.variables.extend(module.variable_table.variables.clone());
+        global_store.functions.functions.extend(module.function_table.functions.clone());
 
         // Inject the module into the global store
         global_store.insert_module(path.clone(), module);
@@ -293,8 +269,7 @@ impl ModuleLoader {
         }
 
         // Return tokens per module
-        global_store
-            .modules
+        global_store.modules
             .iter()
             .map(|(p, m)| (p.clone(), m.tokens.clone()))
             .collect()
@@ -306,16 +281,12 @@ impl ModuleLoader {
             let current_module = match global_store.modules.get(path) {
                 Some(module) => module,
                 None => {
-                    eprintln!(
-                        "[warn] Cannot resolve imports: module '{}' not found in store",
-                        path
-                    );
+                    eprintln!("[warn] Cannot resolve imports: module '{}' not found in store", path);
                     return;
                 }
             };
 
-            current_module
-                .statements
+            current_module.statements
                 .iter()
                 .filter_map(|stmt| {
                     if let StatementKind::Import { source, .. } = &stmt.kind {
@@ -337,13 +308,9 @@ impl ModuleLoader {
         &self,
         module: &mut Module,
         bank_name: &str,
-        alias_override: Option<String>,
+        alias_override: Option<String>
     ) -> Result<Module, String> {
-        let default_alias = bank_name
-            .split('.')
-            .next_back()
-            .unwrap_or(bank_name)
-            .to_string();
+        let default_alias = bank_name.split('.').next_back().unwrap_or(bank_name).to_string();
         let alias_ref = alias_override.as_deref().unwrap_or(&default_alias);
 
         let bank_path = match devalang_utils::path::get_deva_dir() {
@@ -356,10 +323,12 @@ impl ModuleLoader {
             return Ok(module.clone());
         }
 
-        let content = std::fs::read_to_string(&bank_toml_path)
+        let content = std::fs
+            ::read_to_string(&bank_toml_path)
             .map_err(|e| format!("Failed to read '{}': {}", bank_toml_path.display(), e))?;
 
-        let parsed_bankfile: BankFile = toml::from_str(&content)
+        let parsed_bankfile: BankFile = toml
+            ::from_str(&content)
             .map_err(|e| format!("Failed to parse '{}': {}", bank_toml_path.display(), e))?;
 
         let mut bank_map = HashMap::new();
@@ -368,38 +337,30 @@ impl ModuleLoader {
             // Use the configured path from the bank file as the entity reference so
             // that bank entries can point to files or nested paths. Clean common
             // local prefixes like "./" to keep the URI tidy.
-            let entity_ref = bank_trigger
-                .path
-                .clone()
-                .replace("\\", "/")
-                .replace("./", "");
+            let entity_ref = bank_trigger.path.clone().replace("\\", "/").replace("./", "");
             let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, entity_ref);
 
             // Keep the trigger key as declared (bank_trigger.name) but expose its
             // value as a devalang://bank URI pointing to the configured path.
-            bank_map.insert(
-                bank_trigger.name.clone(),
-                Value::String(bank_trigger_path.clone()),
-            );
+            bank_map.insert(bank_trigger.name.clone(), Value::String(bank_trigger_path.clone()));
 
             if module.variable_table.variables.contains_key(alias_ref) {
                 eprintln!(
                     "⚠️ Trigger '{}' already defined in module '{}', skipping injection.",
-                    alias_ref, module.path
+                    alias_ref,
+                    module.path
                 );
                 continue;
             }
 
             module.variable_table.set(
                 format!("{}.{}", alias_ref, bank_trigger.name),
-                Value::String(bank_trigger_path.clone()),
+                Value::String(bank_trigger_path.clone())
             );
         }
 
         // Inject the map under the bank name
-        module
-            .variable_table
-            .set(alias_ref.to_string(), Value::Map(bank_map));
+        module.variable_table.set(alias_ref.to_string(), Value::Map(bank_map));
 
         Ok(module.clone())
     }
@@ -445,7 +406,7 @@ impl ModuleLoader {
         module: &mut Module,
         plugin_name: &str,
         alias: &str,
-        global_store: &mut GlobalStore,
+        global_store: &mut GlobalStore
     ) {
         // plugin_name expected format: "author.name"
         let mut parts = plugin_name.split('.');
@@ -464,10 +425,7 @@ impl ModuleLoader {
             }
         };
         if parts.next().is_some() {
-            eprintln!(
-                "Invalid plugin name '{}': expected <author>.<name>",
-                plugin_name
-            );
+            eprintln!("Invalid plugin name '{}': expected <author>.<name>", plugin_name);
             return;
         }
 
@@ -499,8 +457,7 @@ impl ModuleLoader {
                 // Inject a single, clear error into the module so it is reported once by the error handler
                 module.statements.push(Statement {
                     kind: StatementKind::Error {
-                        message: "plugin present in local files but missing in .devalang config"
-                            .to_string(),
+                        message: "plugin present in local files but missing in .devalang config".to_string(),
                     },
                     value: Value::Null,
                     indent: 0,
@@ -514,20 +471,16 @@ impl ModuleLoader {
         match load_plugin(author, name) {
             Ok((info, wasm)) => {
                 let uri = format!("devalang://plugin/{}.{}", author, name);
-                global_store
-                    .plugins
-                    .insert(format!("{}:{}", author, name), (info, wasm));
+                global_store.plugins.insert(format!("{}:{}", author, name), (info, wasm));
                 // Set alias to URI, and inject exported variables
-                module
-                    .variable_table
-                    .set(alias.to_string(), Value::String(uri.clone()));
+                module.variable_table.set(alias.to_string(), Value::String(uri.clone()));
                 // Also expose alias at global level so runtime can resolve it
-                global_store
-                    .variables
-                    .set(alias.to_string(), Value::String(uri.clone()));
+                global_store.variables.set(alias.to_string(), Value::String(uri.clone()));
 
-                if let Some((plugin_info, _)) =
-                    global_store.plugins.get(&format!("{}:{}", author, name))
+                if
+                    let Some((plugin_info, _)) = global_store.plugins.get(
+                        &format!("{}:{}", author, name)
+                    )
                 {
                     for exp in &plugin_info.exports {
                         match exp.kind.as_str() {
@@ -536,18 +489,18 @@ impl ModuleLoader {
                                     if let Ok(n) = s.parse::<f32>() {
                                         module.variable_table.set(
                                             format!("{}.{}", alias, exp.name),
-                                            Value::Number(n),
+                                            Value::Number(n)
                                         );
                                     }
                                 } else if let Some(toml::Value::Integer(i)) = &exp.default {
                                     module.variable_table.set(
                                         format!("{}.{}", alias, exp.name),
-                                        Value::Number(*i as f32),
+                                        Value::Number(*i as f32)
                                     );
                                 } else if let Some(toml::Value::Float(f)) = &exp.default {
                                     module.variable_table.set(
                                         format!("{}.{}", alias, exp.name),
-                                        Value::Number(*f as f32),
+                                        Value::Number(*f as f32)
                                     );
                                 }
                             }
@@ -555,22 +508,23 @@ impl ModuleLoader {
                                 if let Some(toml::Value::String(s)) = &exp.default {
                                     module.variable_table.set(
                                         format!("{}.{}", alias, exp.name),
-                                        Value::String(s.clone()),
+                                        Value::String(s.clone())
                                     );
                                 }
                             }
                             "bool" => {
                                 if let Some(toml::Value::Boolean(b)) = &exp.default {
-                                    module
-                                        .variable_table
-                                        .set(format!("{}.{}", alias, exp.name), Value::Boolean(*b));
+                                    module.variable_table.set(
+                                        format!("{}.{}", alias, exp.name),
+                                        Value::Boolean(*b)
+                                    );
                                 }
                             }
                             "synth" => {
                                 // Provide a discoverable marker: alias.<synthName> resolves to alias.synthName waveform string
                                 module.variable_table.set(
                                     format!("{}.{}", alias, exp.name),
-                                    Value::String(format!("{}.{}", alias, exp.name)),
+                                    Value::String(format!("{}.{}", alias, exp.name))
                                 );
                             }
                             _ => {
@@ -581,23 +535,28 @@ impl ModuleLoader {
                                         toml::Value::Integer(i) => Value::Number(*i as f32),
                                         toml::Value::Float(f) => Value::Number(*f as f32),
                                         toml::Value::Boolean(b) => Value::Boolean(*b),
-                                        toml::Value::Array(arr) => Value::Array(
-                                            arr.iter()
-                                                .map(|v| match v {
-                                                    toml::Value::String(s) => {
-                                                        Value::String(s.clone())
-                                                    }
-                                                    toml::Value::Integer(i) => {
-                                                        Value::Number(*i as f32)
-                                                    }
-                                                    toml::Value::Float(f) => {
-                                                        Value::Number(*f as f32)
-                                                    }
-                                                    toml::Value::Boolean(b) => Value::Boolean(*b),
-                                                    _ => Value::Null,
-                                                })
-                                                .collect(),
-                                        ),
+                                        toml::Value::Array(arr) =>
+                                            Value::Array(
+                                                arr
+                                                    .iter()
+                                                    .map(|v| {
+                                                        match v {
+                                                            toml::Value::String(s) => {
+                                                                Value::String(s.clone())
+                                                            }
+                                                            toml::Value::Integer(i) => {
+                                                                Value::Number(*i as f32)
+                                                            }
+                                                            toml::Value::Float(f) => {
+                                                                Value::Number(*f as f32)
+                                                            }
+                                                            toml::Value::Boolean(b) =>
+                                                                Value::Boolean(*b),
+                                                            _ => Value::Null,
+                                                        }
+                                                    })
+                                                    .collect()
+                                            ),
                                         toml::Value::Table(t) => {
                                             let mut m = std::collections::HashMap::new();
                                             for (k, v) in t.iter() {
@@ -621,9 +580,10 @@ impl ModuleLoader {
                                         _ => Value::Null,
                                     };
                                     if val != Value::Null {
-                                        module
-                                            .variable_table
-                                            .set(format!("{}.{}", alias, exp.name), val);
+                                        module.variable_table.set(
+                                            format!("{}.{}", alias, exp.name),
+                                            val
+                                        );
                                     }
                                 }
                             }

package/rust/core/preprocessor/processor.rs

@@ -10,11 +10,14 @@ use devalang_types::Value;
 
 pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for module in global_store.modules.values_mut() {
+        let logger = devalang_utils::logger::Logger::new();
+        use devalang_utils::logger::LogLevel;
+
         for stmt in &module.statements {
             match &stmt.kind {
                 StatementKind::Let { name } => {
                     if let Value::Null = stmt.value {
-                        eprintln!("❌ Variable '{}' is declared but not initialized.", name);
+                        logger.log_message(LogLevel::Error, &format!("Variable '{}' is declared but not initialized.", name));
 
                         module.variable_table.variables.insert(
                             name.clone(),
@@ -25,15 +28,12 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                     }
 
                     if module.variable_table.get(name).is_some() {
-                        eprintln!("❌ Variable '{}' is already defined in this scope.", name);
+                        logger.log_message(LogLevel::Error, &format!("Variable '{}' is already defined in this scope.", name));
                         continue;
                     }
 
                     if let Some(module_variable) = module.variable_table.variables.get(name) {
-                        eprintln!(
-                            "❌ Variable '{}' is already defined globally with value: {:?}",
-                            name, module_variable
-                        );
+                        logger.log_message(LogLevel::Error, &format!("Variable '{}' is already defined globally with value: {:?}", name, module_variable));
                         continue;
                     }
 
@@ -87,7 +87,7 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                                 .variable_table
                                 .set(name.to_string(), Value::Map(stored_map));
                         } else {
-                            eprintln!("❌ Invalid group definition: {:?}", stmt.value);
+                            logger.log_message(LogLevel::Error, &format!("Invalid group definition: {:?}", stmt.value));
                         }
                     }
                 }

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

@@ -60,6 +60,34 @@ pub fn resolve_call(
                         }
                     }
                 }
+                // 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()
+                    };
+                }
             }
 
             // Otherwise, log an error

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

@@ -5,7 +5,7 @@ use crate::core::{
         module::Module,
         resolver::{
             bank::resolve_bank, call::resolve_call, condition::resolve_condition,
-            function::resolve_function, group::resolve_group, let_::resolve_let,
+        function::resolve_function, group::resolve_group, pattern::resolve_pattern, let_::resolve_let,
             loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo,
             trigger::resolve_trigger,
         },
@@ -14,6 +14,7 @@ use crate::core::{
 };
 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) {
@@ -66,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)
         }
@@ -90,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) {
@@ -107,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())
         }
 
@@ -141,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 {
@@ -149,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));
                 }
             }
         }
@@ -286,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/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;