@devaloop/devalang 0.0.1-alpha.5 → 0.0.1-alpha.8

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

@@ -0,0 +1,182 @@
+use std::collections::HashMap;
+use crate::{
+    core::{
+        parser::statement::{ self, Statement, StatementKind },
+        preprocessor::{
+            loader::ModuleLoader,
+            module::Module,
+            resolver::{
+                bank::resolve_bank, call::resolve_call, condition::resolve_condition, group::resolve_group, loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo, trigger::resolve_trigger
+            },
+        },
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
+        utils::validation::{ is_valid_entity, is_valid_identifier },
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for module in global_store.clone().modules.values_mut() {
+        resolve_imports(module_loader, global_store);
+    }
+}
+
+pub fn resolve_statement(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    match &stmt.kind {
+        StatementKind::Trigger { entity, duration } => {
+            resolve_trigger(
+                &mut stmt.clone(),
+                entity,
+                &mut duration.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) }
+
+        // TODO: Handle other statement kinds if necessary
+        // ...
+
+        _ => stmt.clone(),
+    }
+}
+
+pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for (module_path, module) in global_store.clone().modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            match source_path {
+                Value::String(source_path) => {
+                    if let Some(source_module) = global_store.modules.get(source_path) {
+                        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}'"
+                            );
+                        }
+                    } else {
+                        println!(
+                            "[warn] '{module_path}': cannot find source module '{source_path}'"
+                        );
+                    }
+                }
+                _ => {
+                    println!(
+                        "[warn] '{module_path}': expected string for import source, found {:?}",
+                        source_path
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn resolve_and_flatten_all_modules(
+    global_store: &mut GlobalStore
+) -> HashMap<String, Vec<Statement>> {
+    let logger = Logger::new();
+    let snapshot = global_store.clone();
+
+    // 1. Imports resolution
+    for (module_path, module) in global_store.modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            if let Value::String(source_path_str) = source_path {
+                match snapshot.modules.get(source_path_str) {
+                    Some(source_module) => {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            logger.log_error_with_stacktrace(
+                                &format!("'{name}' not found in exports of '{source_path_str}'"),
+                                module_path
+                            );
+                        }
+                    }
+                    None => {
+                        logger.log_error_with_stacktrace(
+                            &format!("Cannot find source module '{source_path_str}'"),
+                            module_path
+                        );
+                    }
+                }
+            } else {
+                logger.log_error_with_stacktrace(
+                    &format!("Expected string for import source, found {:?}", source_path),
+                    module_path
+                );
+            }
+        }
+    }
+
+    // 2. Statements resolution
+    let mut resolved_map: HashMap<String, Vec<Statement>> = HashMap::new();
+    let store_snapshot = global_store.clone();
+
+    for (path, module) in &store_snapshot.modules {
+        let mut resolved = Vec::new();
+
+        for stmt in &module.statements {
+            let mut stmt = stmt.clone();
+
+            match &stmt.kind {
+                StatementKind::Trigger { entity, duration } => {
+                    let resolved_stmt = resolve_trigger(
+                        &stmt,
+                        entity.as_str(),
+                        &mut duration.clone(),
+                        &module,
+                        &path,
+                        &store_snapshot
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Loop => {
+                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Bank => {
+                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Tempo => {
+                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Import { .. } | StatementKind::Export { .. } => {
+                    resolved.push(stmt.clone());
+                }
+
+                StatementKind::Group => {
+                    let resolved_stmt = resolve_group(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                _ => {
+                    resolved.push(stmt);
+                }
+            }
+        }
+
+        resolved_map.insert(path.clone(), resolved);
+    }
+
+    resolved_map
+}

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

@@ -0,0 +1,118 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::{condition::resolve_condition, trigger::resolve_trigger} },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(value_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map for group statement".to_string());
+    };
+
+    let group_name = match value_map.get("identifier") {
+        Some(Value::String(name)) => name.clone(),
+        Some(other) => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                format!("Group name must be a string, found {:?}", other)
+            );
+        }
+        None => {
+            return type_error(&logger, module, stmt, "Group name is required".to_string());
+        }
+    };
+
+    let resolved_body = match value_map.get("body") {
+        Some(Value::Block(statements)) => {
+            let mut resolved = Vec::new();
+
+            for stmt in statements {
+                match &stmt.kind {
+                    StatementKind::Trigger { entity, duration } => {
+                        let resolved_trigger = resolve_trigger(
+                            &mut stmt.clone(),
+                            entity,
+                            &mut duration.clone(),
+                            module,
+                            path,
+                            global_store
+                        );
+
+                        resolved.push(resolved_trigger);
+                    }
+
+                    StatementKind::If => {
+                        let resolved_condition = resolve_condition(
+                            &mut stmt.clone(),
+                            module,
+                            path,
+                            global_store
+                        );
+
+                        resolved.push(resolved_condition);
+                    }
+
+                    _ => {
+                        println!("Unhandled group body statement: {:?}", stmt);
+                    }
+                }
+            }
+
+            Value::Block(resolved)
+        }
+
+        Some(other) => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                format!("Unexpected value for group body: {:?}", other)
+            );
+        }
+
+        None => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                "Missing 'body' key in group statement".to_string()
+            );
+        }
+    };
+
+    let mut resolved_map = HashMap::new();
+    resolved_map.insert("identifier".to_string(), Value::String(group_name));
+    resolved_map.insert("body".to_string(), resolved_body);
+
+    Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
+    }
+}
+
+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/loop_.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
@@ -16,9 +18,7 @@ pub fn resolve_loop(
 ) -> Statement {
     let logger = Logger::new();
 
-    // Vérifie que stmt.value est bien une Map
     if let Value::Map(value_map) = &stmt.value {
-        // Résolution de l'iterator
         let iterator_value = match value_map.get("iterator") {
             Some(Value::Identifier(ident)) => {
                 match module.variable_table.get(ident) {
@@ -69,7 +69,6 @@ pub fn resolve_loop(
             }
         };
 
-        // Résolution du body
         let body_value = match value_map.get("body") {
             Some(Value::Block(block)) => {
                 let mut resolved_block = Vec::new();
@@ -113,12 +112,10 @@ pub fn resolve_loop(
             }
         };
 
-        // ✅ Reconstruit proprement la valeur résolue
-        let mut resolved_map = std::collections::HashMap::new();
+        let mut resolved_map = HashMap::new();
         resolved_map.insert("iterator".to_string(), iterator_value);
         resolved_map.insert("body".to_string(), body_value);
 
-        // ✅ Reconstruit le StatementLoop à partir des éléments résolus
         Statement {
             kind: StatementKind::Loop,
             value: Value::Map(resolved_map),

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

@@ -1,151 +1,10 @@
+pub mod driver;
+
 pub mod trigger;
 pub mod loop_;
 pub mod bank;
 pub mod tempo;
-
-use std::collections::HashMap;
-use crate::{
-    core::{
-        parser::statement::{ self, Statement, StatementKind },
-        preprocessor::{
-            loader::ModuleLoader,
-            resolver::{
-                bank::resolve_bank,
-                loop_::resolve_loop,
-                tempo::resolve_tempo,
-                trigger::resolve_trigger,
-            },
-        },
-        shared::{ duration::Duration, value::Value },
-        store::global::GlobalStore,
-        utils::validation::{ is_valid_entity, is_valid_identifier },
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.clone().modules.values_mut() {
-        resolve_imports(module_loader, global_store);
-    }
-}
-
-pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for (module_path, module) in global_store.clone().modules.iter_mut() {
-        for (name, source_path) in &module.import_table.imports {
-            match source_path {
-                Value::String(source_path) => {
-                    if let Some(source_module) = global_store.modules.get(source_path) {
-                        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}'"
-                            );
-                        }
-                    } else {
-                        println!(
-                            "[warn] '{module_path}': cannot find source module '{source_path}'"
-                        );
-                    }
-                }
-                _ => {
-                    println!(
-                        "[warn] '{module_path}': expected string for import source, found {:?}",
-                        source_path
-                    );
-                }
-            }
-        }
-    }
-}
-
-pub fn resolve_and_flatten_all_modules(
-    global_store: &mut GlobalStore
-) -> HashMap<String, Vec<Statement>> {
-    let logger = Logger::new();
-    let snapshot = global_store.clone();
-
-    // 1. Imports resolution
-    for (module_path, module) in global_store.modules.iter_mut() {
-        for (name, source_path) in &module.import_table.imports {
-            if let Value::String(source_path_str) = source_path {
-                match snapshot.modules.get(source_path_str) {
-                    Some(source_module) => {
-                        if let Some(value) = source_module.export_table.get_export(name) {
-                            module.variable_table.set(name.clone(), value.clone());
-                        } else {
-                            logger.log_error_with_stacktrace(
-                                &format!("'{name}' not found in exports of '{source_path_str}'"),
-                                module_path
-                            );
-                        }
-                    }
-                    None => {
-                        logger.log_error_with_stacktrace(
-                            &format!("Cannot find source module '{source_path_str}'"),
-                            module_path
-                        );
-                    }
-                }
-            } else {
-                logger.log_error_with_stacktrace(
-                    &format!("Expected string for import source, found {:?}", source_path),
-                    module_path
-                );
-            }
-        }
-    }
-
-    // 2. Statements resolution
-    let mut resolved_map: HashMap<String, Vec<Statement>> = HashMap::new();
-    let store_snapshot = global_store.clone();
-
-    for (path, module) in &store_snapshot.modules {
-        let mut resolved = Vec::new();
-
-        for stmt in &module.statements {
-            let mut stmt = stmt.clone();
-
-            match &stmt.kind {
-                StatementKind::Trigger { entity, duration } => {
-                    let resolved_stmt = resolve_trigger(
-                        &stmt,
-                        entity.as_str(),
-                        &mut duration.clone(),
-                        &module,
-                        &path,
-                        &store_snapshot
-                    );
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Loop => {
-                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Bank => {
-                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Tempo => {
-                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Import { .. } | StatementKind::Export { .. } => {
-                    resolved.push(stmt.clone());
-                }
-
-                _ => {
-                    resolved.push(stmt);
-                }
-            }
-        }
-
-        resolved_map.insert(path.clone(), resolved);
-    }
-
-    resolved_map
-}
+pub mod group;
+pub mod condition;
+pub mod spawn;
+pub mod call;

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

@@ -0,0 +1,53 @@
+use crate::{
+    core::{
+        parser::statement::{Statement, StatementKind},
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_spawn(
+    stmt: &Statement,
+    module: &Module,
+    _path: &str,
+    _global_store: &GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::String(name) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Spawn expects a group name as string.".to_string());
+    };
+
+    match module.variable_table.variables.get(name) {
+        Some(Value::Map(group_stmt)) => Statement {
+            kind: StatementKind::Spawn,
+            value: Value::Map(group_stmt.clone()),
+            ..stmt.clone()
+        },
+        Some(other) => type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected a group for '{}', but found {:?}", name, other),
+        ),
+        None => type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Group '{}' not found in module '{}'", name, module.path),
+        ),
+    }
+}
+
+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/trigger.rs

@@ -38,7 +38,6 @@ pub fn resolve_trigger(
         };
     }
 
-    // ✅ Résolution de duration si c'est un identifiant
     if let Duration::Identifier(ident) = duration {
         if let Some(val) = module.variable_table.get(ident) {
             match val {
@@ -56,7 +55,6 @@ pub fn resolve_trigger(
         }
     }
 
-    // ✅ Résolution de value (params, effets)
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
             match module.variable_table.get(ident) {
@@ -87,7 +85,6 @@ pub fn resolve_trigger(
         other => other.clone(),
     };
 
-    // ✅ On reconstruit le Statement avec Trigger résolu
     if let StatementKind::Trigger { entity, .. } = &stmt.kind {
         return Statement {
             kind: StatementKind::Trigger {

package/rust/lib.rs

@@ -1,7 +1,6 @@
 pub mod core;
 pub mod utils;
 pub mod config;
-pub mod audio;
 
 use serde::{ Deserialize, Serialize };
 use wasm_bindgen::prelude::*;

package/rust/main.rs

@@ -4,7 +4,6 @@ pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
-pub mod audio;
 
 use std::io;
 use cli::{ Cli };

package/examples/exported.deva

@@ -1,7 +0,0 @@
-let duration = auto
-let default_bank = 808
-let params = {decay:10, delay:30}
-let loopCount = 5
-let tempo = 155
-
-@export { duration, default_bank, params, loopCount, tempo }