@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.11

package/rust/core/preprocessor/loader.rs

@@ -0,0 +1,308 @@
+use std::{ collections::{ HashMap, HashSet }, path::Path };
+use crate::{
+    core::{
+        error::ErrorHandler,
+        lexer::{ token::Token, Lexer },
+        parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+        preprocessor::{ module::Module, processor::process_modules },
+        shared::{ bank::BankFile, value::Value },
+        store::global::GlobalStore,
+        utils::path::normalize_path,
+    },
+    utils::logger::Logger,
+};
+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,
+        }
+    }
+
+    pub fn from_raw_source(
+        entry_path: &str,
+        output_path: &str,
+        content: &str,
+        global_store: &mut GlobalStore
+    ) -> Self {
+        let normalized_entry_path = normalize_path(entry_path);
+
+        let mut module = Module::new(&entry_path);
+        module.content = content.to_string();
+
+        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(),
+        }
+    }
+
+    pub fn extract_statements_map(
+        &self,
+        global_store: &GlobalStore
+    ) -> HashMap<String, Vec<Statement>> {
+        global_store.modules
+            .iter()
+            .map(|(path, module)| (path.clone(), module.statements.clone()))
+            .collect()
+    }
+
+    pub fn load_single_module(&self, global_store: &mut GlobalStore) -> Result<Module, String> {
+        let mut module = global_store.modules
+            .remove(&self.entry)
+            .ok_or_else(|| format!("Module not found in store for path: {}", self.entry))?;
+
+        // SECTION Lexing the module content
+        let lexer = Lexer::new();
+        let tokens = lexer
+            .lex_from_source(&module.content)
+            .map_err(|e| format!("Lexer failed: {}", e))?;
+
+        module.tokens = tokens.clone();
+
+        // SECTION Parsing tokens into statements
+        let mut parser = Parser::new();
+        parser.set_current_module(self.entry.clone());
+        let statements = parser.parse_tokens(tokens, global_store);
+        module.statements = statements;
+
+        // SECTION Injecting bank triggers if any
+        if let Err(e) = self.inject_bank_triggers(&mut module, "808") {
+            return Err(format!("Failed to inject bank triggers: {}", e));
+        }
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
+        // SECTION Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &module.statements);
+
+        Ok(module)
+    }
+
+    pub fn load_wasm_module(&self, global_store: &mut GlobalStore) -> Result<(), String> {
+        // Step one : Load the module from the global store
+        let module = {
+            let module_ref = global_store.modules
+                .get(&self.entry)
+                .ok_or_else(|| format!("❌ Module not found for path: {}", self.entry))?;
+
+            Module::from_existing(&self.entry, module_ref.content.clone())
+        };
+
+        // Step two : lexing
+        let lexer = Lexer::new();
+        let tokens = lexer
+            .lex_from_source(&module.content)
+            .map_err(|e| format!("Lexer failed: {}", e))?;
+
+        // Step three : parsing
+        let mut parser = Parser::new();
+        parser.set_current_module(self.entry.clone());
+
+        let statements = parser.parse_tokens(tokens.clone(), global_store);
+
+        let mut updated_module = module;
+        updated_module.tokens = tokens;
+        updated_module.statements = statements;
+
+        // Step four : error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &updated_module.statements);
+
+        // Final step : insert the updated module back into the global store
+        global_store.modules.insert(self.entry.clone(), updated_module);
+
+        Ok(())
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn load_all_modules(
+        &self,
+        global_store: &mut GlobalStore
+    ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
+        // SECTION Load the entry module and its dependencies
+
+        let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
+
+        // SECTION Process and resolve modules
+        process_modules(self, global_store);
+        resolve_all_modules(self, global_store);
+
+        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
+
+        (tokens_by_module, statemnts_by_module)
+    }
+
+    #[cfg(feature = "cli")]
+    fn load_module_recursively(
+        &self,
+        raw_path: &str,
+        global_store: &mut GlobalStore
+    ) -> HashMap<String, Vec<Token>> {
+        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 mut parser = Parser::new();
+        parser.set_current_module(path.clone());
+
+        let statements = parser.parse_tokens(tokens.clone(), global_store);
+
+        // Insert module into store
+        let mut module = Module::new(&path);
+        module.tokens = tokens.clone();
+        module.statements = statements.clone();
+
+        // Inject triggers for each bank used in module
+        for bank_name in ModuleLoader::extract_bank_names(&statements) {
+            if let Err(e) = self.inject_bank_triggers(&mut module, &bank_name) {
+                return HashMap::new(); // Return empty map on error
+            }
+        }
+
+        global_store.insert_module(path.clone(), module);
+
+        // Load dependencies
+        self.load_module_imports(&path, global_store);
+
+        // Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &statements);
+
+        if error_handler.has_errors() {
+            let logger = Logger::new();
+            for error in error_handler.get_errors() {
+                let trace = format!("{}:{}:{}", path, error.line, error.column);
+                logger.log_error_with_stacktrace(&error.message, &trace);
+            }
+        }
+
+        // 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 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;
+                }
+            };
+
+            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);
+        }
+    }
+
+    pub fn inject_bank_triggers(&self, module: &mut Module, bank_name: &str) -> Result<(), String> {
+        let bank_path = Path::new("./.deva/bank").join(bank_name);
+        let bank_file_path = bank_path.join("bank.toml");
+
+        if !bank_file_path.exists() {
+            return Ok(()); // Pas d'erreur si la banque n'existe pas encore
+        }
+
+        let content = std::fs
+            ::read_to_string(&bank_file_path)
+            .map_err(|e| format!("Failed to read '{}': {}", bank_file_path.display(), e))?;
+
+        let parsed: BankFile = toml
+            ::from_str(&content)
+            .map_err(|e| format!("Failed to parse '{}': {}", bank_file_path.display(), e))?;
+
+        let mut bank_map = HashMap::new();
+
+        for bank_trigger in parsed.triggers.unwrap_or_default() {
+            let trigger_name = bank_trigger.name.clone().replace("./", "");
+            let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, trigger_name);
+
+            bank_map.insert(bank_trigger.name.clone(), Value::String(bank_trigger_path.clone()));
+
+            if module.variable_table.variables.contains_key(bank_name) {
+                eprintln!(
+                    "⚠️ Trigger '{}' already defined in module '{}', skipping injection.",
+                    bank_name, module.path
+                );
+                continue;
+            }
+
+            module.variable_table.set(
+                format!("{}.{}", bank_name, bank_trigger.name),
+                Value::String(bank_trigger_path.clone())
+            );
+        }
+
+        // Inject the map under the bank name
+        module.variable_table.set(bank_name.to_string(), Value::Map(bank_map));
+
+        Ok(())
+    }
+
+    fn extract_bank_names(statements: &[Statement]) -> HashSet<String> {
+        let mut banks = HashSet::new();
+
+        for stmt in statements {
+            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+                let parts: Vec<&str> = entity.split('.').collect();
+                if parts.len() >= 2 {
+                    banks.insert(parts[0].to_string()); // "808.kick" → "808"
+                }
+            }
+
+            if let StatementKind::Bank = &stmt.kind {
+                if let Value::String(name) = &stmt.value {
+                    banks.insert(name.clone());
+                }
+            }
+        }
+
+        banks
+    }
+}

package/rust/core/preprocessor/mod.rs

@@ -1,26 +1,4 @@
 pub mod module;
-pub mod dependencies;
+pub mod loader;
 pub mod resolver;
-
-use crate::core::{
-    preprocessor::{
-        dependencies::collect_dependencies_recursively,
-        module::load_module_into_global_store,
-    },
-    types::{ store::GlobalStore },
-};
-
-pub fn preprocess(entry_file: &str) -> GlobalStore {
-    println!("📦 Collecting dependencies for: {}", entry_file);
-
-    let files = collect_dependencies_recursively(entry_file);
-    let mut store = GlobalStore::default();
-
-    for file in &files {
-        if let Err(e) = load_module_into_global_store(file, &mut store) {
-            eprintln!("❌ Error while loading {}: {}", file, e);
-        }
-    }
-
-    store
-}
+pub mod processor;

package/rust/core/preprocessor/module.rs

@@ -1,70 +1,56 @@
 use crate::core::{
-    lexer::lex,
-    parser::{ parse_without_resolving },
-    preprocessor::{
-        collect_dependencies_recursively,
-        resolver::{ resolve_exports, resolve_imports },
-    },
-    types::{ module::Module, parser::Parser, store::{ ExportTable, GlobalStore, ImportTable } },
+    lexer::token::Token,
+    parser::statement::Statement,
+    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
 };
 
-pub fn load_all_modules(entry_file: &str) -> GlobalStore {
-    let mut global_store = GlobalStore::default();
-    let files = collect_dependencies_recursively(entry_file);
+#[derive(Debug, Clone)]
+pub struct Module {
+    pub path: String,
+    pub resolved: bool,
+    pub tokens: Vec<Token>,
+    pub statements: Vec<Statement>,
+    pub variable_table: VariableTable,
+    pub export_table: ExportTable,
+    pub import_table: ImportTable,
+    pub content: String,
+    pub current_dir: String,
+}
 
-    for file in &files {
-        if let Err(e) = load_module_into_global_store(file, &mut global_store) {
-            eprintln!("❌ Error loading {}: {}", file, e);
+impl Module {
+    pub fn new(path: &str) -> Self {
+        Module {
+            path: path.to_string(),
+            tokens: Vec::new(),
+            statements: Vec::new(),
+            variable_table: VariableTable::new(),
+            export_table: ExportTable::new(),
+            import_table: ImportTable::new(),
+            resolved: false,
+            content: String::new(),
+            current_dir: String::new(),
         }
     }
 
-    for file in &files {
-        if let Some(module) = global_store.modules.clone().get_mut(file) {
-            let imports = resolve_imports(module, &mut global_store);
-            module.import_table = imports.clone();
-
-            let global_store_module = global_store.modules.get(&file.clone().to_string());
-            if let Some(global_store_module_found) = global_store_module {
-                global_store.insert_module(file.to_string(), module.clone());
-            } else {
-                eprintln!("❌ Module {} not found in global store after import resolution", file);
-            }
-        }
+    pub fn is_resolved(&self) -> bool {
+        self.resolved
     }
 
-    global_store
-}
-
-pub fn load_module_into_global_store(
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Result<(), String> {
-    if global_store.modules.contains_key(path) {
-        return Ok(());
+    pub fn set_resolved(&mut self, resolved: bool) {
+        self.resolved = resolved;
     }
 
-    let content = std::fs::read_to_string(path).map_err(|_| format!("Cannot read file: {}", path))?;
-
-    let tokens = lex(content);
-
-    let mut parser = Parser::new(tokens.clone());
-
-    parser.current_module = path.to_string();
-
-    let raw_statements = parse_without_resolving(tokens.clone(), &mut parser, global_store);
-
-    let export_table = resolve_exports(&raw_statements, &mut parser);
-
-    let mut module = Module {
-        path: path.to_string(),
-        tokens: tokens.clone(),
-        statements: raw_statements,
-        variable_table: parser.variable_table.clone(),
-        export_table: export_table.clone(),
-        import_table: parser.import_table.clone(),
-    };
+    pub fn add_token(&mut self, token: Token) {
+        self.tokens.push(token);
+    }
 
-    global_store.insert_module(path.to_string(), module.clone());
+    pub fn add_statement(&mut self, statement: Statement) {
+        self.statements.push(statement);
+    }
 
-    Ok(())
+    pub fn from_existing(path: &str, content: String) -> Self {
+        let mut module = Module::new(path);
+        module.content = content;
+        module
+    }
 }

package/rust/core/preprocessor/processor.rs

@@ -0,0 +1,76 @@
+use std::{ collections::HashMap, path::Path };
+
+use crate::core::{
+    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) {
+    for module in global_store.modules.values_mut() {
+        for stmt in &module.statements {
+            match &stmt.kind {
+                StatementKind::Let { name } => {
+                    module.variable_table.variables.insert(name.clone(), stmt.value.clone());
+                }
+
+                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(resolved_path)
+                    );
+                }
+
+                StatementKind::Export { names, source } => {
+                    for name in names {
+                        if let Some(val) = module.variable_table.get(name) {
+                            module.export_table.add_export(name.clone(), val.clone());
+                        }
+                    }
+                }
+
+                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(resolved.clone())
+                        );
+                    }
+                }
+
+                StatementKind::Group => {
+                    if let Value::Map(map) = &stmt.value {
+                        if
+                            let (Some(Value::String(name)), Some(Value::Block(body))) = (
+                                map.get("identifier"),
+                                map.get("body"),
+                            )
+                        {
+                            let mut stored_map = HashMap::new();
+
+                            stored_map.insert(
+                                "identifier".to_string(),
+                                Value::String(name.clone())
+                            );
+
+                            stored_map.insert("body".to_string(), Value::Block(body.clone()));
+
+                            module.variable_table.set(name.to_string(), Value::Map(stored_map));
+                        } else {
+                            eprintln!("❌ Invalid group definition: {:?}", stmt.value);
+                        }
+                    }
+                }
+
+                _ => {}
+            }
+        }
+    }
+}

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

@@ -1,59 +1,49 @@
-use crate::core::{parser::parse_with_resolving_with_module, 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_bank_statement(stmt: &Statement, module: &Module) -> StatementResolved {
-    match &stmt.value {
-        VariableValue::Text(name) => {
-            if
-                let Some(value) = module.import_table.imports
-                    .get(name)
-                    .or_else(|| module.variable_table.variables.get(name))
-            {
-                let statement_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Text(text) => StatementResolvedValue::String(text.clone()),
-                    VariableValue::Number(num) => StatementResolvedValue::Number(*num),
-                    VariableValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Bank: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
+pub fn resolve_bank(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
 
-                StatementResolved {
-                    kind: StatementKind::Bank,
-                    value: statement_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
             } else {
-                eprintln!("⚠️ Bank variable '{}' not found", name);
-                StatementResolved {
-                    kind: StatementKind::Bank,
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
+                let message = format!("Bank identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message: message.clone(),
+                };
+                new_stmt.value = Value::Null;
             }
         }
-        _ => {
-            eprintln!("⚠️ Invalid value type for Bank statement: {:?}", stmt.value);
-            StatementResolved {
-                kind: StatementKind::Bank,
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
+
+        Value::String(_) => {}
+
+        Value::Number(_) => {}
+
+        other => {
+            let message = format!("Expected a string or identifier for bank, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a string or identifier for bank".to_string(),
+            };
+            new_stmt.value = Value::Null;
         }
     }
+
+    new_stmt
 }