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

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

@@ -1,91 +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_call_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "call"
-
-    // 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 'call'".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 call arguments".to_string(),
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Call {
-            name: func_name,
-            args,
-        },
-        value: Value::Null,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+pub fn parse_call_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "call"
+
+    // 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 'call'".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 call arguments".to_string(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Call {
+            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/emit.rs

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