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

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

package/rust/lib.rs

@@ -7,11 +7,11 @@ use wasm_bindgen::prelude::*;
 use serde_wasm_bindgen::to_value;
 
 use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::driver::{ run_audio_program } },
+    audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
     parser::statement::{ Statement, StatementKind },
     preprocessor::loader::ModuleLoader,
     shared::value::Value,
-    store::global::GlobalStore,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
     utils::path::normalize_path,
 };
 
@@ -69,16 +69,19 @@ pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
         .ok_or(JsValue::from_str("❌ No statements found for entry module"))?
         .clone();
 
-    let audio_engine = AudioEngine::new("wasm_output".to_string());
+    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
 
-    let (final_engine, _, _) = run_audio_program(
+    let _ = run_audio_program(
         &main_statements,
-        audio_engine,
+        &mut audio_engine,
         "playground".to_string(),
-        "wasm_output".to_string()
+        "wasm_output".to_string(),
+        VariableTable::new(),
+        FunctionTable::new(),
+        &mut global_store
     );
 
-    let samples = final_engine.get_normalized_buffer();
+    let samples = audio_engine.get_normalized_buffer();
 
     if samples.is_empty() {
         return Err(JsValue::from_str("❌ Audio buffer is empty"));

package/rust/utils/mod.rs

@@ -3,4 +3,48 @@ pub mod signature;
 pub mod spinner;
 pub mod watcher;
 pub mod file;
-pub mod logger;
+pub mod logger;
+
+use crate::core::parser::statement::{Statement, StatementKind};
+use crate::core::error::ErrorResult;
+use crate::core::shared::value::Value;
+
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+pub fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}