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

package/rust/core/parser/mod.rs

@@ -1,238 +1,4 @@
-pub mod statement;
-pub mod handler;
-
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        handler::{
-            at::parse_at_token,
-            bank::parse_bank_token,
-            dot::parse_dot_token,
-            identifier::parse_identifier_token,
-            loop_::parse_loop_token,
-            tempo::parse_tempo_token,
-        },
-        statement::{ Statement, StatementKind },
-    },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Parser {
-    pub resolve_modules: bool,
-    pub tokens: Vec<Token>,
-    pub token_index: usize,
-    pub current_module: String,
-    pub previous: Option<Token>,
-}
-
-impl Parser {
-    pub fn new() -> Self {
-        Parser {
-            resolve_modules: false,
-            tokens: Vec::new(),
-            token_index: 0,
-            current_module: String::new(),
-            previous: None,
-        }
-    }
-
-    pub fn set_current_module(&mut self, module_path: String) {
-        self.current_module = module_path;
-    }
-
-    pub fn advance(&mut self) -> Option<&Token> {
-        if self.is_eof() {
-            return None;
-        }
-
-        self.previous = self.tokens.get(self.token_index).cloned(); // mémorise avant de bouger
-        self.token_index += 1;
-
-        self.tokens.get(self.token_index - 1)
-    }
-
-    pub fn match_token(&mut self, kind: TokenKind) -> bool {
-        if let Some(tok) = self.peek() {
-            if tok.kind == kind {
-                self.advance();
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn previous_clone(&self) -> Option<Token> {
-        self.previous.clone()
-    }
-
-    pub fn parse_block(
-        &self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        let mut inner_parser = Parser {
-            resolve_modules: self.resolve_modules,
-            tokens,
-            token_index: 0,
-            current_module: self.current_module.clone(),
-            previous: None,
-        };
-
-        inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-    }
-
-    pub fn parse_tokens(
-        &mut self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        self.tokens = tokens;
-        self.token_index = 0;
-
-        let mut statements = Vec::new();
-
-        while !self.is_eof() {
-            let token = match self.peek() {
-                Some(t) => t.clone(),
-                None => {
-                    break;
-                }
-            };
-
-            let mut statement = match &token.kind {
-                TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => parse_identifier_token(self, global_store),
-                TokenKind::Dot => parse_dot_token(self, global_store),
-                TokenKind::Tempo => parse_tempo_token(self, global_store),
-                TokenKind::Bank => parse_bank_token(self, global_store),
-                TokenKind::Loop => parse_loop_token(self, global_store),
-
-                | TokenKind::Comment
-                | TokenKind::Equals
-                | TokenKind::Colon
-                | TokenKind::Number
-                | TokenKind::String
-                | TokenKind::LBrace
-                | TokenKind::RBrace
-                | TokenKind::Comma
-                | TokenKind::Newline
-                | TokenKind::Dedent
-                | TokenKind::Indent => {
-                    self.advance();
-                    continue;
-                }
-
-                TokenKind::EOF => {
-                    break;
-                }
+pub mod driver;
 
-                _ => {
-                    println!("Unhandled token: {:?}", token);
-                    self.advance();
-                    Statement::unknown()
-                }
-            };
-
-            statements.push(statement);
-        }
-
-        statements
-    }
-
-    pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().map_or(false, |t| t.kind == kind)
-    }
-
-    pub fn parse_map_value(&mut self) -> Option<Value> {
-        if !self.match_token(TokenKind::LBrace) {
-            return None;
-        }
-
-        let mut map = std::collections::HashMap::new();
-
-        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
-            } else {
-                break;
-            };
-
-            if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
-                break;
-            }
-
-            let value = if let Some(token) = self.peek_clone() {
-                match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
-                    }
-                    TokenKind::Identifier => {
-                        self.advance();
-                        Value::Identifier(token.lexeme.clone())
-                    }
-                    _ => {
-                        println!("Unexpected token in map value: {:?}", token);
-                        Value::Null
-                    }
-                }
-            } else {
-                Value::Null
-            };
-
-            map.insert(key, value);
-        }
-
-        if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
-        }
-
-        Some(Value::Map(map))
-    }
-
-    pub fn peek(&self) -> Option<&Token> {
-        self.tokens.get(self.token_index)
-    }
-
-    pub fn peek_clone(&self) -> Option<Token> {
-        self.tokens.get(self.token_index).cloned()
-    }
-
-    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
-        let tok = self.advance().ok_or("Unexpected end of input")?;
-        if tok.kind == kind {
-            Ok(tok)
-        } else {
-            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-        }
-    }
-
-    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
-        let mut collected = Vec::new();
-        while let Some(token) = self.peek() {
-            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
-                self.advance(); // Skip newlines and indents
-                continue;
-            }
-            if token.kind == TokenKind::EOF {
-                break;
-            }
-            if condition(token) {
-                break;
-            }
-            collected.push(self.advance().unwrap().clone());
-        }
-        collected
-    }
-
-    pub fn is_eof(&self) -> bool {
-        self.token_index >= self.tokens.len()
-    }
-}
+pub mod statement;
+pub mod handler;

package/rust/core/parser/statement.rs

@@ -1,5 +1,4 @@
 use serde::{ Deserialize, Serialize };
-
 use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::Value } };
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -34,39 +33,32 @@ impl Statement {
 }
 
 #[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-/// Represents the kind of a statement
 pub enum StatementKind {
-    // Trigger statements
-    Trigger {
-        entity: String,
-        duration: Duration,
-        // params: Vec<TokenParam>,
+    // ───── Core Instructions ─────
+    Tempo,
+    Bank,
+    Load {
+        source: String,
+        alias: String,
     },
-
-    // Variable statements
     Let {
         name: String,
     },
 
-    // Loop statements
-    Loop,
-
-    // Group statements
-    Group,
-
-    // Special statements
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+    },
+    Sleep,
     Call,
     Spawn,
-    Sleep,
-
-    // Conditional statements
-    // If
-
-    // Keyword statements
-    Tempo,
-    Bank,
+    Loop,
+    
+    // ───── Structure & Logic ─────
+    Group,
 
-    // At (@) statements
+    // ───── Module System ─────
     Include(String),
     Export {
         names: Vec<String>,
@@ -76,20 +68,21 @@ pub enum StatementKind {
         names: Vec<String>,
         source: String,
     },
-    Load {
-        source: String,
-        alias: String,
-    },
 
-    // Error & Unknown statements
-    Unknown,
-    Error {
-        message: String,
-    },
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
 
-    // Empty or ignored statements
+    // ───── Internal / Utility ─────
     Comment,
     Indent,
     Dedent,
     NewLine,
-}
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}

package/rust/core/preprocessor/loader.rs

@@ -3,17 +3,17 @@ use crate::{
     core::{
         error::ErrorHandler,
         lexer::{ token::Token, Lexer },
-        parser::{ statement::{ Statement, StatementKind }, Parser },
-        preprocessor::{
-            module::Module,
-            processor::process_modules,
-            resolver::{ resolve_all_modules, resolve_and_flatten_all_modules },
-        },
+        parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+        preprocessor::{ module::Module, processor::process_modules },
         store::global::GlobalStore,
         utils::path::normalize_path,
     },
     utils::logger::Logger,
 };
+use crate::core::preprocessor::resolver::driver::{
+    resolve_all_modules,
+    resolve_and_flatten_all_modules,
+};
 
 pub struct ModuleLoader {
     pub entry: String,
@@ -93,6 +93,7 @@ impl ModuleLoader {
         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

package/rust/core/preprocessor/processor.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::core::{
-    parser::{ statement::StatementKind, Parser },
+    parser::{ statement::StatementKind, driver::Parser },
     preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,

package/rust/core/preprocessor/resolver/call.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_call(
+    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, "Call expects a group name as string.".to_string());
+    };
+
+    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),
+        ),
+    }
+}
+
+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/condition.rs

@@ -0,0 +1,66 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{module::Module, resolver::driver::resolve_statement},
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_condition(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(condition_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map in condition statement".to_string());
+    };
+
+    let mut resolved_map = condition_map.clone();
+
+    // 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<_>>();
+
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    }
+
+    // Next resolution
+    if let Some(Value::Map(next)) = condition_map.get("next") {
+        let next_stmt = Statement {
+            kind: StatementKind::If,
+            value: Value::Map(next.clone()),
+            ..stmt.clone()
+        };
+
+        let resolved_next = resolve_condition(&next_stmt, module, path, global_store);
+
+        if let Value::Map(resolved_next_map) = resolved_next.value {
+            resolved_map.insert("next".to_string(), Value::Map(resolved_next_map));
+        }
+    }
+
+    Statement {
+        kind: StatementKind::If,
+        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/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
+}