@devaloop/devalang 0.0.1-beta.2 → 0.1.1

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

@@ -1,324 +0,0 @@
-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,
-        },
-    },
-    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() {
-        resolve_imports(module_loader, global_store);
-    }
-}
-
-pub fn resolve_statement(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    match &stmt.kind {
-        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::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),
-
-        _ => {
-            let resolved_value = resolve_value(&stmt.value, module, global_store);
-
-            Statement {
-                value: resolved_value,
-                ..stmt.clone()
-            }
-        }
-    }
-}
-
-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) {
-                return resolve_value(original_val, module, global_store);
-            }
-
-            if let Some(export_val) = find_export_value(name, global_store) {
-                return resolve_value(&export_val, module, global_store);
-            }
-
-            // 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) => {
-            let mut resolved = HashMap::new();
-            for (k, v) in map {
-                resolved.insert(k.clone(), resolve_value(v, module, global_store));
-            }
-            Value::Map(resolved)
-        }
-
-        Value::Block(stmts) => {
-            let resolved_stmts = stmts
-                .iter()
-                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
-                .collect();
-            Value::Block(resolved_stmts)
-        }
-
-        other => other.clone(),
-    }
-}
-
-fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for module in global_store.modules.values() {
-        if let Some(val) = module.export_table.get_export(name) {
-            return Some(val.clone());
-        }
-    }
-    None
-}
-
-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 {
-                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 {
-                            logger.log_message(LogLevel::Warning, &format!("[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"));
-                        }
-                    } else {
-                        logger.log_message(
-                            LogLevel::Warning,
-                            &format!(
-                                "[warn] '{module_path}': cannot find source module '{source_path}'"
-                            ),
-                        );
-                    }
-                }
-                _ => {
-                    logger.log_message(
-                        LogLevel::Warning,
-                        &format!(
-                            "[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();
-    for (path, module) in global_store.modules.clone() {
-        let mut resolved = Vec::new();
-
-        for stmt in &module.statements {
-            let stmt = stmt.clone();
-
-            match &stmt.kind {
-                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,
-                    );
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Loop => {
-                    let resolved_stmt = resolve_loop(&stmt, &module, &path, global_store);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Bank { .. } => {
-                    let resolved_stmt = resolve_bank(&stmt, &module, &path, global_store);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Tempo => {
-                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, global_store);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Import { .. } | StatementKind::Export { .. } => {
-                    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);
-                }
-            }
-        }
-
-        resolved_map.insert(path.clone(), resolved);
-    }
-
-    resolved_map
-}

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

@@ -1,69 +0,0 @@
-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,122 +0,0 @@
-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,32 +0,0 @@
-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()
-    }
-}