@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

package/rust/core/parser/handler/at.rs

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
@@ -25,10 +26,13 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
             // Expect plugin author
             let Some(author_token) = parser.peek_clone() else {
-                return Statement::error(use_token, "Expected plugin author".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    use_token,
+                    "Expected plugin author".to_string(),
+                );
             };
             if author_token.kind != TokenKind::Identifier {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     author_token,
                     "Expected identifier for plugin author".to_string(),
                 );
@@ -37,7 +41,7 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
             // Expect '.'
             if !parser.match_token(TokenKind::Dot) {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     author_token,
                     "Expected '.' after plugin author".to_string(),
                 );
@@ -45,7 +49,10 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
             // Expect plugin name
             let Some(plugin_token) = parser.peek_clone() else {
-                return Statement::error(author_token, "Expected plugin name".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    author_token,
+                    "Expected plugin name".to_string(),
+                );
             };
 
             let name = match plugin_token.kind {
@@ -54,7 +61,7 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
                     format!("{}.{}", author_token.lexeme, plugin_token.lexeme)
                 }
                 _ => {
-                    return Statement::error(
+                    return crate::core::parser::statement::error_from_token(
                         plugin_token,
                         "Expected identifier or number for plugin name".to_string(),
                     );
@@ -64,13 +71,13 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
             // Optional alias
             let alias = if parser.match_token(TokenKind::As) {
                 let Some(alias_token) = parser.peek_clone() else {
-                    return Statement::error(
+                    return crate::core::parser::statement::error_from_token(
                         use_token,
                         "Expected identifier after 'as'".to_string(),
                     );
                 };
                 if alias_token.kind != TokenKind::Identifier {
-                    return Statement::error(
+                    return crate::core::parser::statement::error_from_token(
                         alias_token,
                         "Expected identifier after 'as'".to_string(),
                     );
@@ -97,7 +104,10 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
             parser.advance(); // consume 'import'
 
             if !parser.match_token(TokenKind::LBrace) {
-                return Statement::error(token, "Expected '{{' after 'import'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected '{{' after 'import'".to_string(),
+                );
             }
 
             let mut names = Vec::new();
@@ -117,27 +127,42 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
                     _ => {
                         let message =
                             format!("Unexpected token in import list: {:?}", token.kind.clone());
-                        return Statement::error(token.clone(), message);
+                        return crate::core::parser::statement::error_from_token(
+                            token.clone(),
+                            message,
+                        );
                     }
                 }
             }
 
             let Some(from_token) = parser.peek_clone() else {
-                return Statement::error(token, "Expected 'from' after import list".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected 'from' after import list".to_string(),
+                );
             };
 
             if from_token.lexeme != "from" {
-                return Statement::error(token, "Expected keyword 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected keyword 'from'".to_string(),
+                );
             }
 
             parser.advance(); // consume 'from'
 
             let Some(source_token) = parser.peek() else {
-                return Statement::error(token, "Expected string after 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'from'".to_string(),
+                );
             };
 
             if source_token.kind != TokenKind::String {
-                return Statement::error(token, "Expected string after 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'from'".to_string(),
+                );
             }
 
             let source = source_token.lexeme.clone();
@@ -168,7 +193,10 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
                 } else if token.kind == TokenKind::RBrace {
                     break; // Stop at the closing brace
                 } else {
-                    return Statement::error(token, "Unexpected token in export list".to_string());
+                    return crate::core::parser::statement::error_from_token(
+                        token,
+                        "Unexpected token in export list".to_string(),
+                    );
                 }
             }
 
@@ -189,11 +217,17 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
             // Example: @load "preset.mydeva"
             let Some(path_token) = parser.peek() else {
-                return Statement::error(token, "Expected string after 'load'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'load'".to_string(),
+                );
             };
 
             if path_token.kind != TokenKind::String {
-                return Statement::error(token, "Expected string after 'load'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'load'".to_string(),
+                );
             }
 
             let path = path_token.lexeme.clone();
@@ -201,21 +235,21 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
             parser.advance(); // consume string
 
             if !parser.match_token(TokenKind::As) {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     token,
                     "Expected 'as' after path in load statement".to_string(),
                 );
             }
 
             let Some(alias_token) = parser.peek_clone() else {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     token,
                     "Expected identifier after 'as' in load statement".to_string(),
                 );
             };
 
             if alias_token.kind != TokenKind::Identifier {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     token,
                     "Expected identifier after 'as' in load statement".to_string(),
                 );
@@ -239,7 +273,7 @@ pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
         _ => {
             let message = format!("Unknown keyword after '@' : {}", keyword);
-            Statement::error(token, message)
+            crate::core::parser::statement::error_from_token(token, message)
         }
     }
 }

package/rust/core/parser/handler/bank.rs

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -66,7 +67,10 @@ pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
     };
 
     if matches!(bank_value, Value::Unknown | Value::Null) {
-        return Statement::error(bank_tok, "Expected a bank name".to_string());
+        return crate::core::parser::statement::error_from_token(
+            bank_tok,
+            "Expected a bank name".to_string(),
+        );
     }
 
     // Optional alias: as <identifier>
@@ -75,10 +79,16 @@ pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
         // consume 'as'
         parser.advance();
         let Some(next) = parser.peek_clone() else {
-            return Statement::error(bank_tok, "Expected identifier after 'as'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                bank_tok,
+                "Expected identifier after 'as'".to_string(),
+            );
         };
         if next.kind != TokenKind::Identifier {
-            return Statement::error(next, "Expected identifier after 'as'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                next,
+                "Expected identifier after 'as'".to_string(),
+            );
         }
         parser.advance();
         alias = Some(next.lexeme.clone());

package/rust/core/parser/handler/condition.rs

@@ -4,9 +4,9 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 use std::collections::HashMap;
 
 pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
@@ -16,7 +16,10 @@ pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore
     };
 
     let Some(condition) = parser.parse_condition_until_colon() else {
-        return Statement::error(if_token, "Expected condition after 'if'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            if_token,
+            "Expected condition after 'if'".to_string(),
+        );
     };
 
     parser.advance_if(TokenKind::Colon);
@@ -43,7 +46,7 @@ pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore
         let next_condition = if parser.peek_is("if") {
             parser.advance(); // consume 'if'
             let Some(cond) = parser.parse_condition_until_colon() else {
-                return Statement::error(
+                return crate::core::parser::statement::error_from_token(
                     tok.clone(),
                     "Expected condition after 'else if'".to_string(),
                 );

package/rust/core/parser/handler/dot.rs

@@ -1,10 +1,11 @@
+use devalang_types::{Duration, Value};
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::{duration::Duration, value::Value},
 };
 
 pub fn parse_dot_token(

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

@@ -1,20 +1,14 @@
-use std::collections::HashMap;
-
 use crate::core::{
     lexer::token::{Token, TokenKind},
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
+use std::collections::HashMap;
 
-// Grammar:
-// automate <identifier>:
-//     param <name> { <percent>% = <number> ... }
-// Produces StatementKind::Automate with value map:
-// { target: Identifier, params: Map<paramName, Map<percent, Number>> }
 pub fn parse_automate_token(
     parser: &mut Parser,
     current_token: Token,
@@ -24,14 +18,14 @@ pub fn parse_automate_token(
 
     // Expect target identifier
     let Some(target_token) = parser.peek_clone() else {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             current_token,
             "Expected target after 'automate'".to_string(),
         );
     };
 
     if target_token.kind != TokenKind::Identifier && target_token.kind != TokenKind::String {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             target_token,
             "Expected valid target after 'automate'".to_string(),
         );
@@ -40,13 +34,13 @@ pub fn parse_automate_token(
 
     // Expect ':'
     let Some(colon_token) = parser.peek_clone() else {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             target_token,
             "Expected ':' after automate target".to_string(),
         );
     };
     if colon_token.kind != TokenKind::Colon {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             colon_token,
             "Expected ':' after automate target".to_string(),
         );
@@ -85,19 +79,22 @@ pub fn parse_automate_token(
                 local.advance(); // consume 'param'
                 // param name
                 let Some(name_tok) = local.peek_clone() else {
-                    return Statement::error(
+                    return crate::core::parser::statement::error_from_token(
                         tok,
                         "Expected parameter name after 'param'".to_string(),
                     );
                 };
                 if name_tok.kind != TokenKind::Identifier && name_tok.kind != TokenKind::String {
-                    return Statement::error(name_tok, "Expected valid parameter name".to_string());
+                    return crate::core::parser::statement::error_from_token(
+                        name_tok,
+                        "Expected valid parameter name".to_string(),
+                    );
                 }
                 local.advance(); // consume name
 
                 // Expect '{'
                 if !local.match_token(TokenKind::LBrace) {
-                    return Statement::error(
+                    return crate::core::parser::statement::error_from_token(
                         name_tok,
                         "Expected '{' to start parameter block".to_string(),
                     );
@@ -142,7 +139,7 @@ pub fn parse_automate_token(
                         break;
                     }
                     if !local.match_token(TokenKind::Equals) {
-                        return Statement::error(
+                        return crate::core::parser::statement::error_from_token(
                             percent_token,
                             "Expected '=' in param entry".to_string(),
                         );

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

@@ -4,9 +4,9 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_call_token(
     parser: &mut Parser,
@@ -19,7 +19,7 @@ pub fn parse_call_token(
     let name_token = match parser.peek_clone() {
         Some(t) => t,
         None => {
-            return Statement::error(
+            return crate::core::parser::statement::error_from_token(
                 current_token,
                 "Expected function name after 'call'".to_string(),
             );
@@ -27,7 +27,7 @@ pub fn parse_call_token(
     };
 
     if name_token.kind != TokenKind::Identifier {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             name_token,
             "Expected function name to be an identifier".to_string(),
         );
@@ -68,7 +68,7 @@ pub fn parse_call_token(
                         parser.advance(); // skip comma
                     }
                     _ => {
-                        return Statement::error(
+                        return crate::core::parser::statement::error_from_token(
                             token,
                             "Unexpected token in call arguments".to_string(),
                         );

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

@@ -4,12 +4,10 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
-// Syntax:
-// emit <event> [<payload>]
 pub fn parse_emit_token(
     parser: &mut Parser,
     current: crate::core::lexer::token::Token,
@@ -18,10 +16,16 @@ pub fn parse_emit_token(
     parser.advance(); // consume 'emit'
 
     let Some(ev) = parser.peek_clone() else {
-        return Statement::error(current, "Expected event name after 'emit'".into());
+        return crate::core::parser::statement::error_from_token(
+            current,
+            "Expected event name after 'emit'".into(),
+        );
     };
     if ev.kind != TokenKind::Identifier {
-        return Statement::error(ev.clone(), "Expected identifier as event name".into());
+        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

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

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -18,11 +19,16 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
 
     let name_token = match parser.peek_clone() {
         Some(tok) => tok,
-        None => return Statement::error(fn_token, "Expected function name after 'fn'".to_string()),
+        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 Statement::error(
+        return crate::core::parser::statement::error_from_token(
             name_token.clone(),
             "Expected function name to be an identifier".to_string(),
         );
@@ -35,7 +41,7 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
 
     // Expect '('
     if parser.peek_kind() != Some(TokenKind::LParen) {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             name_token.clone(),
             "Expected '(' after function name".to_string(),
         );
@@ -53,7 +59,7 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
     if parser.peek_kind() == Some(TokenKind::RParen) {
         parser.advance(); // consume ')'
     } else {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             name_token.clone(),
             "Expected ')' after parameters".to_string(),
         );
@@ -61,7 +67,10 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
 
     // Expect colon
     if parser.peek_kind() != Some(TokenKind::Colon) {
-        return Statement::error(name_token.clone(), "Expected ':' after ')'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            name_token.clone(),
+            "Expected ':' after ')'".to_string(),
+        );
     }
     parser.advance(); // consume ':'
 
@@ -73,7 +82,11 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
         if tok.kind == TokenKind::Dedent && tok.indent <= base_indent {
             break;
         }
-        body_tokens.push(parser.advance().unwrap().clone());
+        if let Some(t) = parser.advance() {
+            body_tokens.push(t.clone());
+        } else {
+            break;
+        }
     }
 
     // Parse those tokens into block statements

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

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::{Token, TokenKind},
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 use std::collections::HashMap;
@@ -17,7 +18,7 @@ pub fn parse_group_token(
     parser.advance(); // consume "group"
 
     let Some(identifier_token) = parser.peek_clone() else {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             current_token,
             "Expected identifier after 'group'".to_string(),
         );
@@ -25,20 +26,23 @@ pub fn parse_group_token(
 
     if identifier_token.kind != TokenKind::Identifier && identifier_token.kind != TokenKind::String
     {
-        return Statement::error(identifier_token, "Expected valid identifier".to_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 Statement::error(
+        return crate::core::parser::statement::error_from_token(
             identifier_token,
             "Expected ':' after group identifier".to_string(),
         );
     };
 
     if colon_token.kind != TokenKind::Colon {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             colon_token.clone(),
             "Expected ':' after group identifier".to_string(),
         );
@@ -75,11 +79,11 @@ pub fn parse_group_token(
     );
     value_map.insert("body".to_string(), Value::Block(body));
 
-    return Statement {
+    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

@@ -7,9 +7,9 @@ use crate::core::{
         handler::{dot::parse_dot_token, identifier::synth::parse_synth_token},
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_let_token(
     parser: &mut Parser,
@@ -23,14 +23,23 @@ pub fn parse_let_token(
             parser.advance();
             token.lexeme.clone()
         } else {
-            return Statement::error(token, "Expected identifier after 'let'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                token,
+                "Expected identifier after 'let'".to_string(),
+            );
         }
     } else {
-        return Statement::error(current_token, "Expected identifier after 'let'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected identifier after 'let'".to_string(),
+        );
     };
 
     if !parser.match_token(TokenKind::Equals) {
-        return Statement::error(current_token, "Expected '=' after identifier".to_string());
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected '=' after identifier".to_string(),
+        );
     }
 
     // If RHS begins with '$' or contains expression tokens ('+', '-', '*', '/', '(', '['),
@@ -101,14 +110,17 @@ pub fn parse_let_token(
                 }
 
                 if key_token.kind != TokenKind::Identifier {
-                    return Statement::error(token, "Expected key identifier in map".to_string());
+                    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 Statement::error(token, message);
+                    return crate::core::parser::statement::error_from_token(token, message);
                 }
 
                 let val = match parser.peek_clone() {
@@ -129,7 +141,7 @@ pub fn parse_let_token(
 
                 if val == Value::Null {
                     let message = format!("Invalid value for key '{}'", key);
-                    return Statement::error(token, message);
+                    return crate::core::parser::statement::error_from_token(token, message);
                 }
 
                 map.insert(key, val);
@@ -144,13 +156,16 @@ pub fn parse_let_token(
             Value::Map(map)
         }
         _ => {
-            return Statement::error(current_token, "Unhandled value type after '='".to_string());
+            return crate::core::parser::statement::error_from_token(
+                current_token,
+                "Unhandled value type after '='".to_string(),
+            );
         }
     };
 
     Statement {
         kind: StatementKind::Let { name: identifier },
-        value: value,
+        value,
         indent: current_token.indent,
         line: current_token.line,
         column: current_token.column,