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

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

@@ -1,75 +1,89 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
-    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 Statement::error(current_token, "Expected identifier after 'group'".to_string());
-    };
-
-    if identifier_token.kind != TokenKind::Identifier && identifier_token.kind != TokenKind::String {
-        return Statement::error(identifier_token, "Expected valid identifier".to_string());
-    }
-
-    parser.advance(); // consume identifier
-
-    let Some(colon_token) = parser.peek_clone() else {
-        return Statement::error(
-            identifier_token,
-            "Expected ':' after group identifier".to_string()
-        );
-    };
-
-    if colon_token.kind != TokenKind::Colon {
-        return Statement::error(
-            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));
-
-    return Statement {
-        kind: StatementKind::Group,
-        value: Value::Map(value_map),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    };
-}
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::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,133 +1,173 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        driver::Parser,
-        handler::identifier::synth::parse_synth_token,
-        statement::{ Statement, StatementKind },
-    },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-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 Statement::error(token, "Expected identifier after 'let'".to_string());
-        }
-    } else {
-        return Statement::error(current_token, "Expected identifier after 'let'".to_string());
-    };
-
-    if !parser.match_token(TokenKind::Equals) {
-        return Statement::error(current_token, "Expected '=' after identifier".to_string());
-    }
-
-    if let Some(token) = parser.peek_clone() {
-        if token.kind == TokenKind::Synth {
-            let synth_stmt = parse_synth_token(parser, token.clone(), global_store);
-
-            return Statement {
-                kind: StatementKind::Let { name: identifier },
-                value: synth_stmt.value,
-                indent: current_token.indent,
-                line: current_token.line,
-                column: current_token.column,
-            };
-        }
-    }
-
-    let value = match parser.peek_clone() {
-        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(); // consume '{'
-            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 Statement::error(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 Statement::error(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 Statement::error(token, message);
-                }
-
-                map.insert(key, val);
-
-                if let Some(t) = parser.peek() {
-                    if t.kind == TokenKind::Comma {
-                        parser.advance(); // skip comma
-                    }
-                }
-            }
-
-            Value::Map(map)
-        }
-        other => {
-            let message = format!("Unexpected value token in let: {:?}", other);
-            return Statement::error(current_token, message);
-        }
-    };
-
-    Statement {
-        kind: StatementKind::Let { name: identifier },
-        value,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+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

@@ -1,51 +1,55 @@
-pub mod let_;
-pub mod group;
-pub mod call;
-pub mod spawn;
-pub mod sleep;
-pub mod synth;
-
-use crate::core::{
-    parser::{
-        driver::Parser,
-        handler::{
-            identifier::{
-                call::parse_call_token,
-                group::parse_group_token,
-                let_::parse_let_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();
-
-    let statement = 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),
-        _ => {
-            parser.advance(); // consume identifier
-
-            println!("Unrecognized identifier: {}", current_token_lexeme);
-
-            return Statement::error(current_token_clone, "Unexpected identifier".to_string());
-        }
-    };
-
-    return statement;
-}
+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(),
+            )
+        }
+    }
+}