@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.1

package/rust/core/preprocessor/mod.rs

@@ -1,4 +1,4 @@
-pub mod module;
-pub mod loader;
-pub mod resolver;
-pub mod processor;
+pub mod loader;
+pub mod module;
+pub mod processor;
+pub mod resolver;

package/rust/core/preprocessor/module.rs

@@ -1,50 +1,60 @@
-use crate::core::{
-    lexer::token::Token,
-    parser::statement::Statement,
-    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
-};
-
-#[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,
-}
-
-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(),
-        }
-    }
-
-    pub fn is_resolved(&self) -> bool {
-        self.resolved
-    }
-
-    pub fn set_resolved(&mut self, resolved: bool) {
-        self.resolved = resolved;
-    }
-
-    pub fn add_token(&mut self, token: Token) {
-        self.tokens.push(token);
-    }
-
-    pub fn add_statement(&mut self, statement: Statement) {
-        self.statements.push(statement);
-    }
-}
+use crate::core::{
+    lexer::token::Token,
+    parser::statement::Statement,
+    store::{
+        export::ExportTable, function::FunctionTable, import::ImportTable, variable::VariableTable,
+    },
+};
+
+#[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 function_table: FunctionTable,
+    pub export_table: ExportTable,
+    pub import_table: ImportTable,
+    pub content: String,
+    pub current_dir: String,
+}
+
+impl Module {
+    pub fn new(path: &str) -> Self {
+        Module {
+            path: path.to_string(),
+            tokens: Vec::new(),
+            statements: Vec::new(),
+            variable_table: VariableTable::new(),
+            function_table: FunctionTable::new(),
+            export_table: ExportTable::new(),
+            import_table: ImportTable::new(),
+            resolved: false,
+            content: String::new(),
+            current_dir: String::new(),
+        }
+    }
+
+    pub fn is_resolved(&self) -> bool {
+        self.resolved
+    }
+
+    pub fn set_resolved(&mut self, resolved: bool) {
+        self.resolved = resolved;
+    }
+
+    pub fn add_token(&mut self, token: Token) {
+        self.tokens.push(token);
+    }
+
+    pub fn add_statement(&mut self, statement: Statement) {
+        self.statements.push(statement);
+    }
+
+    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

@@ -1,76 +1,114 @@
-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);
-                        }
-                    }
-                }
-
-                _ => {}
-            }
-        }
-    }
-}
+use std::{collections::HashMap, path::Path};
+
+use crate::core::{
+    parser::statement::StatementKind,
+    preprocessor::loader::ModuleLoader,
+    store::global::GlobalStore,
+    utils::path::{normalize_path, resolve_relative_path},
+};
+use devalang_types::Value;
+
+pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for module in global_store.modules.values_mut() {
+        let logger = devalang_utils::logger::Logger::new();
+        use devalang_utils::logger::LogLevel;
+
+        for stmt in &module.statements {
+            match &stmt.kind {
+                StatementKind::Let { name } => {
+                    if let Value::Null = stmt.value {
+                        logger.log_message(
+                            LogLevel::Error,
+                            &format!("Variable '{}' is declared but not initialized.", name),
+                        );
+
+                        module.variable_table.variables.insert(
+                            name.clone(),
+                            Value::StatementKind(Box::new(stmt.kind.clone())),
+                        );
+
+                        continue;
+                    }
+
+                    if module.variable_table.get(name).is_some() {
+                        logger.log_message(
+                            LogLevel::Error,
+                            &format!("Variable '{}' is already defined in this scope.", name),
+                        );
+                        continue;
+                    }
+
+                    if let Some(module_variable) = module.variable_table.variables.get(name) {
+                        logger.log_message(
+                            LogLevel::Error,
+                            &format!(
+                                "Variable '{}' is already defined globally with value: {:?}",
+                                name, module_variable
+                            ),
+                        );
+                        continue;
+                    }
+
+                    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 {
+                            logger.log_message(
+                                LogLevel::Error,
+                                &format!("Invalid group definition: {:?}", stmt.value),
+                            );
+                        }
+                    }
+                }
+
+                _ => {}
+            }
+        }
+    }
+}

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

@@ -1,47 +1,49 @@
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_bank(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    _global_store: &GlobalStore
-) -> Statement {
-    let mut new_stmt = stmt.clone();
-    let logger = Logger::new();
-
-    match &stmt.value {
-        Value::Identifier(ident) => {
-            if let Some(val) = module.variable_table.get(ident) {
-                new_stmt.value = val.clone();
-            } else {
-                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;
-            }
-        }
-
-        Value::String(_) => {}
-
-        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
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
+
+pub fn resolve_bank(
+    stmt: &Statement,
+    module: &Module,
+    _path: &str,
+    _global_store: &GlobalStore,
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                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;
+            }
+        }
+
+        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
+}