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

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()
+    }
+}

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

@@ -1,20 +1,18 @@
-use std::collections::HashMap;
-
 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, variable::VariableTable },
+        store::global::GlobalStore,
     },
-    utils::logger::{ LogLevel, Logger },
+    utils::logger::{LogLevel, Logger},
 };
 
 pub fn resolve_group(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore
+    global_store: &mut GlobalStore,
 ) -> Statement {
     let logger = Logger::new();
 
@@ -22,27 +20,59 @@ pub fn resolve_group(
         return type_error(&logger, module, stmt, "Expected a map in group statement".to_string());
     };
 
-    let mut resolved_map = group_map.clone();
+    // Check for the presence of the identifier field
+    let identifier = match group_map.get("identifier") {
+        Some(Value::String(id)) => id.clone(),
+        _ => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            )
+        }
+    };
 
+    // Ensure the identifier does not already exist
+    if global_store.variables.variables.contains_key(&identifier) {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Group identifier '{}' already exists", identifier),
+        );
+    }
+
+    // Resolve statements in the body
+    let mut resolved_map = group_map.clone();
     if let Some(Value::Block(body)) = group_map.get("body") {
         let resolved_body = resolve_block_statements(body, module, path, global_store);
         resolved_map.insert("body".to_string(), Value::Block(resolved_body));
     } else {
-        logger.log_message(LogLevel::Warning, "group without a body");
+        logger.log_message(LogLevel::Warning, "Group without a body");
     }
 
-    Statement {
+    // Build a complete Statement for the group
+    let resolved_group_stmt = Statement {
         kind: StatementKind::Group,
-        value: Value::Map(resolved_map),
+        value: Value::Map(resolved_map.clone()),
         ..stmt.clone()
-    }
+    };
+
+    // Store the Statement directly in the global variable_table
+    global_store
+        .variables
+        .variables
+        .insert(identifier.clone(), Value::Statement(Box::new(resolved_group_stmt.clone())));
+
+    resolved_group_stmt
 }
 
 fn resolve_block_statements(
     body: &[Statement],
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore
+    global_store: &mut GlobalStore,
 ) -> Vec<Statement> {
     body.iter()
         .map(|stmt| resolve_statement(stmt, module, path, global_store))

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

@@ -1,13 +1,8 @@
-use crate::
-    core::{
-        parser::statement:: Statement ,
-        preprocessor::{
-            module::Module,
-            resolver:: value::resolve_value ,
-        },
-        store:: global::GlobalStore ,
-    }
-;
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::{ module::Module, resolver::value::resolve_value },
+    store::global::GlobalStore,
+};
 
 pub fn resolve_let(
     stmt: &Statement,
@@ -18,6 +13,8 @@ pub fn resolve_let(
 ) -> Statement {
     let resolved_value = resolve_value(&stmt.value, module, global_store);
 
+    global_store.variables.set(name.to_string(), resolved_value.clone());
+
     if let Some(current_mod) = global_store.modules.get_mut(path) {
         current_mod.variable_table.set(name.to_string(), resolved_value.clone());
     } else {

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

@@ -11,4 +11,5 @@ pub mod condition;
 pub mod spawn;
 pub mod call;
 pub mod synth;
-pub mod let_;
+pub mod let_;
+pub mod function;

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

@@ -14,45 +14,79 @@ use crate::{
 
 pub fn resolve_spawn(
     stmt: &Statement,
+    name: String,
+    args: Vec<Value>,
     module: &Module,
     path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    let resolved_value = resolve_value(&stmt.value, module, global_store);
+    // ✅ Si c'est une fonction
+    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()));
 
-    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));
-            }
+        return Statement {
+            kind: StatementKind::Spawn { name, args },
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
+        };
+    }
 
-            Statement {
-                kind: StatementKind::Spawn,
-                value: Value::Map(map),
-                ..stmt.clone()
-            }
-        }
+    // ✅ Si c'est un group dans les 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()));
 
-        _ => {
-            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()
+                        return Statement {
+                            kind: StatementKind::Spawn { name, args },
+                            value: Value::Map(resolved_map),
+                            ..stmt.clone()
+                        };
+                    }
+                }
             }
         }
     }
-}
+
+    // ❌ Sinon erreur
+    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()
+    }
+}
+
+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 {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
+
+    Statement {
+        kind: StatementKind::Error {
+            message: message.to_string(),
+        },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}

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

@@ -14,6 +14,7 @@ pub fn resolve_trigger(
     stmt: &Statement,
     entity: &str,
     duration: &mut Duration,
+    effects: Option<Value>,
     module: &Module,
     path: &str,
     global_store: &GlobalStore
@@ -44,6 +45,8 @@ pub fn resolve_trigger(
     // Params value resolution
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
+            println!("Resolving identifier: {}", ident);
+
             resolve_identifier(ident, module, global_store).unwrap_or_else(|| {
                 logger.log_error_with_stacktrace(
                     &format!("'{path}': value identifier '{ident}' not found"),
@@ -71,9 +74,10 @@ pub fn resolve_trigger(
     Statement {
         kind: StatementKind::Trigger {
             entity: entity.to_string(),
-            duration: final_duration,
+            duration: final_duration.clone(),
+            effects: Some(final_value.clone()),
         },
-        value: final_value,
+        value: Value::Null,
         line: stmt.line,
         column: stmt.column,
         indent: stmt.indent,
@@ -86,7 +90,7 @@ fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore)
     }
 
     for (_, other_mod) in &global_store.modules {
-        if let Some(val) = other_mod.export_table.get_export(ident) {
+        if let Some(val) = other_mod.variable_table.get(ident) {
             return Some(resolve_value(val, other_mod, global_store));
         }
     }

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

@@ -16,11 +16,18 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
             return Some(val.clone());
         }
     }
+
     None
 }
 
 pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
     match value {
+        Value::String(s) => {
+            println!("Resolving value: {}", s);
+
+            Value::String(s.clone())
+        },
+
         Value::Identifier(name) => {
             if let Some(original_val) = module.variable_table.get(name) {
                 return resolve_value(original_val, module, global_store);
@@ -30,7 +37,8 @@ pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalSt
                 return resolve_value(&export_val, module, global_store);
             }
 
-            eprintln!("⚠️ Unresolved identifier '{}'", name);
+            println!("⚠️ Unresolved identifier '{}'", name);
+
             Value::Null
         }
 
@@ -62,6 +70,7 @@ pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalSt
             for (k, v) in map {
                 resolved.insert(k.clone(), resolve_value(v, module, global_store));
             }
+
             Value::Map(resolved)
         }
 

package/rust/core/shared/value.rs

@@ -1,12 +1,13 @@
 use std::collections::HashMap;
 use serde::{ Deserialize, Serialize };
 
-use crate::core::parser::statement::Statement;
+use crate::core::{parser::statement::{Statement, StatementKind}, shared::duration::Duration};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum Value {
     Boolean(bool),
     Number(f32),
+    Duration(Duration),
     Identifier(String),
     String(String),
     Array(Vec<Value>),
@@ -14,6 +15,8 @@ pub enum Value {
     Block(Vec<Statement>),
     Sample(String),
     Beat(String),
+    Statement(Box<Statement>),
+    StatementKind(Box<StatementKind>),
     Unknown,
     Null,
 }

package/rust/core/store/function.rs

@@ -0,0 +1,34 @@
+use std::collections::HashMap;
+use crate::core::parser::statement::Statement;
+
+#[derive(Debug, Clone)]
+pub struct FunctionDef {
+    pub name: String,
+    pub parameters: Vec<String>,
+    pub body: Vec<Statement>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FunctionTable {
+    pub functions: HashMap<String, FunctionDef>,
+}
+
+impl FunctionTable {
+    pub fn new() -> Self {
+        FunctionTable {
+            functions: HashMap::new(),
+        }
+    }
+
+    pub fn add_function(&mut self, function: FunctionDef) {
+        self.functions.insert(function.name.clone(), function);
+    }
+
+    pub fn get_function(&self, name: &str) -> Option<&FunctionDef> {
+        self.functions.get(name)
+    }
+
+    pub fn remove_function(&mut self, name: &str) -> Option<FunctionDef> {
+        self.functions.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -1,23 +1,22 @@
 use std::collections::HashMap;
-use crate::core::preprocessor::module::Module;
+use crate::core::{
+    preprocessor::module::Module,
+    store::{ function::FunctionTable, variable::VariableTable },
+};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone)]
 pub struct GlobalStore {
     pub modules: HashMap<String, Module>,
+    pub variables: VariableTable,
+    pub functions: FunctionTable,
 }
 
 impl GlobalStore {
     pub fn new() -> Self {
         GlobalStore {
             modules: HashMap::new(),
-        }
-    }
-
-    pub fn resolve_all_imports(&mut self) {
-        for module in self.modules.values_mut() {
-            for (name, source_path) in &module.import_table.imports {
-                println!("Resolving import: {} from {:?}", name, source_path);
-            }
+            functions: FunctionTable::new(),
+            variables: VariableTable::new(),
         }
     }
 

package/rust/core/store/mod.rs

@@ -1,4 +1,5 @@
 pub mod global;
 pub mod export;
 pub mod import;
-pub mod variable;
+pub mod variable;
+pub mod function;

package/rust/core/store/variable.rs

@@ -5,12 +5,14 @@ use crate::core::shared::value::Value;
 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct VariableTable {
     pub variables: HashMap<String, Value>,
+    pub parent: Option<Box<VariableTable>>,
 }
 
 impl VariableTable {
     pub fn new() -> Self {
         VariableTable {
             variables: HashMap::new(),
+            parent: None,
         }
     }
 
@@ -18,6 +20,10 @@ impl VariableTable {
         self.variables.insert(name, value);
     }
 
+    pub fn with_parent(parent: VariableTable) -> Self {
+        Self { variables: HashMap::new(), parent: Some(Box::new(parent)) }
+    }
+
     pub fn get(&self, name: &str) -> Option<&Value> {
         self.variables.get(name)
     }