@devaloop/devalang 0.0.1-alpha.12 → 0.0.1-alpha.13

package/rust/core/parser/statement.rs

@@ -49,6 +49,11 @@ pub enum StatementKind {
         method: String,
         args: Vec<Value>,
     },
+    Function {
+        name: String,
+        parameters: Vec<String>,
+        body: Vec<Statement>,
+    },
 
     // ───── Instruments ─────
     Synth,
@@ -57,12 +62,19 @@ pub enum StatementKind {
     Trigger {
         entity: String,
         duration: Duration,
+        effects: Option<Value>,
     },
     Sleep,
-    Call,
-    Spawn,
+    Call {
+        name: String,
+        args: Vec<Value>,
+    },
+    Spawn {
+        name: String,
+        args: Vec<Value>,
+    },
     Loop,
-    
+
     // ───── Structure & Logic ─────
     Group,
 
@@ -93,4 +105,4 @@ pub enum StatementKind {
     Error {
         message: String,
     },
-}
+}

package/rust/core/preprocessor/loader.rs

@@ -127,6 +127,11 @@ impl ModuleLoader {
         updated_module.tokens = tokens;
         updated_module.statements = statements;
 
+        // Step four : Injecting bank triggers if any
+        if let Err(e) = self.inject_bank_triggers(&mut updated_module, "808") {
+            return Err(format!("Failed to inject bank triggers: {}", e));
+        }
+
         // Step four : error handling
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &updated_module.statements);
@@ -143,16 +148,16 @@ impl ModuleLoader {
         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);
 
         // SECTION Process and resolve modules
         process_modules(self, global_store);
         resolve_all_modules(self, global_store);
 
-        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
+        // SECTION Flatten all modules to get statements (+ injects)
+        let statements_by_module = resolve_and_flatten_all_modules(global_store);
 
-        (tokens_by_module, statemnts_by_module)
+        (tokens_by_module, statements_by_module)
     }
 
     #[cfg(feature = "cli")]
@@ -182,12 +187,15 @@ impl ModuleLoader {
         module.statements = statements.clone();
 
         // Inject triggers for each bank used in module
-        for bank_name in ModuleLoader::extract_bank_names(&statements) {
-            if let Err(e) = self.inject_bank_triggers(&mut module, &bank_name) {
-                return HashMap::new(); // Return empty map on error
-            }
+        for bank_name in self.extract_bank_names(&statements) {
+            self.inject_bank_triggers(&mut module, &bank_name);
         }
 
+        // 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());
+
+        // Inject the module into the global store
         global_store.insert_module(path.clone(), module);
 
         // Load dependencies
@@ -241,25 +249,29 @@ impl ModuleLoader {
         }
     }
 
-    pub fn inject_bank_triggers(&self, module: &mut Module, bank_name: &str) -> Result<(), String> {
+    pub fn inject_bank_triggers(
+        &self,
+        module: &mut Module,
+        bank_name: &str
+    ) -> Result<Module, String> {
         let bank_path = Path::new("./.deva/bank").join(bank_name);
-        let bank_file_path = bank_path.join("bank.toml");
+        let bank_toml_path = bank_path.join("bank.toml");
 
-        if !bank_file_path.exists() {
-            return Ok(()); // Pas d'erreur si la banque n'existe pas encore
+        if !bank_toml_path.exists() {
+            return Ok(module.clone());
         }
 
         let content = std::fs
-            ::read_to_string(&bank_file_path)
-            .map_err(|e| format!("Failed to read '{}': {}", bank_file_path.display(), e))?;
+            ::read_to_string(&bank_toml_path)
+            .map_err(|e| format!("Failed to read '{}': {}", bank_toml_path.display(), e))?;
 
-        let parsed: BankFile = toml
+        let parsed_bankfile: BankFile = toml
             ::from_str(&content)
-            .map_err(|e| format!("Failed to parse '{}': {}", bank_file_path.display(), e))?;
+            .map_err(|e| format!("Failed to parse '{}': {}", bank_toml_path.display(), e))?;
 
         let mut bank_map = HashMap::new();
 
-        for bank_trigger in parsed.triggers.unwrap_or_default() {
+        for bank_trigger in parsed_bankfile.triggers.unwrap_or_default() {
             let trigger_name = bank_trigger.name.clone().replace("./", "");
             let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, trigger_name);
 
@@ -268,7 +280,8 @@ impl ModuleLoader {
             if module.variable_table.variables.contains_key(bank_name) {
                 eprintln!(
                     "⚠️ Trigger '{}' already defined in module '{}', skipping injection.",
-                    bank_name, module.path
+                    bank_name,
+                    module.path
                 );
                 continue;
             }
@@ -282,24 +295,27 @@ impl ModuleLoader {
         // Inject the map under the bank name
         module.variable_table.set(bank_name.to_string(), Value::Map(bank_map));
 
-        Ok(())
+        Ok(module.clone())
     }
 
-    fn extract_bank_names(statements: &[Statement]) -> HashSet<String> {
+    fn extract_bank_names(&self, statements: &[Statement]) -> HashSet<String> {
         let mut banks = HashSet::new();
 
         for stmt in statements {
-            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
-                let parts: Vec<&str> = entity.split('.').collect();
-                if parts.len() >= 2 {
-                    banks.insert(parts[0].to_string()); // "808.kick" → "808"
-                }
-            }
-
-            if let StatementKind::Bank = &stmt.kind {
-                if let Value::String(name) = &stmt.value {
-                    banks.insert(name.clone());
+            match &stmt.kind {
+                // Extract only bank declarations
+                StatementKind::Bank => {
+                    if let Value::String(name) = &stmt.value {
+                        banks.insert(name.clone());
+                    }
+                    if let Value::Number(num) = &stmt.value {
+                        banks.insert(num.to_string());
+                    }
+                    if let Value::Identifier(name) = &stmt.value {
+                        banks.insert(name.clone());
+                    }
                 }
+                _ => {}
             }
         }
 

package/rust/core/preprocessor/module.rs

@@ -1,7 +1,7 @@
 use crate::core::{
     lexer::token::Token,
     parser::statement::Statement,
-    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
+    store::{ export::ExportTable, function::FunctionTable, import::ImportTable, variable::VariableTable },
 };
 
 #[derive(Debug, Clone)]
@@ -11,6 +11,7 @@ pub struct Module {
     pub tokens: Vec<Token>,
     pub statements: Vec<Statement>,
     pub variable_table: VariableTable,
+    pub function_table: FunctionTable,
     pub export_table: ExportTable,
     pub import_table: ImportTable,
     pub content: String,
@@ -24,6 +25,7 @@ impl Module {
             tokens: Vec::new(),
             statements: Vec::new(),
             variable_table: VariableTable::new(),
+            function_table: FunctionTable::new(),
             export_table: ExportTable::new(),
             import_table: ImportTable::new(),
             resolved: false,

package/rust/core/preprocessor/processor.rs

@@ -5,7 +5,7 @@ use crate::core::{
     preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,
-    utils::path::{normalize_path, resolve_relative_path},
+    utils::path::{ normalize_path, resolve_relative_path },
 };
 
 pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
@@ -13,6 +13,31 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
         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);
+                        
+                        module.variable_table.variables.insert(
+                            name.clone(),
+                            Value::StatementKind(Box::new(stmt.kind.clone()))
+                        );
+
+                        continue;
+                    }
+
+                    if module.variable_table.get(name).is_some() {
+                        eprintln!("❌ 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
+                        );
+                        continue;
+                    }
+
                     module.variable_table.variables.insert(name.clone(), stmt.value.clone());
                 }
 

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

@@ -10,103 +10,80 @@ use crate::{
 
 pub fn resolve_call(
     stmt: &Statement,
+    name: String,
+    args: Vec<Value>,
     module: &Module,
     path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    match &stmt.value {
-        Value::Identifier(ident) => {
-            match module.variable_table.get(ident) {
-                Some(Value::String(group_name)) =>
-                    resolve_group_by_name(group_name, stmt, module, path, global_store, &logger),
-                Some(Value::Map(group_map)) =>
-                    resolved_call(stmt, group_map, module, path, global_store),
-                Some(other) =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!(
-                            "Identifier '{ident}' must resolve to a group name or map, found {:?}",
-                            other
-                        )
-                    ),
-                None =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!("Identifier '{ident}' not found in variable table")
-                    ),
-            }
-        }
+    match &stmt.kind {
+        StatementKind::Call { .. } => {
+            // Check if it's a function
+            if let Some(func) = global_store.functions.functions.get(&name) {
+                let mut call_map = std::collections::HashMap::new();
+                call_map.insert("name".to_string(), Value::Identifier(name.clone()));
+                call_map.insert(
+                    "parameters".to_string(),
+                    Value::Array(
+                        func.parameters
+                            .iter()
+                            .map(|p| Value::Identifier(p.clone()))
+                            .collect()
+                    )
+                );
+                call_map.insert("args".to_string(), Value::Array(args.clone()));
+                call_map.insert("body".to_string(), Value::Block(func.body.clone()));
 
-        Value::String(name) =>
-            resolve_group_by_name(name, stmt, module, path, global_store, &logger),
+                return Statement {
+                    kind: StatementKind::Call { name, args },
+                    value: Value::Map(call_map),
+                    ..stmt.clone()
+                };
+            }
 
-        Value::Map(group_map) => resolved_call(stmt, group_map, module, path, global_store),
+            // 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()));
 
-        other =>
-            error_stmt(
-                &logger,
-                module,
-                stmt,
-                &format!("Call expects a group name as string or identifier, found {:?}", other)
-            ),
-    }
-}
+                                return Statement {
+                                    kind: StatementKind::Call { name, args },
+                                    value: Value::Map(resolved_map),
+                                    ..stmt.clone()
+                                };
+                            }
+                        }
+                    }
+                }
+            }
 
-fn resolve_group_by_name(
-    name: &str,
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-    logger: &Logger
-) -> Statement {
-    match module.variable_table.get(name) {
-        Some(Value::Map(group_map)) => resolved_call(stmt, group_map, module, path, global_store),
-        Some(other) =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Expected a group for '{}', but found {:?}", name, other)
-            ),
-        None =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Group '{}' not found in module '{}'", name, module.path)
-            ),
+            // Otherwise, log an error
+            logger.log_message(LogLevel::Error, &format!("Function or group '{}' not found", name));
+            Statement {
+                kind: StatementKind::Error {
+                    message: format!("Function or group '{}' not found", name),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
+        _ => error_stmt(&logger, module, stmt, "Expected StatementKind::Call in resolve_call()"),
     }
 }
 
-fn resolved_call(
-    stmt: &Statement,
-    group_map: &std::collections::HashMap<String, Value>,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let mut cloned_map = group_map.clone();
-
-    if let Some(Value::Block(stmts)) = group_map.get("body") {
-        let resolved = stmts
-            .iter()
-            .map(|s| resolve_statement(s, module, path, global_store))
-            .collect();
-        cloned_map.insert("body".to_string(), Value::Block(resolved));
-    }
-
-    Statement {
-        kind: StatementKind::Call,
-        value: Value::Map(cloned_map),
-        ..stmt.clone()
-    }
+fn get_group_body(stmt_box: &Statement) -> Vec<Statement> {
+    if let Value::Block(body) = &stmt_box.value { body.clone() } else { vec![] }
 }
 
 fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {

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

@@ -1,7 +1,7 @@
 use crate::{
     core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -12,12 +12,17 @@ pub fn resolve_condition(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore,
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
     let Value::Map(condition_map) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Expected a map in condition statement".to_string());
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in condition statement".to_string()
+        );
     };
 
     let mut resolved_map = condition_map.clone();
@@ -60,13 +65,13 @@ fn resolve_block_statements(
     body: &[Statement],
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore,
+    global_store: &mut GlobalStore
 ) -> Vec<Statement> {
     body.iter()
         .flat_map(|stmt| {
             let resolved = resolve_statement(stmt, module, path, global_store);
 
-            if let StatementKind::Call = resolved.kind {
+            if let StatementKind::Call { .. } = resolved.kind {
                 if let Value::Block(inner) = &resolved.value {
                     return inner
                         .iter()

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

@@ -9,6 +9,7 @@ use crate::{
                 bank::resolve_bank,
                 call::resolve_call,
                 condition::resolve_condition,
+                function::resolve_function,
                 group::resolve_group,
                 let_::resolve_let,
                 loop_::resolve_loop,
@@ -36,12 +37,22 @@ pub fn resolve_statement(
     global_store: &mut GlobalStore
 ) -> Statement {
     match &stmt.kind {
-        StatementKind::Trigger { entity, duration } =>
-            resolve_trigger(stmt, entity, &mut duration.clone(), module, path, global_store),
+        StatementKind::Trigger { entity, duration, effects } =>
+            resolve_trigger(
+                stmt,
+                entity,
+                &mut duration.clone(),
+                effects.clone(),
+                module,
+                path,
+                global_store
+            ),
         StatementKind::If => resolve_condition(stmt, module, path, global_store),
         StatementKind::Group => resolve_group(stmt, module, path, global_store),
-        StatementKind::Call => resolve_call(stmt, module, path, global_store),
-        StatementKind::Spawn => resolve_spawn(stmt, module, path, global_store),
+        StatementKind::Call { name, args } =>
+            resolve_call(stmt, name.clone(), args.clone(), module, path, global_store),
+        StatementKind::Spawn { name, args } =>
+            resolve_spawn(stmt, name.clone(), args.clone(), module, path, global_store),
         StatementKind::Bank => resolve_bank(stmt, module, path, global_store),
         StatementKind::Tempo => resolve_tempo(stmt, module, path, global_store),
         StatementKind::Loop => resolve_loop(stmt, module, path, global_store),
@@ -180,14 +191,20 @@ pub fn resolve_and_flatten_all_modules(
         let mut resolved = Vec::new();
 
         for stmt in &module.statements {
-            let mut stmt = stmt.clone();
+            let stmt = stmt.clone();
 
             match &stmt.kind {
-                StatementKind::Trigger { entity, duration } => {
+                StatementKind::Let { name } => {
+                    let resolved_stmt = resolve_let(&stmt, name, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Trigger { entity, duration, effects } => {
                     let resolved_stmt = resolve_trigger(
                         &stmt,
                         entity.as_str(),
                         &mut duration.clone(),
+                        effects.clone(),
                         &module,
                         &path,
                         global_store
@@ -214,11 +231,40 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(stmt.clone());
                 }
 
+                StatementKind::Call { name, args } => {
+                    let resolved_stmt = resolve_call(
+                        &stmt,
+                        name.clone(),
+                        args.clone(),
+                        &module,
+                        &path,
+                        global_store
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Spawn { name, args } => {
+                    let resolved_stmt = resolve_spawn(
+                        &stmt,
+                        name.clone(),
+                        args.clone(),
+                        &module,
+                        &path,
+                        global_store
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
                 StatementKind::Group => {
                     let resolved_stmt = resolve_group(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
 
+                StatementKind::Function { name, parameters, body } => {
+                    let resolved_function = resolve_function(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_function);
+                }
+
                 _ => {
                     resolved.push(stmt);
                 }

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

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::{ function::FunctionDef, global::GlobalStore, variable::VariableTable },
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn resolve_function(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    if let StatementKind::Function { name, parameters, body } = &stmt.kind {
+        let resolved_body = resolve_block_statements(body, &module, path, global_store);
+
+        global_store.functions.add_function(FunctionDef {
+            name: name.clone(),
+            parameters: parameters.clone(),
+            body: resolved_body.clone(),
+        });
+
+        if let Some(current_mod) = global_store.modules.get_mut(path) {
+            current_mod.function_table.add_function(FunctionDef {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body.clone(),
+            });
+        } else {
+            eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+        }
+
+        return Statement {
+            kind: StatementKind::Function {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body,
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        };
+    } else {
+        return Statement {
+            kind: StatementKind::Error {
+                message: "Expected a function statement".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        };
+    }
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .collect()
+}
+
+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()
+    }
+}