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

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

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        preprocessor::{ module::Module, resolver::{condition::resolve_condition, trigger::resolve_trigger} },
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -18,96 +18,101 @@ pub fn resolve_group(
 ) -> Statement {
     let logger = Logger::new();
 
-    if let Value::Map(value_map) = &stmt.value {
-        let group_name = match value_map.get("identifier") {
-            Some(Value::String(name)) => name.clone(),
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Group name must be a string, found {:?}", other)
-                );
-                return stmt.clone();
-            }
-            None => {
-                log_type_error(&logger, module, stmt, "Group name is required".to_string());
-                return stmt.clone();
-            }
-        };
-
-        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 group body statement: {:?}", statement);
-                        }
+    let Value::Map(value_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map for group statement".to_string());
+    };
+
+    let group_name = match value_map.get("identifier") {
+        Some(Value::String(name)) => name.clone(),
+        Some(other) => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                format!("Group name must be a string, found {:?}", other)
+            );
+        }
+        None => {
+            return type_error(&logger, module, stmt, "Group name is required".to_string());
+        }
+    };
+
+    let resolved_body = match value_map.get("body") {
+        Some(Value::Block(statements)) => {
+            let mut resolved = Vec::new();
+
+            for stmt in statements {
+                match &stmt.kind {
+                    StatementKind::Trigger { entity, duration } => {
+                        let resolved_trigger = resolve_trigger(
+                            &mut stmt.clone(),
+                            entity,
+                            &mut duration.clone(),
+                            module,
+                            path,
+                            global_store
+                        );
+
+                        resolved.push(resolved_trigger);
+                    }
+
+                    StatementKind::If => {
+                        let resolved_condition = resolve_condition(
+                            &mut stmt.clone(),
+                            module,
+                            path,
+                            global_store
+                        );
+
+                        resolved.push(resolved_condition);
+                    }
+
+                    _ => {
+                        println!("Unhandled group body statement: {:?}", stmt);
                     }
                 }
-                Value::Block(resolved_block)
-            }
-            Some(other) => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    format!("Unexpected value for group body: {:?}", other)
-                );
-                Value::Null
-            }
-            None => {
-                log_type_error(
-                    &logger,
-                    module,
-                    stmt,
-                    "Missing 'body' key in group statement map".to_string()
-                );
-                Value::Null
             }
-        };
-
-        let mut resolved_map = HashMap::new();
-
-        resolved_map.insert("identifier".to_string(), Value::String(group_name));
-        resolved_map.insert("body".to_string(), body_value);
-
-        return Statement {
-            kind: StatementKind::Group,
-            value: Value::Map(resolved_map),
-            ..stmt.clone()
-        };
-    } else {
-        log_type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Expected Map for group statement, found {:?}", stmt.value)
-        );
-
-        Statement {
-            kind: StatementKind::Error {
-                message: "Expected a map for group statement".to_string(),
-            },
-            value: Value::Null,
-            ..stmt.clone()
+
+            Value::Block(resolved)
+        }
+
+        Some(other) => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                format!("Unexpected value for group body: {:?}", other)
+            );
         }
+
+        None => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                "Missing 'body' key in group statement".to_string()
+            );
+        }
+    };
+
+    let mut resolved_map = HashMap::new();
+    resolved_map.insert("identifier".to_string(), Value::String(group_name));
+    resolved_map.insert("body".to_string(), resolved_body);
+
+    Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
     }
 }
 
-fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+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/mod.rs

@@ -1,158 +1,10 @@
+pub mod driver;
+
 pub mod trigger;
 pub mod loop_;
 pub mod bank;
 pub mod tempo;
 pub mod group;
-
-use std::collections::HashMap;
-use crate::{
-    core::{
-        parser::statement::{ self, Statement, StatementKind },
-        preprocessor::{
-            loader::ModuleLoader,
-            resolver::{
-                bank::resolve_bank,
-                group::resolve_group,
-                loop_::resolve_loop,
-                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_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
-}
+pub mod condition;
+pub mod spawn;
+pub mod call;

package/rust/core/preprocessor/resolver/spawn.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_spawn(
+    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, "Spawn expects a group name as string.".to_string());
+    };
+
+    match module.variable_table.variables.get(name) {
+        Some(Value::Map(group_stmt)) => Statement {
+            kind: StatementKind::Spawn,
+            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()
+    }
+}