@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,70 +0,0 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-pub fn parse_emit_token(
-    parser: &mut Parser,
-    current: crate::core::lexer::token::Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume 'emit'
-
-    let Some(ev) = parser.peek_clone() else {
-        return crate::core::parser::statement::error_from_token(
-            current,
-            "Expected event name after 'emit'".into(),
-        );
-    };
-    if ev.kind != TokenKind::Identifier {
-        return crate::core::parser::statement::error_from_token(
-            ev.clone(),
-            "Expected identifier as event name".into(),
-        );
-    }
-    let event_name = ev.lexeme.clone();
-    parser.advance(); // consume event name
-
-    // Optional payload on same line: number|string|identifier|map|array
-    let mut payload: Option<Value> = None;
-    if let Some(tok) = parser.peek_clone() {
-        if tok.line == ev.line {
-            let val = match tok.kind {
-                TokenKind::String => {
-                    parser.advance();
-                    Value::String(tok.lexeme.clone())
-                }
-                TokenKind::Number => {
-                    parser.advance();
-                    Value::Number(tok.lexeme.parse().unwrap_or(0.0))
-                }
-                TokenKind::Identifier => {
-                    parser.advance();
-                    Value::Identifier(tok.lexeme.clone())
-                }
-                TokenKind::LBrace => parser.parse_map_value().unwrap_or(Value::Null),
-                TokenKind::LBracket => parser.parse_array_value().unwrap_or(Value::Null),
-                _ => Value::Null,
-            };
-            if val != Value::Null {
-                payload = Some(val);
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Emit {
-            event: event_name,
-            payload: payload.clone(),
-        },
-        value: payload.unwrap_or(Value::Null),
-        indent: current.indent,
-        line: current.line,
-        column: current.column,
-    }
-}

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

@@ -1,113 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'fn'
-
-    let fn_token = match parser.previous_clone() {
-        Some(tok) => tok,
-        None => return Statement::unknown(),
-    };
-
-    let name_token = match parser.peek_clone() {
-        Some(tok) => tok,
-        None => {
-            return crate::core::parser::statement::error_from_token(
-                fn_token,
-                "Expected function name after 'fn'".to_string(),
-            );
-        }
-    };
-
-    if name_token.kind != TokenKind::Identifier {
-        return crate::core::parser::statement::error_from_token(
-            name_token.clone(),
-            "Expected function name to be an identifier".to_string(),
-        );
-    }
-
-    let function_name = name_token.lexeme.clone();
-    parser.advance(); // consume function name
-
-    let mut parameters = Vec::new();
-
-    // Expect '('
-    if parser.peek_kind() != Some(TokenKind::LParen) {
-        return crate::core::parser::statement::error_from_token(
-            name_token.clone(),
-            "Expected '(' after function name".to_string(),
-        );
-    }
-    parser.advance(); // consume '('
-
-    // Parse parameters until ')'
-    let tokens = parser.collect_until(|t| t.kind == TokenKind::RParen || t.kind == TokenKind::EOF);
-    for token in tokens {
-        if token.kind == TokenKind::Identifier {
-            parameters.push(token.lexeme.clone());
-        }
-    }
-
-    if parser.peek_kind() == Some(TokenKind::RParen) {
-        parser.advance(); // consume ')'
-    } else {
-        return crate::core::parser::statement::error_from_token(
-            name_token.clone(),
-            "Expected ')' after parameters".to_string(),
-        );
-    }
-
-    // Expect colon
-    if parser.peek_kind() != Some(TokenKind::Colon) {
-        return crate::core::parser::statement::error_from_token(
-            name_token.clone(),
-            "Expected ':' after ')'".to_string(),
-        );
-    }
-    parser.advance(); // consume ':'
-
-    // Collect ALL tokens indented after this line until Dedent
-    let base_indent = fn_token.indent;
-    let mut body_tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        if tok.kind == TokenKind::Dedent && tok.indent <= base_indent {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            body_tokens.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    // Parse those tokens into block statements
-    let body = parser.parse_block(body_tokens.clone(), global_store);
-
-    // Skip Dedent if present
-    if let Some(tok) = parser.peek() {
-        if tok.kind == TokenKind::Dedent {
-            parser.advance();
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Function {
-            name: function_name.clone(),
-            parameters: parameters.clone(),
-            body: body.clone(),
-        },
-        value: Value::Null,
-        indent: fn_token.indent,
-        line: fn_token.line,
-        column: fn_token.column,
-    }
-}

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

@@ -1,89 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use std::collections::HashMap;
-
-pub fn parse_group_token(
-    parser: &mut Parser,
-    current_token: Token,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "group"
-
-    let Some(identifier_token) = parser.peek_clone() else {
-        return crate::core::parser::statement::error_from_token(
-            current_token,
-            "Expected identifier after 'group'".to_string(),
-        );
-    };
-
-    if identifier_token.kind != TokenKind::Identifier && identifier_token.kind != TokenKind::String
-    {
-        return crate::core::parser::statement::error_from_token(
-            identifier_token,
-            "Expected valid identifier".to_string(),
-        );
-    }
-
-    parser.advance(); // consume identifier
-
-    let Some(colon_token) = parser.peek_clone() else {
-        return crate::core::parser::statement::error_from_token(
-            identifier_token,
-            "Expected ':' after group identifier".to_string(),
-        );
-    };
-
-    if colon_token.kind != TokenKind::Colon {
-        return crate::core::parser::statement::error_from_token(
-            colon_token.clone(),
-            "Expected ':' after group identifier".to_string(),
-        );
-    }
-
-    parser.advance(); // consume ':'
-
-    let base_indent = current_token.indent;
-
-    // Clone without consuming tokens
-    let mut index = parser.token_index;
-    let mut tokens_inside_group = Vec::new();
-
-    while index < parser.tokens.len() {
-        let token = parser.tokens[index].clone();
-
-        if token.indent <= base_indent && token.kind != TokenKind::Newline {
-            break;
-        }
-
-        tokens_inside_group.push(token);
-        index += 1;
-    }
-
-    // Advance index once to skip the processed tokens
-    parser.token_index = index;
-
-    let body = parser.parse_block(tokens_inside_group, global_store);
-
-    let mut value_map = HashMap::new();
-    value_map.insert(
-        "identifier".to_string(),
-        Value::String(identifier_token.lexeme.clone()),
-    );
-    value_map.insert("body".to_string(), Value::Block(body));
-
-    Statement {
-        kind: StatementKind::Group,
-        value: Value::Map(value_map),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}

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

@@ -1,173 +0,0 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::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

@@ -1,55 +0,0 @@
-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::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

@@ -1,107 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::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

@@ -1,49 +0,0 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::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,
-    }
-}