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

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

@@ -1,30 +1,24 @@
-use std::collections::HashMap;
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{
-            loader::ModuleLoader,
-            module::Module,
-            resolver::{
-                bank::resolve_bank,
-                call::resolve_call,
-                condition::resolve_condition,
-                group::resolve_group,
-                let_::resolve_let,
-                loop_::resolve_loop,
-                spawn::resolve_spawn,
-                tempo::resolve_tempo,
-                trigger::resolve_trigger,
-            },
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        loader::ModuleLoader,
+        module::Module,
+        resolver::{
+            bank::resolve_bank, call::resolve_call, condition::resolve_condition,
+            function::resolve_function, group::resolve_group, let_::resolve_let,
+            loop_::resolve_loop, pattern::resolve_pattern, spawn::resolve_spawn,
+            tempo::resolve_tempo, trigger::resolve_trigger,
         },
-        shared::value::Value,
-        store::global::GlobalStore,
     },
-    utils::logger::Logger,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::LogLevel;
+use devalang_utils::logger::Logger;
+use std::collections::HashMap;
 
 pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.clone().modules.values_mut() {
+    for _module in global_store.clone().modules.values_mut() {
         resolve_imports(module_loader, global_store);
     }
 }
@@ -33,16 +27,55 @@ pub fn resolve_statement(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore
+    global_store: &mut GlobalStore,
 ) -> Statement {
     match &stmt.kind {
-        StatementKind::Trigger { entity, duration } =>
-            resolve_trigger(stmt, entity, &mut duration.clone(), module, path, global_store),
+        StatementKind::On { event, args, body } => {
+            let resolved_body: Vec<Statement> = body
+                .iter()
+                .map(|s| resolve_statement(s, module, path, global_store))
+                .collect();
+            Statement {
+                kind: StatementKind::On {
+                    event: event.clone(),
+                    args: args.clone(),
+                    body: resolved_body,
+                },
+                value: resolve_value(&stmt.value, module, global_store),
+                ..stmt.clone()
+            }
+        }
+        StatementKind::Emit { event, payload: _ } => Statement {
+            kind: StatementKind::Emit {
+                event: event.clone(),
+                payload: Some(resolve_value(&stmt.value, module, global_store)),
+            },
+            value: resolve_value(&stmt.value, module, global_store),
+            ..stmt.clone()
+        },
+        StatementKind::Trigger {
+            entity,
+            duration,
+            effects,
+        } => resolve_trigger(
+            stmt,
+            entity,
+            &mut duration.clone(),
+            effects.clone(),
+            module,
+            path,
+            global_store,
+        ),
         StatementKind::If => resolve_condition(stmt, module, path, global_store),
         StatementKind::Group => resolve_group(stmt, module, path, global_store),
-        StatementKind::Call => resolve_call(stmt, module, path, global_store),
-        StatementKind::Spawn => resolve_spawn(stmt, module, path, global_store),
-        StatementKind::Bank => resolve_bank(stmt, module, path, global_store),
+        StatementKind::Pattern { .. } => resolve_pattern(stmt, module, path, global_store),
+        StatementKind::Call { name, args } => {
+            resolve_call(stmt, name.clone(), args.clone(), module, path, global_store)
+        }
+        StatementKind::Spawn { name, args } => {
+            resolve_spawn(stmt, name.clone(), args.clone(), module, path, global_store)
+        }
+        StatementKind::Bank { .. } => resolve_bank(stmt, module, path, global_store),
         StatementKind::Tempo => resolve_tempo(stmt, module, path, global_store),
         StatementKind::Loop => resolve_loop(stmt, module, path, global_store),
         StatementKind::Let { name, .. } => resolve_let(stmt, name, module, path, global_store),
@@ -59,6 +92,7 @@ pub fn resolve_statement(
 }
 
 fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    let logger = Logger::new();
     match value {
         Value::Identifier(name) => {
             if let Some(original_val) = module.variable_table.get(name) {
@@ -69,8 +103,18 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
                 return resolve_value(&export_val, module, global_store);
             }
 
-            eprintln!("⚠️ Unresolved identifier '{}'", name);
-            Value::Null
+            // Leave unresolved identifiers as-is; they might be runtime-bound (e.g., foreach vars)
+            Value::Identifier(name.clone())
+        }
+
+        Value::String(s) => Value::String(s.clone()),
+
+        Value::Beat(beat_str) => {
+            logger.log_message(
+                LogLevel::Warning,
+                &format!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str),
+            );
+            Value::Beat(beat_str.clone())
         }
 
         Value::Map(map) => {
@@ -94,7 +138,7 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
 }
 
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for (_path, module) in &global_store.modules {
+    for module in global_store.modules.values() {
         if let Some(val) = module.export_table.get_export(name) {
             return Some(val.clone());
         }
@@ -102,7 +146,8 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
     None
 }
 
-pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+pub fn resolve_imports(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    let logger = Logger::new();
     for (module_path, module) in global_store.clone().modules.iter_mut() {
         for (name, source_path) in &module.import_table.imports {
             match source_path {
@@ -111,20 +156,24 @@ pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                         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}'"
-                            );
+                            logger.log_message(LogLevel::Warning, &format!("[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"));
                         }
                     } else {
-                        println!(
-                            "[warn] '{module_path}': cannot find source module '{source_path}'"
+                        logger.log_message(
+                            LogLevel::Warning,
+                            &format!(
+                                "[warn] '{module_path}': cannot find source module '{source_path}'"
+                            ),
                         );
                     }
                 }
                 _ => {
-                    println!(
-                        "[warn] '{module_path}': expected string for import source, found {:?}",
-                        source_path
+                    logger.log_message(
+                        LogLevel::Warning,
+                        &format!(
+                            "[warn] '{module_path}': expected string for import source, found {:?}",
+                            source_path
+                        ),
                     );
                 }
             }
@@ -133,7 +182,7 @@ pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalSt
 }
 
 pub fn resolve_and_flatten_all_modules(
-    global_store: &mut GlobalStore
+    global_store: &mut GlobalStore,
 ) -> HashMap<String, Vec<Statement>> {
     let logger = Logger::new();
     let snapshot = global_store.clone();
@@ -149,21 +198,21 @@ pub fn resolve_and_flatten_all_modules(
                         } else {
                             logger.log_error_with_stacktrace(
                                 &format!("'{name}' not found in exports of '{source_path_str}'"),
-                                module_path
+                                module_path,
                             );
                         }
                     }
                     None => {
                         logger.log_error_with_stacktrace(
                             &format!("Cannot find source module '{source_path_str}'"),
-                            module_path
+                            module_path,
                         );
                     }
                 }
             } else {
                 logger.log_error_with_stacktrace(
                     &format!("Expected string for import source, found {:?}", source_path),
-                    module_path
+                    module_path,
                 );
             }
         }
@@ -175,17 +224,27 @@ pub fn resolve_and_flatten_all_modules(
         let mut resolved = Vec::new();
 
         for stmt in &module.statements {
-            let mut stmt = stmt.clone();
+            let stmt = stmt.clone();
 
             match &stmt.kind {
-                StatementKind::Trigger { entity, duration } => {
+                StatementKind::Let { name } => {
+                    let resolved_stmt = resolve_let(&stmt, name, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Trigger {
+                    entity,
+                    duration,
+                    effects,
+                } => {
                     let resolved_stmt = resolve_trigger(
                         &stmt,
                         entity.as_str(),
                         &mut duration.clone(),
+                        effects.clone(),
                         &module,
                         &path,
-                        global_store
+                        global_store,
                     );
                     resolved.push(resolved_stmt);
                 }
@@ -195,7 +254,7 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(resolved_stmt);
                 }
 
-                StatementKind::Bank => {
+                StatementKind::Bank { .. } => {
                     let resolved_stmt = resolve_bank(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
@@ -209,11 +268,49 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(stmt.clone());
                 }
 
+                StatementKind::Call { name, args } => {
+                    let resolved_stmt = resolve_call(
+                        &stmt,
+                        name.clone(),
+                        args.clone(),
+                        &module,
+                        &path,
+                        global_store,
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Spawn { name, args } => {
+                    let resolved_stmt = resolve_spawn(
+                        &stmt,
+                        name.clone(),
+                        args.clone(),
+                        &module,
+                        &path,
+                        global_store,
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
                 StatementKind::Group => {
                     let resolved_stmt = resolve_group(&stmt, &module, &path, global_store);
                     resolved.push(resolved_stmt);
                 }
 
+                StatementKind::Pattern { .. } => {
+                    let resolved_stmt = resolve_pattern(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Function {
+                    name: _,
+                    parameters: _,
+                    body: _,
+                } => {
+                    let resolved_function = resolve_function(&stmt, &module, &path, global_store);
+                    resolved.push(resolved_function);
+                }
+
                 _ => {
                     resolved.push(stmt);
                 }

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

@@ -0,0 +1,69 @@
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::{FunctionDef, Value};
+
+pub fn resolve_function(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    if let StatementKind::Function {
+        name,
+        parameters,
+        body,
+    } = &stmt.kind
+    {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+
+        global_store.functions.add_function(FunctionDef {
+            name: name.clone(),
+            parameters: parameters.clone(),
+            body: resolved_body.clone(),
+        });
+
+        if let Some(current_mod) = global_store.modules.get_mut(path) {
+            current_mod.function_table.add_function(FunctionDef {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body.clone(),
+            });
+        } else {
+            eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+        }
+
+        Statement {
+            kind: StatementKind::Function {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body,
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    } else {
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a function statement".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    }
+}
+
+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()
+}
+
+// (removed unused helper type_error)

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

@@ -1,61 +1,122 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
-        shared::value::Value,
-        store::{ global::GlobalStore, variable::VariableTable },
-    },
-    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());
-    };
-
-    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");
-    }
-
-    Statement {
-        kind: StatementKind::Group,
-        value: Value::Map(resolved_map),
-        ..stmt.clone()
-    }
-}
-
-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()
-    }
-}
+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();
+
+    // Extract identifier from several allowed shapes (map.identifier, bare string, number -> to_string)
+    let identifier = match extract_group_identifier(stmt, &logger, module) {
+        Ok(id) => id,
+        Err(err_stmt) => return err_stmt,
+    };
+
+    // group_map: if the value is a map we clone it, otherwise create an empty map to hold body
+    let group_map = match &stmt.value {
+        Value::Map(m) => m.clone(),
+        _ => std::collections::HashMap::new(),
+    };
+
+    // 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()
+    }
+}
+
+// Helper to extract a group identifier from multiple Value forms
+fn extract_group_identifier(
+    stmt: &Statement,
+    logger: &Logger,
+    module: &Module,
+) -> Result<String, Statement> {
+    match &stmt.value {
+        Value::Map(map) => match map.get("identifier") {
+            Some(Value::String(s)) => Ok(s.clone()),
+            Some(Value::Identifier(s)) => Ok(s.clone()),
+            Some(Value::Number(n)) => Ok(n.to_string()),
+            Some(other) => Err(type_error(
+                logger,
+                module,
+                stmt,
+                format!("Unsupported type for 'identifier': {:?}", other),
+            )),
+            None => Err(type_error(
+                logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            )),
+        },
+        Value::String(s) => Ok(s.clone()),
+        Value::Identifier(s) => Ok(s.clone()),
+        other => Err(type_error(
+            logger,
+            module,
+            stmt,
+            format!(
+                "Expected a map or string for group statement, found {:?}",
+                other
+            ),
+        )),
+    }
+}

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

@@ -1,25 +1,26 @@
-use crate::
-    core::{
-        parser::statement:: Statement ,
-        preprocessor::{
-            module::Module,
-            resolver:: value::resolve_value ,
-        },
-        store:: global::GlobalStore ,
-    }
-;
+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
+    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());
+        current_mod
+            .variable_table
+            .set(name.to_string(), resolved_value.clone());
     } else {
         eprintln!("[resolve_statement] ❌ Module path not found: {path}");
     }