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

package/rust/core/preprocessor/module.rs

@@ -1,70 +1,51 @@
 use crate::core::{
-    lexer::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.rs

@@ -0,0 +1,372 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ self, Statement, StatementKind },
+        preprocessor::loader::ModuleLoader,
+        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_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();
+
+    // 1. Imports resolving
+    let global_store_clone = global_store.clone();
+    for (module_path, module) in global_store.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_clone.modules.get(source_path) {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            let message = format!(
+                                "'{name}' not found in exports of '{source_path}'"
+                            );
+                            logger.log_error_with_stacktrace(&message, module_path);
+                        }
+                    } else {
+                        let message = format!("cannot find source module '{source_path}'");
+                        logger.log_error_with_stacktrace(&message, module_path);
+                    }
+                }
+                _ => {
+                    let message = format!(
+                        "expected string for import source, found {:?}",
+                        source_path
+                    );
+                    logger.log_error_with_stacktrace(&message, module_path);
+                }
+            }
+        }
+    }
+
+    // 2. Full statement resolution
+    let mut resolved_map = HashMap::new();
+
+    for (path, module) in &global_store.modules {
+        let mut resolved = Vec::new();
+
+        for mut stmt in module.statements.clone() {
+            match &mut stmt.kind {
+                StatementKind::Bank => {
+                    if let Value::Identifier(ident) = &stmt.value {
+                        if let Some(val) = module.variable_table.get(ident) {
+                            stmt.value = val.clone();
+                        } else {
+                            let message = format!(
+                                "Bank identifier '{ident}' not found in variable table"
+                            );
+
+                            logger.log_error_with_stacktrace(&message, &module.path);
+
+                            stmt.kind = StatementKind::Error {
+                                message: format!(
+                                    "Bank identifier '{ident}' not found in variable table"
+                                ),
+                            };
+                            stmt.value = Value::Null;
+                        }
+                    } else if let Value::String(_) = &stmt.value {
+                        // Value is already a string, no need to modify
+                    } else {
+                        let message = format!(
+                            "Expected a string or identifier for bank, found {:?}",
+                            stmt.value
+                        );
+
+                        logger.log_error_with_stacktrace(&message, &module.path);
+
+                        stmt.kind = StatementKind::Error {
+                            message: "Expected a string or identifier for bank".to_string(),
+                        };
+                        stmt.value = Value::Null;
+                    }
+                }
+
+                StatementKind::Tempo => {
+                    if let Value::Identifier(ident) = &stmt.value {
+                        if let Some(val) = module.variable_table.get(ident) {
+                            stmt.value = val.clone();
+                        } else {
+                            let message = format!(
+                                "Tempo identifier '{ident}' not found in variable table"
+                            );
+
+                            logger.log_error_with_stacktrace(&message, &module.path);
+
+                            stmt.kind = StatementKind::Error {
+                                message: format!(
+                                    "Tempo identifier '{ident}' not found in variable table"
+                                ),
+                            };
+                            stmt.value = Value::Null;
+                        }
+                    } else if let Value::Number(_) = &stmt.value {
+                        // Value is already a number, no need to modify
+                    } else {
+                        let message = format!(
+                            "Expected a number or identifier for tempo, found {:?}",
+                            stmt.value
+                        );
+
+                        logger.log_error_with_stacktrace(&message, &module.path);
+
+                        stmt.kind = StatementKind::Error {
+                            message: "Expected a number or identifier for tempo".to_string(),
+                        };
+                        stmt.value = Value::Null;
+                    }
+                }
+
+                StatementKind::Trigger { entity, duration } => {
+                    if !is_valid_entity(entity, module, global_store) {
+                        let message =
+                            format!("Invalid entity '{}', expected a valid identifier", entity);
+
+                        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+                        logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                        stmt.kind = StatementKind::Error {
+                            message: format!("Invalid entity '{}'", entity),
+                        };
+                        stmt.value = Value::Null;
+
+                        resolved.push(stmt);
+                        continue;
+                    }
+
+                    // Duration resolution
+                    if let Duration::Identifier(ident) = duration {
+                        if let Some(val) = module.variable_table.get(ident) {
+                            match val {
+                                Value::Number(num) => {
+                                    *duration = Duration::Number(*num);
+                                }
+                                Value::String(s) => {
+                                    *duration = Duration::Identifier(s.clone());
+                                }
+                                Value::Identifier(id) if id == "auto" => {
+                                    *duration = Duration::Auto;
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+
+                    // Associated value resolution
+                    if let Value::Identifier(ident) = &stmt.value {
+                        if let Some(val) = module.variable_table.get(ident) {
+                            stmt.value = val.clone();
+                        } else {
+                            let stacktrace = format!(
+                                "{}:{}:{}",
+                                module.path,
+                                stmt.line,
+                                stmt.column
+                            );
+                            let message = format!(
+                                "'{path}': value identifier '{ident}' not found in variable table"
+                            );
+
+                            logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                            stmt.kind = StatementKind::Error {
+                                message: format!(
+                                    "Value identifier '{ident}' not found in variable table"
+                                ),
+                            };
+                            stmt.value = Value::Null;
+                        }
+                    }
+                }
+
+                StatementKind::Let { .. } => {
+                    if let Value::Identifier(ident) = &stmt.value {
+                        if let Some(val) = module.variable_table.get(ident) {
+                            stmt.value = val.clone();
+                        } else {
+                            if !is_valid_identifier(ident, module) {
+                                let message = format!(
+                                    "'{path}': value identifier '{ident}' not found in variable table"
+                                );
+
+                                logger.log_error_with_stacktrace(&message, &module.path);
+
+                                stmt.kind = StatementKind::Error {
+                                    message: format!(
+                                        "Value identifier '{ident}' not found in variable table"
+                                    ),
+                                };
+                                stmt.value = Value::Null;
+                            } else {
+                                stmt.value = Value::Identifier(ident.clone());
+                            }
+                        }
+                    }
+                }
+
+                StatementKind::Loop => {
+                    if let Value::Map(value_map) = &stmt.value {
+                        let iterator_value = match value_map.get("iterator") {
+                            Some(Value::Identifier(ident)) => {
+                                if let Some(val) = module.variable_table.get(ident) {
+                                    match val {
+                                        Value::Number(n) => Value::Number(*n),
+                                        _ => {
+                                            let message = format!(
+                                                "Loop iterator '{ident}' must resolve to a number"
+                                            );
+                                            let stacktrace = format!(
+                                                "{}:{}:{}",
+                                                module.path,
+                                                stmt.line,
+                                                stmt.column
+                                            );
+                                            logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                                            stmt.kind = StatementKind::Error {
+                                                message,
+                                            };
+                                            Value::Null
+                                        }
+                                    }
+                                } else {
+                                    let message = format!(
+                                        "'{path}': loop iterator '{ident}' not found in variable table"
+                                    );
+                                    let stacktrace = format!(
+                                        "{}:{}:{}",
+                                        module.path,
+                                        stmt.line,
+                                        stmt.column
+                                    );
+                                    logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                                    stmt.kind = StatementKind::Error {
+                                        message: format!("Loop iterator '{ident}' not found"),
+                                    };
+                                    Value::Null
+                                }
+                            }
+
+                            Some(Value::Number(n)) => Value::Number(*n),
+
+                            Some(v) => {
+                                let message = format!(
+                                    "Unexpected value for loop iterator: {:?}, expected number or identifier",
+                                    v
+                                );
+                                let stacktrace = format!(
+                                    "{}:{}:{}",
+                                    module.path,
+                                    stmt.line,
+                                    stmt.column
+                                );
+                                logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                                stmt.kind = StatementKind::Error {
+                                    message,
+                                };
+                                Value::Null
+                            }
+
+                            None => {
+                                let message = format!(
+                                    "Missing 'iterator' key in loop statement map"
+                                );
+                                let stacktrace = format!(
+                                    "{}:{}:{}",
+                                    module.path,
+                                    stmt.line,
+                                    stmt.column
+                                );
+                                logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                                stmt.kind = StatementKind::Error {
+                                    message,
+                                };
+                                Value::Null
+                            }
+                        };
+
+                        let body_value = value_map.get("body").cloned().unwrap_or(Value::Null);
+
+                        let mut loop_map = std::collections::HashMap::new();
+                        loop_map.insert("iterator".to_string(), iterator_value);
+                        loop_map.insert("body".to_string(), body_value);
+
+                        stmt.value = Value::Map(loop_map);
+                    } else {
+                        let message = format!(
+                            "'{path}': expected a map for loop value, found {:?}",
+                            stmt.value
+                        );
+                        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+
+                        logger.log_error_with_stacktrace(&message, &stacktrace);
+
+                        stmt.kind = StatementKind::Error {
+                            message: "Expected a map for loop value".to_string(),
+                        };
+                        stmt.value = Value::Null;
+                    }
+                }
+
+                StatementKind::Import { names, source } => {}
+
+                StatementKind::Export { names, source } => {}
+
+                _ => {}
+            }
+
+            resolved.push(stmt);
+        }
+
+        resolved_map.insert(path.clone(), resolved);
+    }
+
+    resolved_map
+}

package/rust/core/shared/duration.rs

@@ -0,0 +1,8 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum Duration {
+    Number(f32),
+    Identifier(String),
+    Auto,
+}

package/rust/core/shared/mod.rs

@@ -0,0 +1,2 @@
+pub mod value;
+pub mod duration;

package/rust/core/shared/value.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+use serde::{ Deserialize, Serialize };
+
+use crate::core::parser::statement::Statement;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Unknown,
+    Null,
+}

package/rust/core/store/export.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -0,0 +1,39 @@
+use std::collections::HashMap;
+use crate::core::preprocessor::module::Module;
+
+#[derive(Debug, Default, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+        }
+    }
+
+    pub fn resolve_all_imports(&mut self) {
+        for module in self.modules.values_mut() {
+            for (name, source_path) in &module.import_table.imports {
+                println!("Resolving import: {} from {:?}", name, source_path);
+            }
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
+        &mut self.modules
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+}

package/rust/core/store/import.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}

package/rust/core/store/mod.rs

@@ -0,0 +1,4 @@
+pub mod global;
+pub mod export;
+pub mod import;
+pub mod variable;

package/rust/core/store/variable.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        self.variables.get(name)
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}