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

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

@@ -1,118 +1,94 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::{condition::resolve_condition, trigger::resolve_trigger} },
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_group(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &GlobalStore
-) -> Statement {
-    let logger = Logger::new();
-
-    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)
-        }
-
-        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 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()
-    }
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn resolve_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(group_map) = &stmt.value else {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in group statement".to_string(),
+        );
+    };
+
+    // Check for the presence of the identifier field
+    let identifier = match group_map.get("identifier") {
+        Some(Value::String(id)) => id.clone(),
+        _ => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            );
+        }
+    };
+
+    // Ensure the identifier does not already exist
+    if global_store.variables.variables.contains_key(&identifier) {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Group identifier '{}' already exists", identifier),
+        );
+    }
+
+    // Resolve statements in the body
+    let mut resolved_map = group_map.clone();
+    if let Some(Value::Block(body)) = group_map.get("body") {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    } else {
+        logger.log_message(LogLevel::Warning, "Group without a body");
+    }
+
+    // Build a complete Statement for the group
+    let resolved_group_stmt = Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map.clone()),
+        ..stmt.clone()
+    };
+
+    // Store the Statement directly in the global variable_table
+    global_store.variables.variables.insert(
+        identifier.clone(),
+        Value::Statement(Box::new(resolved_group_stmt.clone())),
+    );
+
+    resolved_group_stmt
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .collect()
+}
+
+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/let_.rs

@@ -0,0 +1,32 @@
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::{module::Module, resolver::value::resolve_value},
+    store::global::GlobalStore,
+};
+
+pub fn resolve_let(
+    stmt: &Statement,
+    name: &str,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    global_store
+        .variables
+        .set(name.to_string(), resolved_value.clone());
+
+    if let Some(current_mod) = global_store.modules.get_mut(path) {
+        current_mod
+            .variable_table
+            .set(name.to_string(), resolved_value.clone());
+    } else {
+        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+    }
+
+    Statement {
+        value: resolved_value,
+        ..stmt.clone()
+    }
+}