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

package/rust/core/preprocessor/loader.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{ collections::HashMap, path::Path };
 use crate::{
     core::{
         error::ErrorHandler,
@@ -14,17 +14,26 @@ use crate::core::preprocessor::resolver::driver::{
     resolve_all_modules,
     resolve_and_flatten_all_modules,
 };
+use crate::core::utils::path::resolve_relative_path;
 
 pub struct ModuleLoader {
     pub entry: String,
     pub output: String,
+    pub base_dir: String,
 }
 
 impl ModuleLoader {
     pub fn new(entry: &str, output: &str) -> Self {
+        let base_dir = Path::new(entry)
+            .parent()
+            .unwrap_or(Path::new(""))
+            .to_string_lossy()
+            .replace('\\', "/");
+
         Self {
             entry: entry.to_string(),
             output: output.to_string(),
+            base_dir: base_dir,
         }
     }
 
@@ -39,13 +48,12 @@ impl ModuleLoader {
         let mut module = Module::new(&entry_path);
         module.content = content.to_string();
 
-        println!("Loading module from raw source: {}", normalized_entry_path);
-
         global_store.insert_module(normalized_entry_path.to_string(), module);
 
         Self {
             entry: normalized_entry_path.to_string(),
             output: output_path.to_string(),
+            base_dir: "".to_string(),
         }
     }
 
@@ -108,72 +116,78 @@ impl ModuleLoader {
     #[cfg(feature = "cli")]
     fn load_module_recursively(
         &self,
-        path: &str,
+        raw_path: &str,
         global_store: &mut GlobalStore
     ) -> HashMap<String, Vec<Token>> {
-        if global_store.modules.contains_key(path) {
+        let path = normalize_path(raw_path);
+
+        // Check if already loaded
+        if global_store.modules.contains_key(&path) {
             return HashMap::new();
         }
 
         let lexer = Lexer::new();
-        let tokens = lexer.lex_tokens(path);
+        let tokens = lexer.lex_tokens(&path);
 
         let mut parser = Parser::new();
-        parser.set_current_module(path.to_string());
+        parser.set_current_module(path.clone());
 
         let statements = parser.parse_tokens(tokens.clone(), global_store);
 
-        // SECTION Error handling
+        // Error handling
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &statements);
 
-        error_handler.has_errors().then(|| {
+        if error_handler.has_errors() {
             let logger = Logger::new();
-            let errors = error_handler.get_errors();
-
-            for error in errors {
-                let stacktrace = format!("{}:{}:{}", path, error.line, error.column);
-                logger.log_error_with_stacktrace(&error.message, &stacktrace);
+            for error in error_handler.get_errors() {
+                let trace = format!("{}:{}:{}", path, error.line, error.column);
+                logger.log_error_with_stacktrace(&error.message, &trace);
             }
-        });
+        }
 
-        // SECTION Module creation
-        let mut module = Module::new(path);
+        // Insert module into store
+        let mut module = Module::new(&path);
         module.tokens = tokens.clone();
         module.statements = statements.clone();
+        global_store.insert_module(path.clone(), module);
 
-        global_store.insert_module(path.to_string(), module);
-
-        // Then load the imports recursively
-        self.load_module_imports(&path.to_string(), global_store);
+        // Load dependencies
+        self.load_module_imports(&path, global_store);
 
-        // Return all tokens by module
-        let mut tokens_by_module = HashMap::new();
-
-        global_store.modules.iter().for_each(|(path, module)| {
-            tokens_by_module.insert(path.clone(), module.tokens.clone());
-        });
-
-        tokens_by_module
+        // Return tokens per module
+        global_store.modules
+            .iter()
+            .map(|(p, m)| (p.clone(), m.tokens.clone()))
+            .collect()
     }
 
     #[cfg(feature = "cli")]
     fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {
-        let imports = global_store.modules
-            .get(path)
-            .unwrap()
-            .statements.iter()
-            .filter_map(|stmt| {
-                if let StatementKind::Import { source, .. } = &stmt.kind {
-                    Some(source.clone())
-                } else {
-                    None
+        let import_paths: Vec<String> = {
+            let current_module = match global_store.modules.get(path) {
+                Some(module) => module,
+                None => {
+                    eprintln!("[warn] Cannot resolve imports: module '{}' not found in store", path);
+                    return;
                 }
-            })
-            .collect::<Vec<_>>();
-
-        for import_path in imports {
-            self.load_module_recursively(&import_path, global_store);
+            };
+
+            current_module.statements
+                .iter()
+                .filter_map(|stmt| {
+                    if let StatementKind::Import { source, .. } = &stmt.kind {
+                        Some(source.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        };
+
+        for import_path in import_paths {
+            let resolved = resolve_relative_path(path, &import_path);
+            self.load_module_recursively(&resolved, global_store);
         }
     }
 }

package/rust/core/preprocessor/module.rs

@@ -1,12 +1,7 @@
 use crate::core::{
     lexer::token::Token,
     parser::statement::Statement,
-    store::{
-        export::ExportTable,
-        global::GlobalStore,
-        import::ImportTable,
-        variable::VariableTable,
-    },
+    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
 };
 
 #[derive(Debug, Clone)]
@@ -19,6 +14,7 @@ pub struct Module {
     pub export_table: ExportTable,
     pub import_table: ImportTable,
     pub content: String,
+    pub current_dir: String,
 }
 
 impl Module {
@@ -32,6 +28,7 @@ impl Module {
             import_table: ImportTable::new(),
             resolved: false,
             content: String::new(),
+            current_dir: String::new(),
         }
     }
 

package/rust/core/preprocessor/processor.rs

@@ -1,10 +1,11 @@
-use std::collections::HashMap;
+use std::{ collections::HashMap, path::Path };
 
 use crate::core::{
-    parser::{ statement::StatementKind, driver::Parser },
+    parser::{ driver::Parser, statement::StatementKind },
     preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,
+    utils::path::{normalize_path, resolve_relative_path},
 };
 
 pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
@@ -16,9 +17,13 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                 }
 
                 StatementKind::Load { source, alias } => {
+                    let module_dir = Path::new(&module.path).parent().unwrap_or(Path::new(""));
+
+                    let resolved_path = normalize_path(&module_dir.join(source));
+
                     module.variable_table.variables.insert(
                         alias.clone(),
-                        Value::Sample(source.clone())
+                        Value::Sample(resolved_path)
                     );
                 }
 
@@ -31,8 +36,12 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                 }
 
                 StatementKind::Import { names, source } => {
+                    let resolved = resolve_relative_path(&module.path, source);
                     for name in names {
-                        module.import_table.add_import(name.clone(), Value::String(source.clone()));
+                        module.import_table.add_import(
+                            name.clone(),
+                            Value::String(resolved.clone())
+                        );
                     }
                 }
 

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

@@ -1,52 +1,122 @@
 use crate::{
     core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
         store::global::GlobalStore,
     },
-    utils::logger::Logger,
+    utils::logger::{ Logger, LogLevel },
 };
 
 pub fn resolve_call(
     stmt: &Statement,
     module: &Module,
-    _path: &str,
-    _global_store: &GlobalStore,
+    path: &str,
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    let Value::String(name) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Call expects a group name as string.".to_string());
-    };
+    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 module.variable_table.variables.get(name) {
-        Some(Value::Map(group_stmt)) => Statement {
-            kind: StatementKind::Call,
-            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),
-        ),
+        Value::String(name) =>
+            resolve_group_by_name(name, stmt, module, path, global_store, &logger),
+
+        Value::Map(group_map) => resolved_call(stmt, group_map, module, path, global_store),
+
+        other =>
+            error_stmt(
+                &logger,
+                module,
+                stmt,
+                &format!("Call expects a group name as string or identifier, found {:?}", other)
+            ),
     }
 }
 
-fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
+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)
+            ),
+    }
+}
+
+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 error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {
     let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
+    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
 
     Statement {
-        kind: StatementKind::Error { message },
+        kind: StatementKind::Error {
+            message: message.to_string(),
+        },
         value: Value::Null,
         ..stmt.clone()
     }

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

@@ -1,6 +1,6 @@
 use crate::{
     core::{
-        parser::statement::{ Statement, StatementKind },
+        parser::statement::{Statement, StatementKind},
         preprocessor::{module::Module, resolver::driver::resolve_statement},
         shared::value::Value,
         store::global::GlobalStore,
@@ -12,7 +12,7 @@ pub fn resolve_condition(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &GlobalStore
+    global_store: &mut GlobalStore,
 ) -> Statement {
     let logger = Logger::new();
 
@@ -22,27 +22,29 @@ pub fn resolve_condition(
 
     let mut resolved_map = condition_map.clone();
 
-    // Body resolution
+    // Main body resolution
     if let Some(Value::Block(body)) = condition_map.get("body") {
-        let resolved_body = body
-            .iter()
-            .map(|s| resolve_statement(s, module, path, global_store))
-            .collect::<Vec<_>>();
-
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
         resolved_map.insert("body".to_string(), Value::Block(resolved_body));
     }
 
-    // Next resolution
-    if let Some(Value::Map(next)) = condition_map.get("next") {
+    // Recursive resolution of next condition
+    if let Some(Value::Map(next_map)) = condition_map.get("next") {
         let next_stmt = Statement {
             kind: StatementKind::If,
-            value: Value::Map(next.clone()),
+            value: Value::Map(next_map.clone()),
             ..stmt.clone()
         };
 
         let resolved_next = resolve_condition(&next_stmt, module, path, global_store);
 
-        if let Value::Map(resolved_next_map) = resolved_next.value {
+        if let Value::Map(mut resolved_next_map) = resolved_next.value {
+            // Body next resolution
+            if let Some(Value::Block(body)) = resolved_next_map.get("body") {
+                let resolved_body = resolve_block_statements(body, module, path, global_store);
+                resolved_next_map.insert("body".to_string(), Value::Block(resolved_body));
+            }
+
             resolved_map.insert("next".to_string(), Value::Map(resolved_next_map));
         }
     }
@@ -54,6 +56,30 @@ pub fn resolve_condition(
     }
 }
 
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    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 Value::Block(inner) = &resolved.value {
+                    return inner
+                        .iter()
+                        .map(|s| resolve_statement(s, module, path, global_store))
+                        .collect();
+                }
+            }
+
+            vec![resolved]
+        })
+        .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);

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

@@ -1,17 +1,24 @@
 use std::collections::HashMap;
 use crate::{
     core::{
-        parser::statement::{ self, Statement, StatementKind },
+        parser::statement::{ 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
+                bank::resolve_bank,
+                call::resolve_call,
+                condition::resolve_condition,
+                group::resolve_group,
+                let_::resolve_let,
+                loop_::resolve_loop,
+                spawn::resolve_spawn,
+                tempo::resolve_tempo,
+                trigger::resolve_trigger,
             },
         },
-        shared::{ duration::Duration, value::Value },
+        shared::value::Value,
         store::global::GlobalStore,
-        utils::validation::{ is_valid_entity, is_valid_identifier },
     },
     utils::logger::Logger,
 };
@@ -26,35 +33,75 @@ pub fn resolve_statement(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &GlobalStore
+    global_store: &mut GlobalStore
 ) -> Statement {
     match &stmt.kind {
-        StatementKind::Trigger { entity, duration } => {
-            resolve_trigger(
-                &mut stmt.clone(),
-                entity,
-                &mut duration.clone(),
-                module,
-                path,
-                global_store
-            )
+        StatementKind::Trigger { entity, duration } =>
+            resolve_trigger(stmt, 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),
+        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),
+        StatementKind::Let { name, .. } => resolve_let(stmt, name, module, path, global_store),
+
+        _ => {
+            let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+            Statement {
+                value: resolved_value,
+                ..stmt.clone()
+            }
         }
+    }
+}
 
-        StatementKind::If => { resolve_condition(stmt, module, path, global_store) }
+fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::Identifier(name) => {
+            if let Some(original_val) = module.variable_table.get(name) {
+                return resolve_value(original_val, module, global_store);
+            }
 
-        StatementKind::Group => { resolve_group(stmt, module, path, global_store) }
+            if let Some(export_val) = find_export_value(name, global_store) {
+                return resolve_value(&export_val, module, global_store);
+            }
 
-        StatementKind::Call => { resolve_call(stmt, module, path, global_store) }
+            eprintln!("⚠️ Unresolved identifier '{}'", name);
+            Value::Null
+        }
 
-        StatementKind::Spawn => { resolve_spawn(stmt, module, path, global_store) }
+        Value::Map(map) => {
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+            Value::Map(resolved)
+        }
 
-        // TODO: Handle other statement kinds if necessary
-        // ...
+        Value::Block(stmts) => {
+            let resolved_stmts = stmts
+                .iter()
+                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
+                .collect();
+            Value::Block(resolved_stmts)
+        }
 
-        _ => stmt.clone(),
+        other => other.clone(),
     }
 }
 
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for (_path, module) in &global_store.modules {
+        if let Some(val) = module.export_table.get_export(name) {
+            return Some(val.clone());
+        }
+    }
+    None
+}
+
 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 {
@@ -124,9 +171,7 @@ pub fn resolve_and_flatten_all_modules(
 
     // 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 {
+    for (path, module) in global_store.modules.clone() {
         let mut resolved = Vec::new();
 
         for stmt in &module.statements {
@@ -140,23 +185,23 @@ pub fn resolve_and_flatten_all_modules(
                         &mut duration.clone(),
                         &module,
                         &path,
-                        &store_snapshot
+                        global_store
                     );
                     resolved.push(resolved_stmt);
                 }
 
                 StatementKind::Loop => {
-                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
+                    let resolved_stmt = resolve_loop(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
 
                 StatementKind::Bank => {
-                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
+                    let resolved_stmt = resolve_bank(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
 
                 StatementKind::Tempo => {
-                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
+                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
 
@@ -165,7 +210,7 @@ pub fn resolve_and_flatten_all_modules(
                 }
 
                 StatementKind::Group => {
-                    let resolved_stmt = resolve_group(&stmt, &module, &path, &store_snapshot);
+                    let resolved_stmt = resolve_group(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }