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

package/rust/core/parser/handler/identifier/let_.rs

@@ -0,0 +1,173 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        handler::{dot::parse_dot_token, identifier::synth::parse_synth_token},
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+pub fn parse_let_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "let"
+
+    let identifier = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Identifier {
+            parser.advance();
+            token.lexeme.clone()
+        } else {
+            return crate::core::parser::statement::error_from_token(
+                token,
+                "Expected identifier after 'let'".to_string(),
+            );
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected identifier after 'let'".to_string(),
+        );
+    };
+
+    if !parser.match_token(TokenKind::Equals) {
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected '=' after identifier".to_string(),
+        );
+    }
+
+    // If RHS begins with '$' or contains expression tokens ('+', '-', '*', '/', '(', '['),
+    // collect the rest of the line as a raw expression string.
+    if let Some(tok) = parser.peek_clone() {
+        let line = tok.line;
+        if tok.lexeme.starts_with('$')
+            || matches!(
+                tok.kind,
+                TokenKind::Identifier | TokenKind::Number | TokenKind::LParen | TokenKind::LBracket
+            )
+        {
+            // Collect tokens until end of the current line
+            let collected = parser.collect_until(|t| {
+                t.line != line || matches!(t.kind, TokenKind::Newline | TokenKind::EOF)
+            });
+            let mut text = String::new();
+            for t in collected.iter() {
+                if matches!(t.kind, TokenKind::Newline | TokenKind::EOF) {
+                    break;
+                }
+                text.push_str(&t.lexeme);
+            }
+            return Statement {
+                kind: StatementKind::Let { name: identifier },
+                value: Value::String(text.trim().to_string()),
+                indent: current_token.indent,
+                line: current_token.line,
+                column: current_token.column,
+            };
+        }
+    }
+
+    let value = match parser.peek_clone() {
+        Some(token) if token.kind == TokenKind::Dot => {
+            let dot_stmt = parse_dot_token(parser, global_store);
+            Value::Statement(Box::new(dot_stmt))
+        }
+        Some(token) if token.kind == TokenKind::Synth => {
+            let synth_stmt = parse_synth_token(parser, token.clone(), global_store);
+            Value::Statement(Box::new(synth_stmt))
+        }
+        Some(token) if token.kind == TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::String => {
+            parser.advance();
+            Value::String(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::Number => {
+            parser.advance();
+            Value::Number(token.lexeme.parse().unwrap_or(0.0))
+        }
+        Some(token) if token.kind == TokenKind::Boolean => {
+            parser.advance();
+            Value::Boolean(token.lexeme.parse().unwrap_or(false))
+        }
+        Some(token) if token.kind == TokenKind::LBrace => {
+            parser.advance();
+
+            let mut map = HashMap::new();
+
+            while let Some(key_token) = parser.peek_clone() {
+                if key_token.kind == TokenKind::RBrace {
+                    parser.advance(); // consume '}'
+                    break;
+                }
+
+                if key_token.kind != TokenKind::Identifier {
+                    return crate::core::parser::statement::error_from_token(
+                        token,
+                        "Expected key identifier in map".to_string(),
+                    );
+                }
+                parser.advance();
+                let key = key_token.lexeme.clone();
+
+                if !parser.match_token(TokenKind::Colon) {
+                    let message = format!("Expected ':' after key '{}'", key);
+                    return crate::core::parser::statement::error_from_token(token, message);
+                }
+
+                let val = match parser.peek_clone() {
+                    Some(t) if t.kind == TokenKind::Number => {
+                        parser.advance();
+                        Value::Number(t.lexeme.parse().unwrap_or(0.0))
+                    }
+                    Some(t) if t.kind == TokenKind::String => {
+                        parser.advance();
+                        Value::String(t.lexeme.clone())
+                    }
+                    Some(t) if t.kind == TokenKind::Identifier => {
+                        parser.advance();
+                        Value::Identifier(t.lexeme.clone())
+                    }
+                    _ => Value::Null,
+                };
+
+                if val == Value::Null {
+                    let message = format!("Invalid value for key '{}'", key);
+                    return crate::core::parser::statement::error_from_token(token, message);
+                }
+
+                map.insert(key, val);
+
+                if let Some(t) = parser.peek() {
+                    if t.kind == TokenKind::Comma {
+                        parser.advance(); // skip comma
+                    }
+                }
+            }
+
+            Value::Map(map)
+        }
+        _ => {
+            return crate::core::parser::statement::error_from_token(
+                current_token,
+                "Unhandled value type after '='".to_string(),
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Let { name: identifier },
+        value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/handler/identifier/mod.rs

@@ -0,0 +1,55 @@
+pub mod automate;
+pub mod call;
+pub mod emit;
+pub mod function;
+pub mod group;
+pub mod let_;
+pub mod on;
+pub mod print;
+pub mod sleep;
+pub mod spawn;
+pub mod synth;
+
+use crate::core::{
+    parser::{
+        driver::Parser,
+        handler::identifier::{
+            automate::parse_automate_token, call::parse_call_token, emit::parse_emit_token,
+            group::parse_group_token, let_::parse_let_token, on::parse_on_token,
+            print::parse_print_token, sleep::parse_sleep_token, spawn::parse_spawn_token,
+            synth::parse_synth_token,
+        },
+        statement::Statement,
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    let Some(current_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    let current_token_clone = current_token.clone();
+    let current_token_lexeme = current_token_clone.lexeme.clone();
+
+    match current_token_lexeme.as_str() {
+        "let" => parse_let_token(parser, current_token_clone, global_store),
+        "group" => parse_group_token(parser, current_token_clone, global_store),
+        "call" => parse_call_token(parser, current_token_clone, global_store),
+        "spawn" => parse_spawn_token(parser, current_token_clone, global_store),
+        "sleep" => parse_sleep_token(parser, current_token_clone, global_store),
+        "synth" => parse_synth_token(parser, current_token_clone, global_store),
+        "automate" => parse_automate_token(parser, current_token_clone, global_store),
+        "print" => parse_print_token(parser, current_token_clone, global_store),
+        "on" => parse_on_token(parser, global_store),
+        "emit" => parse_emit_token(parser, current_token_clone, global_store),
+        _ => {
+            parser.advance(); // consume identifier
+
+            crate::core::parser::statement::error_from_token(
+                current_token_clone,
+                "Unexpected identifier".to_string(),
+            )
+        }
+    }
+}

package/rust/core/parser/handler/identifier/on.rs

@@ -0,0 +1,107 @@
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    // consume 'on'
+    let on_tok = match parser.peek_clone() {
+        Some(tok) => tok,
+        None => return Statement::unknown(),
+    };
+    parser.advance();
+
+    // Expect event name identifier
+    let event_tok = match parser.peek_clone() {
+        Some(tok) if tok.kind == TokenKind::Identifier => tok,
+        Some(other) => {
+            return crate::core::parser::statement::error_from_token(
+                other,
+                "Expected event name after 'on'".to_string(),
+            );
+        }
+        None => {
+            return crate::core::parser::statement::error_from_token(
+                on_tok,
+                "Expected event name after 'on'".to_string(),
+            );
+        }
+    };
+    let event_name = event_tok.lexeme.clone();
+    parser.advance();
+
+    // Optional parenthesized args on same line
+    let mut args: Option<Vec<Value>> = None;
+    if parser.peek_kind() == Some(TokenKind::LParen) {
+        parser.advance(); // '('
+        let mut collected: Vec<Value> = Vec::new();
+        // Collect tokens until ')', supporting numbers and identifiers separated by comma
+        while let Some(tok) = parser.peek_clone() {
+            match tok.kind {
+                TokenKind::RParen => {
+                    parser.advance();
+                    break;
+                }
+                TokenKind::Number => {
+                    parser.advance();
+                    collected.push(Value::Number(tok.lexeme.parse().unwrap_or(0.0)));
+                }
+                TokenKind::Identifier => {
+                    parser.advance();
+                    collected.push(Value::Identifier(tok.lexeme));
+                }
+                TokenKind::Comma => {
+                    parser.advance();
+                }
+                TokenKind::Whitespace | TokenKind::Newline => {
+                    parser.advance();
+                }
+                _ => {
+                    break;
+                }
+            }
+        }
+        if !collected.is_empty() {
+            args = Some(collected);
+        }
+    }
+
+    // Expect ':' then block
+    if parser.peek_kind() != Some(TokenKind::Colon) {
+        return crate::core::parser::statement::error_from_token(
+            event_tok,
+            "Expected ':' after event name".to_string(),
+        );
+    }
+    parser.advance(); // consume ':'
+
+    let base_indent = on_tok.indent;
+    let block_tokens = parser.collect_block_tokens(base_indent);
+    // Parse body within current store context
+    let body = parser.parse_block(block_tokens, _global_store);
+
+    let stmt = Statement {
+        kind: StatementKind::On {
+            event: event_name,
+            args,
+            body,
+        },
+        value: Value::Null,
+        indent: on_tok.indent,
+        line: on_tok.line,
+        column: on_tok.column,
+    };
+
+    // Register in global store for later emission
+    if let StatementKind::On { event, .. } = &stmt.kind {
+        _global_store.register_event_handler(event, stmt.clone());
+    }
+
+    stmt
+}

package/rust/core/parser/handler/identifier/print.rs

@@ -0,0 +1,49 @@
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+pub fn parse_print_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    // consume 'print'
+    parser.advance();
+
+    let collected = parser.collect_until(|t| matches!(t.kind, TokenKind::Newline | TokenKind::EOF));
+    // Accept: print <identifier|string|number|expression>
+    let value = if collected.len() == 1 {
+        match collected[0].kind {
+            TokenKind::Identifier => Value::Identifier(collected[0].lexeme.clone()),
+            TokenKind::String => Value::String(collected[0].lexeme.clone()),
+            TokenKind::Number => {
+                let n = collected[0].lexeme.parse::<f32>().unwrap_or(0.0);
+                Value::Number(n)
+            }
+            _ => Value::String(collected[0].lexeme.clone()),
+        }
+    } else {
+        // Join tokens with spaces to preserve readability for expressions/text
+        let text = collected
+            .iter()
+            .filter(|t| !matches!(t.kind, TokenKind::Newline | TokenKind::EOF))
+            .map(|t| t.lexeme.clone())
+            .collect::<Vec<_>>()
+            .join(" ");
+        Value::String(text.trim().to_string())
+    };
+
+    Statement {
+        kind: StatementKind::Print,
+        value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/handler/identifier/sleep.rs

@@ -0,0 +1,43 @@
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_sleep_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "sleep"
+
+    let duration = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Number {
+            parser.advance();
+            token.lexeme.parse().unwrap_or(0.0)
+        } else {
+            return crate::core::parser::statement::error_from_token(
+                token,
+                "Expected number after 'sleep'".to_string(),
+            );
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected number after 'sleep'".to_string(),
+        );
+    };
+
+    Statement {
+        kind: StatementKind::Sleep,
+        value: Value::Number(duration),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/handler/identifier/spawn.rs

@@ -0,0 +1,91 @@
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+pub fn parse_spawn_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "spawn"
+
+    // Expect function name
+    let name_token = match parser.peek_clone() {
+        Some(t) => t,
+        None => {
+            return crate::core::parser::statement::error_from_token(
+                current_token,
+                "Expected function name after 'spawn'".to_string(),
+            );
+        }
+    };
+
+    if name_token.kind != TokenKind::Identifier {
+        return crate::core::parser::statement::error_from_token(
+            name_token,
+            "Expected function name to be an identifier".to_string(),
+        );
+    }
+
+    let func_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    // Expect '('
+    let mut args: Vec<Value> = Vec::new();
+    if let Some(open_paren) = parser.peek_clone() {
+        if open_paren.kind == TokenKind::LParen {
+            parser.advance(); // consume '('
+
+            // Collect args until ')'
+            while let Some(token) = parser.peek_clone() {
+                if token.kind == TokenKind::RParen {
+                    parser.advance(); // consume ')'
+                    break;
+                }
+
+                match token.kind {
+                    TokenKind::Number => {
+                        if let Ok(num) = token.lexeme.parse::<f32>() {
+                            args.push(Value::Number(num));
+                        }
+                        parser.advance();
+                    }
+                    TokenKind::String => {
+                        args.push(Value::String(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Identifier => {
+                        args.push(Value::Identifier(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance(); // skip comma
+                    }
+                    _ => {
+                        return crate::core::parser::statement::error_from_token(
+                            token,
+                            "Unexpected token in spawn arguments".to_string(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Spawn {
+            name: func_name,
+            args,
+        },
+        value: Value::Null,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/handler/identifier/synth.rs

@@ -0,0 +1,135 @@
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::Token,
+    parser::{
+        driver::Parser,
+        handler::dot::parse_dot_token,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_synth_token(
+    parser: &mut Parser,
+    _current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume 'synth'
+
+    let Some(synth_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a provider/waveform identifier (can be dotted: alias.synth)
+    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
+    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
+        use crate::core::lexer::token::TokenKind;
+
+        if first_token.kind == TokenKind::Dot {
+            // Parse dot-entity and extract its entity string
+            let dot_stmt = parse_dot_token(parser, _global_store);
+            // Extract entity if the parsed statement is a Trigger
+            match dot_stmt.kind {
+                StatementKind::Trigger { entity, .. } => entity,
+                _ => String::new(),
+            }
+        } else {
+            if first_token.kind != crate::core::lexer::token::TokenKind::Identifier
+                && first_token.kind != crate::core::lexer::token::TokenKind::Number
+                && first_token.kind != crate::core::lexer::token::TokenKind::Synth
+            {
+                return crate::core::parser::statement::error_from_token(
+                    first_token.clone(),
+                    "Expected identifier after 'synth'".to_string(),
+                );
+            }
+
+            // Collect dotted parts on the same line
+            let mut parts: Vec<String> = Vec::new();
+            let current_line = first_token.line;
+            loop {
+                let Some(tok) = parser.peek_clone() else {
+                    break;
+                };
+                if tok.line != current_line {
+                    break;
+                }
+                match tok.kind {
+                    crate::core::lexer::token::TokenKind::Identifier
+                    | crate::core::lexer::token::TokenKind::Number
+                    | crate::core::lexer::token::TokenKind::Synth => {
+                        parts.push(tok.lexeme.clone());
+                        parser.advance();
+                        // If next isn't a dot on same line, stop
+                        if let Some(next) = parser.peek_clone() {
+                            if !(next.line == current_line
+                                && next.kind == crate::core::lexer::token::TokenKind::Dot)
+                            {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    crate::core::lexer::token::TokenKind::Dot => {
+                        parser.advance();
+                    }
+                    _ => break,
+                }
+            }
+
+            parts.join(".")
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            synth_token,
+            "Expected identifier after 'synth'".to_string(),
+        );
+    };
+
+    // Skip formatting before optional parameters map
+    while parser.check_token(crate::core::lexer::token::TokenKind::Newline)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Indent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Dedent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Whitespace)
+    {
+        parser.advance();
+    }
+
+    // Expect synth optional parameters map
+    let parameters = if let Some(params) = parser.parse_map_value() {
+        // If parameters are provided, we expect a map
+        if let Value::Map(map) = params {
+            map
+        } else {
+            return crate::core::parser::statement::error_from_token(
+                synth_token,
+                "Expected a map for synth parameters".to_string(),
+            );
+        }
+    } else {
+        // If no parameters are provided, we can still create the statement with an empty map
+        HashMap::new()
+    };
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(HashMap::from([
+            ("entity".to_string(), Value::String("synth".to_string())),
+            (
+                "value".to_string(),
+                Value::Map(HashMap::from([
+                    // Store waveform as identifier to allow resolution from variables/exports
+                    ("waveform".to_string(), Value::Identifier(synth_waveform)),
+                    ("parameters".to_string(), Value::Map(parameters)),
+                ])),
+            ),
+        ])),
+        indent: synth_token.indent,
+        line: synth_token.line,
+        column: synth_token.column,
+    }
+}