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

package/rust/core/preprocessor/module.rs

@@ -1,70 +1,51 @@
 use crate::core::{
-    lexer::driver::lex,
-    parser::{ parse_without_resolving },
-    preprocessor::{
-        collect_dependencies_recursively,
-        resolver::{ resolve_exports, resolve_imports },
+    lexer::token::Token,
+    parser::statement::Statement,
+    store::{
+        export::ExportTable,
+        global::GlobalStore,
+        import::ImportTable,
+        variable::VariableTable,
     },
-    types::{ module::Module, parser::Parser, store::{ ExportTable, GlobalStore, ImportTable } },
 };
 
-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,
+}
 
-    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,
         }
     }
 
-    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(),
-    };
-
-    global_store.insert_module(path.to_string(), module.clone());
+    pub fn add_token(&mut self, token: Token) {
+        self.tokens.push(token);
+    }
 
-    Ok(())
+    pub fn add_statement(&mut self, statement: Statement) {
+        self.statements.push(statement);
+    }
 }

package/rust/core/preprocessor/processor.rs

@@ -0,0 +1,41 @@
+use crate::core::{
+    parser::{ statement::StatementKind, Parser },
+    preprocessor::loader::ModuleLoader,
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+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 } => {
+                    module.variable_table.variables.insert(
+                        alias.clone(),
+                        Value::Sample(source.clone())
+                    );
+                }
+
+                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 } => {
+                    for name in names {
+                        module.import_table.add_import(name.clone(), Value::String(source.clone()));
+                    }
+                }
+                
+                _ => {}
+            }
+        }
+    }
+}

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

@@ -1,59 +1,46 @@
-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(_) => {
+            // Pas de résolution nécessaire
+        }
+
+        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
 }

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

@@ -1,82 +1,143 @@
-use crate::core::{
-    parser::parse_without_resolving_with_module,
-    preprocessor::resolver::resolve_statement,
-    types::{
-        module::Module,
-        statement::{
-            Statement,
-            StatementIterator,
-            StatementKind,
-            StatementResolved,
-            StatementResolvedValue,
-        },
-        variable::VariableValue,
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        shared::value::Value,
+        store::global::GlobalStore,
     },
+    utils::logger::Logger,
 };
 
-pub fn resolve_loop_statement(
-    loop_statement: &Statement,
-    iterator: StatementIterator,
-    module: &Module
-) -> StatementResolved {
-    let mut resolved_iterator = StatementIterator::Unknown;
+pub fn resolve_loop(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
 
-    match iterator.clone() {
-        StatementIterator::Identifier(id) => {
-            if let Some(value) = module.variable_table.variables.get(&id) {
-                match value {
-                    VariableValue::Array(arr) => {
-                        resolved_iterator = StatementIterator::Array(
-                            parse_without_resolving_with_module(arr.clone(), module)
+    // 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) {
+                    Some(Value::Number(n)) => Value::Number(*n),
+                    Some(_) => {
+                        log_type_error(
+                            &logger,
+                            module,
+                            stmt,
+                            format!("Loop iterator '{ident}' must resolve to a number")
                         );
+                        Value::Null
                     }
-                    VariableValue::Number(num) => {
-                        resolved_iterator = StatementIterator::Number(*num);
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for loop iterator: {:?}", value);
-                        resolved_iterator = StatementIterator::Unknown;
+                    None => {
+                        log_type_error(
+                            &logger,
+                            module,
+                            stmt,
+                            format!("Loop iterator '{ident}' not found")
+                        );
+                        Value::Null
                     }
                 }
-            } else {
-                eprintln!("⚠️ Loop iterator variable '{}' not found", id);
-                resolved_iterator = StatementIterator::Unknown;
             }
-        }
-        StatementIterator::Number(num) => {
-            resolved_iterator = StatementIterator::Number(num);
-        }
-        _ => {
-            resolved_iterator = iterator.clone();
-        }
-    }
-
-    let mut resolved_body: StatementResolvedValue = StatementResolvedValue::Unknown;
-
-    match &loop_statement.value {
-        VariableValue::Array(arr) => {
-            let raw_statements = parse_without_resolving_with_module(arr.clone(), &module.clone());
-
-            let mut resolved_statements = Vec::new();
+            Some(Value::Number(n)) => Value::Number(*n),
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop iterator: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'iterator' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
 
-            for raw_stmt in raw_statements {
-                let resolved_stmt = resolve_statement(&raw_stmt, &mut module.clone());
-                resolved_statements.push(resolved_stmt);
+        // Résolution du body
+        let body_value = match value_map.get("body") {
+            Some(Value::Block(block)) => {
+                let mut resolved_block = Vec::new();
+                for ref statement in block.clone() {
+                    match &statement.kind {
+                        StatementKind::Trigger { entity, duration } => {
+                            let resolved = resolve_trigger(
+                                &mut statement.clone(),
+                                &entity,
+                                &mut duration.clone(),
+                                module,
+                                path,
+                                global_store
+                            );
+                            resolved_block.push(resolved);
+                        }
+                        _ => {
+                            println!("Unhandled loop body statement: {:?}", statement);
+                        }
+                    }
+                }
+                Value::Block(resolved_block)
+            }
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop body: {:?}", other)
+                );
+                Value::Null
             }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'body' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        // ✅ Reconstruit proprement la valeur résolue
+        let mut resolved_map = std::collections::HashMap::new();
+        resolved_map.insert("iterator".to_string(), iterator_value);
+        resolved_map.insert("body".to_string(), body_value);
 
-            resolved_body = StatementResolvedValue::Array(resolved_statements);
+        // ✅ Reconstruit le StatementLoop à partir des éléments résolus
+        Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
         }
-        _ => {
-            resolved_body = StatementResolvedValue::Unknown;
-            eprintln!("⚠️ Unsupported value type for loop body: {:?}", loop_statement.value);
+    } else {
+        log_type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected a map for loop value, found {:?}", stmt.value)
+        );
+
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a map for loop value".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
         }
     }
+}
 
-    return StatementResolved {
-        kind: StatementKind::Loop { iterator: resolved_iterator },
-        value: resolved_body,
-        indent: loop_statement.indent,
-        line: loop_statement.line,
-        column: loop_statement.column,
-    };
+fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
 }