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

package/rust/core/parser/handler/loop_.rs

@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::{ token::TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'loop'
+    let Some(loop_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    let Some(iterator_token) = parser.peek_clone() else {
+        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
+    };
+
+    let iterator_value = match iterator_token.kind {
+        TokenKind::Number => {
+            let val = iterator_token.lexeme.parse::<f32>().unwrap_or(1.0);
+            parser.advance();
+            Value::Number(val)
+        }
+        TokenKind::Identifier => {
+            let val = iterator_token.lexeme.clone();
+            parser.advance();
+            Value::Identifier(val)
+        }
+        _ => {
+            return Statement::error(
+                iterator_token.clone(),
+                "Expected a number or identifier as loop count".to_string()
+            );
+        }
+    };
+
+    // Expect colon
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(iterator_token.clone(), "Expected ':' after loop count".to_string());
+    };
+
+    if colon_token.kind != TokenKind::Colon {
+        let message = format!("Expected ':' after loop count, got {:?}", colon_token.kind);
+        return Statement::error(colon_token.clone(), message);
+    }
+
+    parser.advance(); // consume ':'
+
+    // Collect body
+    let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+    let loop_body = parser.parse_block(tokens.clone(), global_store);
+
+    if let Some(token) = parser.peek() {
+        if token.kind == TokenKind::Dedent {
+            parser.advance();
+        }
+    }
+
+    let mut value_map = HashMap::new();
+    value_map.insert("iterator".to_string(), iterator_value);
+    value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(value_map),
+        indent: loop_token.indent,
+        line: loop_token.line,
+        column: loop_token.column,
+    }
+}

package/rust/core/parser/handler/mod.rs

@@ -0,0 +1,8 @@
+pub mod at;
+pub mod identifier;
+pub mod dot;
+pub mod tempo;
+pub mod bank;
+pub mod loop_;
+pub mod condition;
+pub mod arrow_call;

package/rust/core/parser/handler/tempo.rs

@@ -0,0 +1,47 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'bpm'
+
+    let Some(tempo_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a number or identifier
+    let Some(value_token) = parser.peek_clone() else {
+        return Statement::error(
+            tempo_token,
+            "Expected a number or identifier after 'bpm'".to_string()
+        );
+    };
+
+    let value = match value_token.kind {
+        TokenKind::Number => {
+            parser.advance();
+            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+        }
+        TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(value_token.lexeme.clone())
+        }
+        _ => {
+            return Statement::error(
+                value_token.clone(),
+                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Tempo,
+        value,
+        indent: tempo_token.indent,
+        line: tempo_token.line,
+        column: tempo_token.column,
+    }
+}

package/rust/core/parser/mod.rs

@@ -1,201 +1,4 @@
-pub mod identifer;
-pub mod variable;
-pub mod at;
-pub mod dot;
-pub mod bank;
-pub mod loop_;
-pub mod tempo;
+pub mod driver;
 
-use crate::{
-    core::{
-        parser::{
-            at::parse_at,
-            bank::parse_bank,
-            dot::parse_dot,
-            identifer::parse_identifier,
-            loop_::parse_loop,
-            tempo::parse_tempo,
-        },
-        preprocessor::resolver::resolve_statement,
-        types::{
-            module::Module,
-            parser::Parser,
-            statement::{ Statement, StatementKind, StatementResolved },
-            store::{ GlobalStore },
-            token::{ Token, TokenKind },
-            variable::VariableValue,
-        },
-    },
-    utils::logger::log_message,
-};
-
-pub fn parse_without_resolving(
-    tokens: Vec<Token>,
-    mut parser: &mut Parser,
-    global_store: &mut GlobalStore
-) -> Vec<Statement> {
-    let mut statements = Vec::new();
-
-    while !parser.is_eof() {
-        let mut error_statement = Statement {
-            kind: StatementKind::Error,
-            value: VariableValue::Null,
-            line: parser.peek().map_or(0, |t| t.line),
-            column: parser.peek().map_or(0, |t| t.column),
-            indent: parser.peek().map_or(0, |t| t.indent),
-        };
-
-        match parser.peek().map(|t| t.kind.clone()) {
-            Some(TokenKind::Identifier) => {
-                match parse_identifier(&mut parser, global_store) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            Some(TokenKind::Bank) => {
-                match parse_bank(&mut parser, global_store) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            Some(TokenKind::At) => {
-                match parse_at(&mut parser) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            Some(TokenKind::Dot) => {
-                match parse_dot(&mut parser, global_store) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            Some(TokenKind::Loop) => {
-                match parse_loop(&mut parser, global_store) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            Some(TokenKind::Tempo) => {
-                match parse_tempo(&mut parser, global_store) {
-                    Ok(statement) => statements.push(statement),
-                    Err(e) => {
-                        error_statement.value = VariableValue::Text(e.to_string());
-                        statements.push(error_statement);
-                    }
-                }
-            }
-
-            | Some(TokenKind::LBrace)
-            | Some(TokenKind::RBrace)
-            | Some(TokenKind::LBracket)
-            | Some(TokenKind::RBracket)
-            | Some(TokenKind::DbQuote)
-            | Some(TokenKind::Quote)
-            | Some(TokenKind::Number)
-            | Some(TokenKind::String)
-            | Some(TokenKind::Newline)
-            | Some(TokenKind::Indent)
-            | Some(TokenKind::Dedent) => {
-                parser.next();
-            }
-            Some(_) => {
-                parser.next();
-            }
-            None => {
-                break;
-            }
-        }
-    }
-
-    statements
-}
-
-pub fn parse_without_resolving_with_module(tokens: Vec<Token>, module: &Module) -> Vec<Statement> {
-    let mut parser = Parser::new(tokens.clone());
-
-    parser.current_module = module.path.clone();
-
-    let mut global_store = GlobalStore::new();
-    global_store.insert_module(module.path.clone(), module.clone());
-
-    let statements = parse_without_resolving(tokens, &mut parser, &mut global_store);
-
-    let mut updated_module = module.clone();
-    updated_module.statements = statements.clone();
-
-    let mut errors: Vec<String> = Vec::new();
-
-    statements.iter().for_each(|statement| {
-        match &statement.kind {
-            StatementKind::Error => {
-                let error_message = match &statement.value {
-                    VariableValue::Text(text) => text.clone(),
-                    _ => "Unknown error".to_string(),
-                };
-
-                errors.push(format!(
-                    "Error in module '{}': {} at line {}, column {}",
-                    updated_module.path,
-                    error_message,
-                    statement.line,
-                    statement.column
-                ));
-
-                log_message(&format!("Error: {}", error_message), "ERROR");
-            }
-            _ => {}
-        }
-    });
-
-    if errors.len() > 0 {
-        log_message(&format!("{} error(s) found. Parsing stopped.", errors.len()), "INFO");
-
-        statements
-    } else {
-        statements
-    }
-}
-
-pub fn parse_with_resolving_with_module(
-    tokens: Vec<Token>,
-    module: &Module
-) -> Vec<StatementResolved> {
-    let mut parser = Parser::new(tokens.clone());
-
-    parser.current_module = module.path.clone();
-
-    let mut global_store = GlobalStore::new();
-    global_store.insert_module(module.path.clone(), module.clone());
-
-    let statements = parse_without_resolving(tokens, &mut parser, &mut global_store);
-
-    let mut resolved_statements = Vec::new();
-
-    for statement in statements {
-        let resolved_statement = resolve_statement(&statement, &mut module.clone());
-        resolved_statements.push(resolved_statement);
-    }
-
-    return resolved_statements;
-}
+pub mod statement;
+pub mod handler;

package/rust/core/parser/statement.rs

@@ -0,0 +1,96 @@
+use serde::{ Deserialize, Serialize };
+use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::Value } };
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub value: Value,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Statement {
+    pub fn unknown() -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: 0,
+            line: 0,
+            column: 0,
+        }
+    }
+
+    pub fn error(token: Token, message: String) -> Self {
+        Statement {
+            kind: StatementKind::Error { message },
+            value: Value::Null,
+            indent: token.indent,
+            line: token.line,
+            column: token.column,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
+pub enum StatementKind {
+    // ───── Core Instructions ─────
+    Tempo,
+    Bank,
+    Load {
+        source: String,
+        alias: String,
+    },
+    Let {
+        name: String,
+    },
+    ArrowCall {
+        target: String,
+        method: String,
+        args: Vec<Value>,
+    },
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+    },
+    Sleep,
+    Call,
+    Spawn,
+    Loop,
+    
+    // ───── Structure & Logic ─────
+    Group,
+
+    // ───── Module System ─────
+    Include(String),
+    Export {
+        names: Vec<String>,
+        source: String,
+    },
+    Import {
+        names: Vec<String>,
+        source: String,
+    },
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Internal / Utility ─────
+    Comment,
+    Indent,
+    Dedent,
+    NewLine,
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}

package/rust/core/preprocessor/loader.rs

@@ -0,0 +1,229 @@
+use std::{ collections::HashMap, path::Path };
+use crate::{
+    core::{
+        error::ErrorHandler,
+        lexer::{ token::Token, Lexer },
+        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,
+};
+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 Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &module.statements);
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
+        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);
+
+        // 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);
+            }
+        }
+
+        // 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);
+
+        // Load dependencies
+        self.load_module_imports(&path, global_store);
+
+        // 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);
+        }
+    }
+}

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;