@devaloop/devalang 0.0.1-beta.2 → 0.0.1-beta.3

package/rust/lib.rs

@@ -1,323 +1,323 @@
-pub mod config;
-pub mod core;
-
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
-    parser::statement::{Statement, StatementKind},
-    preprocessor::loader::ModuleLoader,
-    store::global::GlobalStore,
-};
-use devalang_types::{FunctionTable, Value, VariableTable};
-use devalang_utils::path::normalize_path;
-use serde::{Deserialize, Serialize};
-use serde_wasm_bindgen::to_value;
-use wasm_bindgen::prelude::*;
-
-#[derive(Serialize, Deserialize)]
-struct ParseResult {
-    ok: bool,
-    ast: String,
-    errors: Vec<ErrorResult>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct ErrorResult {
-    message: String,
-    line: usize,
-    column: usize,
-}
-
-#[wasm_bindgen]
-pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
-    let statements = parse_internal_from_string(entry_path, source);
-
-    match statements {
-        Ok(value) => {
-            let ast_string = value;
-            to_value(&ast_string)
-                .map_err(|e| JsValue::from_str(&format!("Error converting AST to JS value: {}", e)))
-        }
-        Err(e) => Err(JsValue::from_str(&format!("Error: {}", e))),
-    }
-}
-
-#[wasm_bindgen]
-pub fn debug_render(user_code: &str) -> Result<JsValue, JsValue> {
-    console_error_panic_hook::set_once();
-
-    let entry_path = normalize_path("playground.deva");
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
-
-    loader
-        .load_wasm_module(&mut global_store)
-        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
-
-    let all_statements_map = loader.extract_statements_map(&global_store);
-
-    let main_statements = all_statements_map
-        .get(&entry_path)
-        .ok_or(JsValue::from_str("No statements found for entry module"))?
-        .clone();
-
-    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
-
-    let _ = run_audio_program(
-        &main_statements,
-        &mut audio_engine,
-        "playground".to_string(),
-        "wasm_output".to_string(),
-        VariableTable::new(),
-        FunctionTable::new(),
-        &mut global_store,
-    );
-
-    // Inspect buffer to detect if any audio was produced. In test/CI
-    // environments it's common to produce no audio (silent program);
-    // callers rely on this flag for diagnostics.
-    let samples = audio_engine.get_normalized_buffer();
-    let any_nonzero = samples.iter().any(|&s| s != 0.0);
-
-    // Build parsed AST for diagnostics
-    let ast_res = parse_internal_from_string("playground.deva", user_code);
-    let ast_str = match ast_res {
-        Ok(p) => p.ast,
-        Err(_) => "".to_string(),
-    };
-
-    #[derive(Serialize)]
-    struct DebugResult {
-        samples_len: usize,
-        any_nonzero: bool,
-        ast: String,
-        note_count: usize,
-        global_vars: Vec<String>,
-        statements_count: usize,
-    }
-
-    let out = DebugResult {
-        samples_len: samples.len(),
-        any_nonzero,
-        ast: ast_str,
-        note_count: audio_engine.note_count,
-        global_vars: global_store.variables.variables.keys().cloned().collect(),
-        statements_count: main_statements.len(),
-    };
-
-    to_value(&out).map_err(|e| JsValue::from_str(&format!("Error converting debug result: {}", e)))
-}
-
-#[wasm_bindgen]
-pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
-    console_error_panic_hook::set_once();
-
-    let entry_path = normalize_path("playground.deva");
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
-
-    loader
-        .load_wasm_module(&mut global_store)
-        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
-
-    let all_statements_map = loader.extract_statements_map(&global_store);
-
-    let main_statements = all_statements_map
-        .get(&entry_path)
-        .ok_or(JsValue::from_str("No statements found for entry module"))?
-        .clone();
-
-    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
-
-    let _ = run_audio_program(
-        &main_statements,
-        &mut audio_engine,
-        "playground".to_string(),
-        "wasm_output".to_string(),
-        VariableTable::new(),
-        FunctionTable::new(),
-        &mut global_store,
-    );
-
-    let samples = audio_engine.get_normalized_buffer();
-
-    if samples.is_empty() {
-        // For test environments where no audio was scheduled, return a small
-        // silent buffer instead of failing. This helps tests proceed in CI.
-        let silent = vec![0.0f32; 1024];
-        return Ok(js_sys::Float32Array::from(silent.as_slice()));
-    }
-
-    Ok(js_sys::Float32Array::from(samples.as_slice()))
-}
-
-#[wasm_bindgen]
-#[allow(unused_variables)]
-pub fn register_playhead_callback(cb: &js_sys::Function) {
-    // Register a JS callback to receive playhead events during real-time
-    // playback. This is a no-op on non-wasm targets to keep the bindings
-    // portable for native builds.
-    // Only register if target supports wasm callbacks
-    #[cfg(target_arch = "wasm32")]
-    {
-        crate::core::audio::interpreter::driver::register_playhead_callback(cb.clone());
-    }
-}
-
-#[wasm_bindgen]
-#[allow(unused_variables)]
-pub fn collect_playhead_events() -> Result<JsValue, JsValue> {
-    #[cfg(target_arch = "wasm32")]
-    {
-        let events = crate::core::audio::interpreter::driver::collect_playhead_events();
-        to_value(&events).map_err(|e| JsValue::from_str(&format!("Error converting events: {}", e)))
-    }
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        // On non-wasm targets, return an empty array
-        to_value(&Vec::<String>::new()).map_err(|e| JsValue::from_str(&format!("Error: {}", e)))
-    }
-}
-
-#[wasm_bindgen]
-pub fn unregister_playhead_callback() {
-    #[cfg(target_arch = "wasm32")]
-    {
-        crate::core::audio::interpreter::driver::unregister_playhead_callback();
-    }
-}
-
-fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
-    let entry_path = normalize_path(virtual_path);
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, source, &mut global_store);
-
-    let module = loader
-        .load_single_module(&mut global_store)
-        .map_err(|e| format!("Error loading module: {}", e))?;
-
-    let raw_ast = ast_to_string(module.statements.clone());
-
-    let found_errors = collect_errors_recursively(&module.statements);
-
-    let result = ParseResult {
-        ok: true,
-        ast: raw_ast,
-        errors: found_errors,
-    };
-
-    Ok(result)
-}
-
-fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
-    let mut errors: Vec<ErrorResult> = Vec::new();
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Unknown => {
-                errors.push(ErrorResult {
-                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Error { message } => {
-                errors.push(ErrorResult {
-                    message: message.clone(),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Loop => {
-                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
-                    errors.extend(collect_errors_recursively(body_statements));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    errors
-}
-
-fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
-    if let Value::Map(map) = value {
-        if let Some(Value::Block(statements)) = map.get("body") {
-            return Some(statements);
-        }
-    }
-    None
-}
-
-fn ast_to_string(statements: Vec<Statement>) -> String {
-    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use devalang_types::{Statement, StatementKind, Value};
-
-    #[test]
-    fn test_extract_loop_body_statements_none() {
-        let v = Value::Map(std::collections::HashMap::new());
-        assert!(extract_loop_body_statements(&v).is_none());
-    }
-
-    #[test]
-    fn test_extract_loop_body_statements_some() {
-        let stmt = Statement::unknown();
-        let mut map = std::collections::HashMap::new();
-        map.insert("body".to_string(), Value::Block(vec![stmt.clone(), stmt]));
-
-        let v = Value::Map(map);
-        let res = extract_loop_body_statements(&v);
-        assert!(res.is_some());
-        let slice = res.unwrap();
-        assert_eq!(slice.len(), 2);
-    }
-
-    #[test]
-    fn test_collect_errors_recursively_detection() {
-        let mut statements: Vec<Statement> = Vec::new();
-
-        // Unknown statement should be reported
-        let s1 = Statement::unknown_with_pos(0, 10, 2);
-        statements.push(s1.clone());
-
-        // Error statement
-        let s2 = Statement::error_with_pos(0, 20, 4, "boom".to_string());
-        statements.push(s2.clone());
-
-        // Loop with body containing unknown
-        let body_stmt = Statement::unknown_with_pos(1, 30, 5);
-        let mut loop_map = std::collections::HashMap::new();
-        loop_map.insert("body".to_string(), Value::Block(vec![body_stmt.clone()]));
-
-        let loop_stmt = Statement {
-            kind: StatementKind::Loop,
-            value: Value::Map(loop_map),
-            indent: 0,
-            line: 15,
-            column: 1,
-        };
-        statements.push(loop_stmt);
-
-        let errors = collect_errors_recursively(&statements);
-        // expect three errors: s1 unknown, s2 error, body unknown
-        assert_eq!(errors.len(), 3);
-        assert!(errors.iter().any(|e| e.line == 10));
-        assert!(errors.iter().any(|e| e.line == 20));
-        assert!(errors.iter().any(|e| e.line == 30));
-    }
-}
+pub mod config;
+pub mod core;
+
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
+    parser::statement::{Statement, StatementKind},
+    preprocessor::loader::ModuleLoader,
+    store::global::GlobalStore,
+};
+use devalang_types::{FunctionTable, Value, VariableTable};
+use devalang_utils::path::normalize_path;
+use serde::{Deserialize, Serialize};
+use serde_wasm_bindgen::to_value;
+use wasm_bindgen::prelude::*;
+
+#[derive(Serialize, Deserialize)]
+struct ParseResult {
+    ok: bool,
+    ast: String,
+    errors: Vec<ErrorResult>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct ErrorResult {
+    message: String,
+    line: usize,
+    column: usize,
+}
+
+#[wasm_bindgen]
+pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
+    let statements = parse_internal_from_string(entry_path, source);
+
+    match statements {
+        Ok(value) => {
+            let ast_string = value;
+            to_value(&ast_string)
+                .map_err(|e| JsValue::from_str(&format!("Error converting AST to JS value: {}", e)))
+        }
+        Err(e) => Err(JsValue::from_str(&format!("Error: {}", e))),
+    }
+}
+
+#[wasm_bindgen]
+pub fn debug_render(user_code: &str) -> Result<JsValue, JsValue> {
+    console_error_panic_hook::set_once();
+
+    let entry_path = normalize_path("playground.deva");
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+
+    let loader =
+        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
+
+    loader
+        .load_wasm_module(&mut global_store)
+        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
+
+    let all_statements_map = loader.extract_statements_map(&global_store);
+
+    let main_statements = all_statements_map
+        .get(&entry_path)
+        .ok_or(JsValue::from_str("No statements found for entry module"))?
+        .clone();
+
+    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
+
+    let _ = run_audio_program(
+        &main_statements,
+        &mut audio_engine,
+        "playground".to_string(),
+        "wasm_output".to_string(),
+        VariableTable::new(),
+        FunctionTable::new(),
+        &mut global_store,
+    );
+
+    // Inspect buffer to detect if any audio was produced. In test/CI
+    // environments it's common to produce no audio (silent program);
+    // callers rely on this flag for diagnostics.
+    let samples = audio_engine.get_normalized_buffer();
+    let any_nonzero = samples.iter().any(|&s| s != 0.0);
+
+    // Build parsed AST for diagnostics
+    let ast_res = parse_internal_from_string("playground.deva", user_code);
+    let ast_str = match ast_res {
+        Ok(p) => p.ast,
+        Err(_) => "".to_string(),
+    };
+
+    #[derive(Serialize)]
+    struct DebugResult {
+        samples_len: usize,
+        any_nonzero: bool,
+        ast: String,
+        note_count: usize,
+        global_vars: Vec<String>,
+        statements_count: usize,
+    }
+
+    let out = DebugResult {
+        samples_len: samples.len(),
+        any_nonzero,
+        ast: ast_str,
+        note_count: audio_engine.note_count,
+        global_vars: global_store.variables.variables.keys().cloned().collect(),
+        statements_count: main_statements.len(),
+    };
+
+    to_value(&out).map_err(|e| JsValue::from_str(&format!("Error converting debug result: {}", e)))
+}
+
+#[wasm_bindgen]
+pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
+    console_error_panic_hook::set_once();
+
+    let entry_path = normalize_path("playground.deva");
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+
+    let loader =
+        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
+
+    loader
+        .load_wasm_module(&mut global_store)
+        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
+
+    let all_statements_map = loader.extract_statements_map(&global_store);
+
+    let main_statements = all_statements_map
+        .get(&entry_path)
+        .ok_or(JsValue::from_str("No statements found for entry module"))?
+        .clone();
+
+    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
+
+    let _ = run_audio_program(
+        &main_statements,
+        &mut audio_engine,
+        "playground".to_string(),
+        "wasm_output".to_string(),
+        VariableTable::new(),
+        FunctionTable::new(),
+        &mut global_store,
+    );
+
+    let samples = audio_engine.get_normalized_buffer();
+
+    if samples.is_empty() {
+        // For test environments where no audio was scheduled, return a small
+        // silent buffer instead of failing. This helps tests proceed in CI.
+        let silent = vec![0.0f32; 1024];
+        return Ok(js_sys::Float32Array::from(silent.as_slice()));
+    }
+
+    Ok(js_sys::Float32Array::from(samples.as_slice()))
+}
+
+#[wasm_bindgen]
+#[allow(unused_variables)]
+pub fn register_playhead_callback(cb: &js_sys::Function) {
+    // Register a JS callback to receive playhead events during real-time
+    // playback. This is a no-op on non-wasm targets to keep the bindings
+    // portable for native builds.
+    // Only register if target supports wasm callbacks
+    #[cfg(target_arch = "wasm32")]
+    {
+        crate::core::audio::interpreter::driver::register_playhead_callback(cb.clone());
+    }
+}
+
+#[wasm_bindgen]
+#[allow(unused_variables)]
+pub fn collect_playhead_events() -> Result<JsValue, JsValue> {
+    #[cfg(target_arch = "wasm32")]
+    {
+        let events = crate::core::audio::interpreter::driver::collect_playhead_events();
+        to_value(&events).map_err(|e| JsValue::from_str(&format!("Error converting events: {}", e)))
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        // On non-wasm targets, return an empty array
+        to_value(&Vec::<String>::new()).map_err(|e| JsValue::from_str(&format!("Error: {}", e)))
+    }
+}
+
+#[wasm_bindgen]
+pub fn unregister_playhead_callback() {
+    #[cfg(target_arch = "wasm32")]
+    {
+        crate::core::audio::interpreter::driver::unregister_playhead_callback();
+    }
+}
+
+fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
+    let entry_path = normalize_path(virtual_path);
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+    let loader =
+        ModuleLoader::from_raw_source(&entry_path, &output_path, source, &mut global_store);
+
+    let module = loader
+        .load_single_module(&mut global_store)
+        .map_err(|e| format!("Error loading module: {}", e))?;
+
+    let raw_ast = ast_to_string(module.statements.clone());
+
+    let found_errors = collect_errors_recursively(&module.statements);
+
+    let result = ParseResult {
+        ok: true,
+        ast: raw_ast,
+        errors: found_errors,
+    };
+
+    Ok(result)
+}
+
+fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+fn ast_to_string(statements: Vec<Statement>) -> String {
+    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use devalang_types::{Statement, StatementKind, Value};
+
+    #[test]
+    fn test_extract_loop_body_statements_none() {
+        let v = Value::Map(std::collections::HashMap::new());
+        assert!(extract_loop_body_statements(&v).is_none());
+    }
+
+    #[test]
+    fn test_extract_loop_body_statements_some() {
+        let stmt = Statement::unknown();
+        let mut map = std::collections::HashMap::new();
+        map.insert("body".to_string(), Value::Block(vec![stmt.clone(), stmt]));
+
+        let v = Value::Map(map);
+        let res = extract_loop_body_statements(&v);
+        assert!(res.is_some());
+        let slice = res.unwrap();
+        assert_eq!(slice.len(), 2);
+    }
+
+    #[test]
+    fn test_collect_errors_recursively_detection() {
+        let mut statements: Vec<Statement> = Vec::new();
+
+        // Unknown statement should be reported
+        let s1 = Statement::unknown_with_pos(0, 10, 2);
+        statements.push(s1.clone());
+
+        // Error statement
+        let s2 = Statement::error_with_pos(0, 20, 4, "boom".to_string());
+        statements.push(s2.clone());
+
+        // Loop with body containing unknown
+        let body_stmt = Statement::unknown_with_pos(1, 30, 5);
+        let mut loop_map = std::collections::HashMap::new();
+        loop_map.insert("body".to_string(), Value::Block(vec![body_stmt.clone()]));
+
+        let loop_stmt = Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(loop_map),
+            indent: 0,
+            line: 15,
+            column: 1,
+        };
+        statements.push(loop_stmt);
+
+        let errors = collect_errors_recursively(&statements);
+        // expect three errors: s1 unknown, s2 error, body unknown
+        assert_eq!(errors.len(), 3);
+        assert!(errors.iter().any(|e| e.line == 10));
+        assert!(errors.iter().any(|e| e.line == 20));
+        assert!(errors.iter().any(|e| e.line == 30));
+    }
+}

package/rust/macros/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "devalang_macros"
+description = "Macros for Devalang"
+license = "MIT"
+version = "0.0.1"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2", features = ["full"] }