@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.4

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

@@ -1,113 +1,152 @@
-pub mod bank;
+pub mod trigger;
 pub mod loop_;
+pub mod bank;
 pub mod tempo;
-pub mod trigger;
-pub mod at;
-
-use crate::core::{
-    preprocessor::resolver::{
-        bank::resolve_bank_statement,
-        loop_::resolve_loop_statement,
-        tempo::resolve_tempo_statement,
-        trigger::resolve_trigger_statement,
-        at::{ resolve_load_statement },
-    },
-    types::{
-        module::Module,
-        parser::Parser,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        store::{ ExportTable, GlobalStore, ImportTable },
-        variable::VariableValue,
+
+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_exports(statements: &[Statement], parser: &Parser) -> ExportTable {
-    let mut export_table = parser.export_table.clone();
+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);
+    }
+}
 
-    for stmt in statements {
-        if let StatementKind::Export = &stmt.kind {
-            if let VariableValue::Array(tokens) = &stmt.value {
-                for token in tokens {
-                    let var_name = &token.lexeme;
-                    if let Some(value) = parser.variable_table.variables.get(var_name) {
-                        export_table.add_export(var_name.clone(), value.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 {
-                        eprintln!("⚠️ Variable '{}' not found in scope, export skipped", var_name);
+                        println!(
+                            "[warn] '{module_path}': cannot find source module '{source_path}'"
+                        );
                     }
                 }
-            } else {
-                eprintln!("⚠️ Unexpected value type in export: {:?}", stmt.value);
+                _ => {
+                    println!(
+                        "[warn] '{module_path}': expected string for import source, found {:?}",
+                        source_path
+                    );
+                }
             }
         }
     }
-
-    export_table
 }
 
-pub fn resolve_imports(module: &mut Module, global_store: &GlobalStore) -> ImportTable {
-    let mut import_table = ImportTable::default();
+pub fn resolve_and_flatten_all_modules(
+    global_store: &mut GlobalStore
+) -> HashMap<String, Vec<Statement>> {
+    let logger = Logger::new();
+    let snapshot = global_store.clone(); // pour éviter les emprunts mutables
 
-    for stmt in &module.statements {
-        if let StatementKind::Import { names, source } = &stmt.kind {
-            if let Some(from_module) = global_store.modules.get(source) {
-                for name in names {
-                    if let Some(value) = from_module.export_table.exports.get(name) {
-                        module.variable_table.variables.insert(name.clone(), value.clone());
-                        import_table.add_import(name.clone(), value.clone());
-                    } else {
-                        eprintln!("⚠️ '{}' not found in exports of '{}'", name, source);
+    // 1. Résolution des imports
+    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 {
-                eprintln!("⚠️ Module '{}' not found", source);
+                logger.log_error_with_stacktrace(
+                    &format!("Expected string for import source, found {:?}", source_path),
+                    module_path
+                );
             }
         }
     }
 
-    import_table
-}
+    // 2. Résolution des statements
+    let mut resolved_map = HashMap::new();
+    let store_snapshot = global_store.clone();
 
-pub fn resolve_statement(stmt: &Statement, module: &mut Module) -> StatementResolved {
-    match &stmt.kind {
-        StatementKind::Loop { iterator } => {
-            resolve_loop_statement(stmt, iterator.clone(), module)
-        }
+    for (path, module) in &store_snapshot.modules {
+        let mut resolved = Vec::new();
 
-        StatementKind::Trigger { entity, duration } => {
-            resolve_trigger_statement(stmt, entity.clone(), duration.clone(), module)
-        }
+        for stmt in &module.statements {
+            let mut stmt = stmt.clone();
 
-        StatementKind::Bank { .. } => { resolve_bank_statement(stmt, module) }
+            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::Tempo { .. } => { resolve_tempo_statement(stmt, module) }
+                StatementKind::Loop => {
+                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
 
-        StatementKind::Load { source, alias } => {
-            resolve_load_statement(stmt, source, alias, module)
-        }
+                StatementKind::Bank => {
+                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
 
-        // TODO Handle other statement kinds
-
-        StatementKind::Error => {
-            StatementResolved {
-                kind: StatementKind::Error,
-                value: match stmt.value {
-                    VariableValue::Text(ref msg) => StatementResolvedValue::String(msg.clone()),
-                    _ => StatementResolvedValue::Unknown,
-                },
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
+                StatementKind::Tempo => {
+                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Import { .. } | StatementKind::Export { .. } => {
+                    // Rien à faire
+                    resolved.push(stmt.clone());
+                }
 
-        _ => {
-            StatementResolved {
-                kind: StatementKind::Unknown,
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+                _ => {
+                    resolved.push(stmt);
+                }
             }
         }
+
+        resolved_map.insert(path.clone(), resolved);
     }
+
+    resolved_map
 }

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

@@ -1,70 +1,49 @@
-use crate::core::types::{module::Module, statement::{Statement, StatementKind, StatementResolved, StatementResolvedValue}, variable::VariableValue};
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
 
-pub fn resolve_tempo_statement(
-    tempo_statement: &Statement,
-    module: &Module
-) -> StatementResolved {
-    match &tempo_statement.value {
-        VariableValue::Number(num) => {
-            if *num > 0.0 {
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Number(*num),
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
+pub fn resolve_tempo(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
             } else {
-                eprintln!("⚠️ Invalid tempo value: {}", num);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
+                let message = format!("Tempo identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message,
+                };
+                new_stmt.value = Value::Null;
             }
         }
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let variable_value: StatementResolvedValue = match value {
-                    VariableValue::Number(num) if *num > 0.0 => {
-                        StatementResolvedValue::Number(*num)
-                    }
-                    VariableValue::Text(t) => StatementResolvedValue::String(t.clone()),
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Tempo: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
 
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: variable_value,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            } else {
-                eprintln!("⚠️ Tempo variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            }
+        Value::Number(_) => {
+            // Already resolved, no modification needed
         }
-        _ => {
-            eprintln!("⚠️ Invalid value type for Tempo statement: {:?}", tempo_statement.value);
-            StatementResolved {
-                kind: StatementKind::Tempo,
-                value: StatementResolvedValue::Unknown,
-                indent: tempo_statement.indent,
-                line: tempo_statement.line,
-                column: tempo_statement.column,
-            }
+
+        other => {
+            let message = format!("Expected a number or identifier for tempo, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a number or identifier for tempo".to_string(),
+            };
+            new_stmt.value = Value::Null;
         }
     }
+
+    new_stmt
 }

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

@@ -1,176 +1,114 @@
 use std::collections::HashMap;
 
-use crate::core::{
-    parser::parse_with_resolving_with_module,
-    types::{
-        module::Module,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        token::{ TokenDuration, TokenParamValue },
-        variable::VariableValue,
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
+        utils::validation::is_valid_entity,
     },
+    utils::logger::Logger,
 };
 
-pub fn resolve_trigger_statement(
+pub fn resolve_trigger(
     stmt: &Statement,
-    entity: String,
-    duration: TokenDuration,
-    module: &Module
-) -> StatementResolved {
-    let mut entity_value = VariableValue::Unknown;
-
-    if let Some(value) = module.variable_table.variables.get(&entity) {
-        entity_value = value.clone();
-    } else {
-        entity_value = VariableValue::Text(entity.clone());
+    entity: &str,
+    duration: &mut Duration,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+    let mut final_value = stmt.value.clone();
+
+    if !is_valid_entity(entity, module, global_store) {
+        let message = format!("Invalid entity '{}', expected a valid identifier", entity);
+        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+        logger.log_error_with_stacktrace(&message, &stacktrace);
+
+        return Statement {
+            kind: stmt.kind.clone(),
+            value: Value::Null,
+            line: stmt.line,
+            column: stmt.column,
+            indent: stmt.indent,
+        };
     }
 
-    let duration_raw_value = match duration {
-        TokenDuration::Auto => "auto",
-        TokenDuration::Infinite => "infinite",
-        TokenDuration::Number(n) => &n.to_string(),
-        TokenDuration::Identifier(ref id) => id.as_str(),
-        _ => "unknown",
-    };
-
-    let duration_variable_value = module.variable_table.variables.get(duration_raw_value);
-    let mut parsed_duration_value = TokenDuration::Unknown;
-
-    if duration_variable_value.is_some() {
-        parsed_duration_value = duration_variable_value
-            .as_ref()
-            .map_or(TokenDuration::Unknown, |value| {
-                match value {
-                    VariableValue::Text(text) => TokenDuration::Identifier(text.clone()),
-                    VariableValue::Number(num) => TokenDuration::Number(*num),
-                    VariableValue::Boolean(_) => TokenDuration::Unknown,
-                    _ => {
-                        eprintln!("⚠️ Invalid duration type for Trigger: {:?}", value);
-                        TokenDuration::Unknown
-                    }
+    // ✅ 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 {
+                Value::Number(num) => {
+                    final_duration = Duration::Number(*num);
                 }
-            });
-    } else if let Ok(num) = duration_raw_value.parse::<f32>() {
-        parsed_duration_value = TokenDuration::Number(num);
-    } else if duration_raw_value == "auto" {
-        parsed_duration_value = TokenDuration::Auto;
-    } else if duration_raw_value == "infinite" {
-        parsed_duration_value = TokenDuration::Infinite;
-    } else {
-        eprintln!("⚠️ Invalid duration format: {}", duration_raw_value);
-    }
-
-    match &stmt.value {
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let parsed_entity_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Map(map) => {
-                        let mut resolved_map = HashMap::new();
-
-                        for (key, value) in map {
-                            let resolved_value = match value {
-                                TokenParamValue::String(text) =>
-                                    StatementResolvedValue::String(text.clone()),
-                                TokenParamValue::Number(num) =>
-                                    StatementResolvedValue::Number(*num),
-                                TokenParamValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                                _ => {
-                                    eprintln!(
-                                        "⚠️ Unsupported variable type for Trigger map: {:?}",
-                                        value
-                                    );
-                                    StatementResolvedValue::Unknown
-                                }
-                            };
-                            resolved_map.insert(key.clone(), resolved_value);
-                        }
-
-                        StatementResolvedValue::Map(resolved_map)
-                    }
-
-                    | VariableValue::Text(_)
-                    | VariableValue::Number(_)
-                    | VariableValue::Boolean(_) => {
-                        StatementResolvedValue::String(text.clone())
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Trigger entity: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: parsed_entity_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s.clone());
                 }
-            } else {
-                eprintln!("⚠️ Trigger variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::Identifier(id) if id == "auto" => {
+                    final_duration = Duration::Auto;
                 }
+                _ => {}
             }
         }
-        VariableValue::Map(map) => {
-            let mut resolved_map = HashMap::new();
-
-            // TODO Handle nested maps and arrays
+    }
 
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(resolved_map),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+    // ✅ Résolution de value (params, effets)
+    final_value = match &stmt.value {
+        Value::Identifier(ident) => {
+            match module.variable_table.get(ident) {
+                Some(val) => val.clone(),
+                None => {
+                    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+                    let message = format!(
+                        "'{path}': value identifier '{ident}' not found in variable table"
+                    );
+                    logger.log_error_with_stacktrace(&message, &stacktrace);
+                    Value::Null
+                }
             }
         }
-        VariableValue::Null => {
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(HashMap::new()),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+        Value::Map(map) => {
+            let mut resolved_map = HashMap::new();
+            for (k, v) in map.iter() {
+                let resolved_v = match v {
+                    Value::Identifier(id) => {
+                        module.variable_table.get(id).cloned().unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved_v);
             }
+            Value::Map(resolved_map)
         }
+        other => other.clone(),
+    };
 
-        // TODO Parse other parameters
-
-        _ => {
-            eprintln!("⚠️ Invalid value type for Trigger statement: {:?}", stmt.value);
-
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
+    // ✅ On reconstruit le Statement avec Trigger résolu
+    if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+        return Statement {
+            kind: StatementKind::Trigger {
+                entity: entity.to_string(),
+                duration: final_duration,
+            },
+            value: final_value,
+            line: stmt.line,
+            column: stmt.column,
+            indent: stmt.indent,
+        };
     }
+
+    return Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration,
+        },
+        value: final_value,
+        line: stmt.line,
+        column: stmt.column,
+        indent: stmt.indent,
+    };
 }

package/rust/core/shared/duration.rs

@@ -0,0 +1,8 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum Duration {
+    Number(f32),
+    Identifier(String),
+    Auto,
+}

package/rust/core/shared/mod.rs

@@ -0,0 +1,2 @@
+pub mod value;
+pub mod duration;

package/rust/core/shared/value.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+use serde::{ Deserialize, Serialize };
+
+use crate::core::parser::statement::Statement;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Unknown,
+    Null,
+}