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

package/rust/core/parser/driver/parser.rs

@@ -0,0 +1,160 @@
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::statement::Statement,
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Parser {
+    pub resolve_modules: bool,
+    pub tokens: Vec<Token>,
+    pub token_index: usize,
+    pub current_module: String,
+    pub previous: Option<Token>,
+}
+
+impl Default for Parser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Parser {
+    pub fn new() -> Self {
+        Parser {
+            resolve_modules: false,
+            tokens: Vec::new(),
+            token_index: 0,
+            current_module: String::new(),
+            previous: None,
+        }
+    }
+
+    pub fn set_current_module(&mut self, module_path: String) {
+        self.current_module = module_path;
+    }
+
+    pub fn advance(&mut self) -> Option<&Token> {
+        crate::core::parser::driver::cursor::advance_impl(self)
+    }
+
+    pub fn peek_is(&self, expected: &str) -> bool {
+        crate::core::parser::driver::cursor::peek_is_impl(self, expected)
+    }
+
+    pub fn peek_nth(&self, n: usize) -> Option<&Token> {
+        crate::core::parser::driver::cursor::peek_nth_impl(self, n)
+    }
+
+    pub fn peek_nth_kind(&self, n: usize) -> Option<TokenKind> {
+        crate::core::parser::driver::cursor::peek_nth_kind_impl(self, n)
+    }
+
+    pub fn advance_if(&mut self, kind: TokenKind) -> bool {
+        crate::core::parser::driver::cursor::advance_if_impl(self, kind)
+    }
+
+    pub fn match_token(&mut self, kind: TokenKind) -> bool {
+        crate::core::parser::driver::cursor::match_token_impl(self, kind)
+    }
+
+    pub fn previous_clone(&self) -> Option<Token> {
+        crate::core::parser::driver::cursor::previous_clone_impl(self)
+    }
+
+    pub fn parse_block(
+        &self,
+        tokens: Vec<Token>,
+        global_store: &mut GlobalStore,
+    ) -> Vec<Statement> {
+        crate::core::parser::driver::block::parse_block(self, tokens, global_store)
+    }
+
+    pub fn parse_tokens(
+        &mut self,
+        tokens: Vec<Token>,
+        global_store: &mut GlobalStore,
+    ) -> Vec<Statement> {
+        crate::core::parser::driver::driver_impl::parse_tokens_impl(self, tokens, global_store)
+    }
+
+    pub fn check_token(&self, kind: TokenKind) -> bool {
+        crate::core::parser::driver::cursor::peek_impl(self).is_some_and(|t| t.kind == kind)
+    }
+
+    pub fn peek_kind(&self) -> Option<TokenKind> {
+        crate::core::parser::driver::cursor::peek_impl(self).map(|t| t.kind.clone())
+    }
+
+    pub fn parse_map_value(&mut self) -> Option<Value> {
+        // Delegated to parse_map.rs
+        crate::core::parser::driver::parse_map::parse_map_value(self)
+    }
+
+    // Parse an array value like [1, 2, 3] or ["a", b]
+    pub fn parse_array_value(&mut self) -> Option<Value> {
+        // delegated to parse_array.rs
+        crate::core::parser::driver::parse_array::parse_array_value(self)
+    }
+
+    pub fn peek(&self) -> Option<&Token> {
+        self.tokens.get(self.token_index)
+    }
+
+    pub fn peek_clone(&self) -> Option<Token> {
+        self.tokens.get(self.token_index).cloned()
+    }
+
+    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
+        let tok = self.advance().ok_or("Unexpected end of input")?;
+        if tok.kind == kind {
+            Ok(tok)
+        } else {
+            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
+        }
+    }
+
+    pub fn collect_block_tokens(&mut self, base_indent: usize) -> Vec<Token> {
+        crate::core::parser::driver::block::collect_block_tokens(self, base_indent)
+    }
+
+    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token>
+    where
+        F: Fn(&Token) -> bool,
+    {
+        crate::core::parser::driver::block::collect_until(self, condition)
+    }
+
+    pub fn is_eof(&self) -> bool {
+        self.token_index >= self.tokens.len()
+    }
+
+    pub fn parse_block_until_next_else(
+        &mut self,
+        base_indent: usize,
+        global_store: &mut GlobalStore,
+    ) -> Vec<Statement> {
+        crate::core::parser::driver::block::parse_block_until_next_else(
+            self,
+            base_indent,
+            global_store,
+        )
+    }
+
+    pub fn parse_condition_until_colon(&mut self) -> Option<Value> {
+        crate::core::parser::driver::driver_impl::parse_condition_until_colon_impl(self)
+    }
+
+    pub fn parse_block_until_else_or_dedent(
+        &mut self,
+        base_indent: usize,
+        global_store: &mut GlobalStore,
+    ) -> Vec<Statement> {
+        crate::core::parser::driver::block::parse_block_until_else_or_dedent(
+            self,
+            base_indent,
+            global_store,
+        )
+    }
+}

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

@@ -1,126 +1,277 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    let Some(target_token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    if target_token.kind != TokenKind::Identifier {
-        parser.advance(); // consume target token
-        return Statement::unknown();
-    }
-
-    let Some(arrow_token) = parser.peek_nth(1).cloned() else {
-        parser.advance(); // consume arrow token
-        return Statement {
-            kind: StatementKind::Unknown,
-            value: Value::String(target_token.lexeme.clone()),
-            indent: target_token.indent,
-            line: target_token.line,
-            column: target_token.column,
-        };
-    };
-
-    if arrow_token.kind != TokenKind::Arrow {
-        parser.advance(); // consume method token
-        return Statement {
-            kind: StatementKind::Unknown,
-            value: Value::String(target_token.lexeme.clone()),
-            indent: target_token.indent,
-            line: target_token.line,
-            column: target_token.column,
-        };
-    }
-
-    // We have a valid arrow call, so we consume the arrow token
-    let Some(method_token) = parser.peek_nth(2).cloned() else {
-        parser.advance();
-        return Statement::unknown();
-    };
-
-    if method_token.kind != TokenKind::Identifier {
-        parser.advance();
-        return Statement::unknown();
-    }
-
-    // Consume the tokens for target, arrow, and method
-    parser.advance(); // target
-    parser.advance(); // ->
-    parser.advance(); // method
-
-    let mut args = Vec::new();
-
-    while let Some(token) = parser.peek_clone() {
-        if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
-            break;
-        }
-
-        parser.advance();
-
-        let value = match token.kind {
-            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
-            TokenKind::String => Value::String(token.lexeme.clone()),
-            TokenKind::Number => Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0)),
-            TokenKind::LBrace => {
-                // Handle map literal
-                let mut map = std::collections::HashMap::new();
-                while let Some(inner_token) = parser.peek_clone() {
-                    if inner_token.kind == TokenKind::RBrace {
-                        parser.advance(); // consume RBrace
-                        break;
-                    }
-                    if inner_token.kind == TokenKind::Newline || inner_token.kind == TokenKind::EOF {
-                        break;
-                    }
-                    parser.advance(); // consume key token
-                    let key = inner_token.lexeme.clone();
-
-                    if let Some(colon_token) = parser.peek_clone() {
-                        if colon_token.kind == TokenKind::Colon {
-                            parser.advance(); // consume colon
-                            if let Some(value_token) = parser.peek_clone() {
-                                parser.advance(); // consume value token
-                                let value = match value_token.kind {
-                                    TokenKind::Identifier =>
-                                        Value::Identifier(value_token.lexeme.clone()),
-                                    TokenKind::String => Value::String(value_token.lexeme.clone()),
-                                    TokenKind::Number =>
-                                        Value::Number(
-                                            value_token.lexeme.parse::<f32>().unwrap_or(0.0)
-                                        ),
-                                    TokenKind::Boolean =>
-                                        Value::Boolean(
-                                            value_token.lexeme.parse::<bool>().unwrap_or(false)
-                                        ),
-                                    _ => Value::Unknown,
-                                };
-                                map.insert(key, value);
-                            }
-                        }
-                    }
-                }
-                Value::Map(map)
-            }
-            _ => Value::Unknown,
-        };
-
-        args.push(value);
-    }
-
-    Statement {
-        kind: StatementKind::ArrowCall {
-            target: target_token.lexeme.clone(),
-            method: method_token.lexeme.clone(),
-            args,
-        },
-        value: Value::Null,
-        indent: target_token.indent,
-        line: target_token.line,
-        column: target_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+fn parse_map_literal(parser: &mut Parser) -> Value {
+    // Assumes '{' has already been consumed by caller
+    let mut map = std::collections::HashMap::new();
+    loop {
+        let Some(inner_token) = parser.peek_clone() else {
+            break;
+        };
+
+        match inner_token.kind {
+            TokenKind::RBrace => {
+                parser.advance(); // consume '}'
+                break;
+            }
+            TokenKind::Newline | TokenKind::Comma => {
+                parser.advance();
+                continue;
+            }
+            _ => {}
+        }
+
+        // Key
+        parser.advance();
+        let key = inner_token.lexeme.clone();
+
+        // Expect ':'
+        if let Some(colon_token) = parser.peek_clone() {
+            if colon_token.kind == TokenKind::Colon {
+                parser.advance(); // consume ':'
+
+                // Value
+                if let Some(value_token) = parser.peek_clone() {
+                    match value_token.kind {
+                        TokenKind::LBrace => {
+                            parser.advance(); // consume '{'
+                            let nested = parse_map_literal(parser);
+                            map.insert(key, nested);
+                        }
+                        TokenKind::Identifier => {
+                            parser.advance();
+                            let v = if value_token.lexeme == "true" {
+                                Value::Boolean(true)
+                            } else if value_token.lexeme == "false" {
+                                Value::Boolean(false)
+                            } else {
+                                Value::Identifier(value_token.lexeme.clone())
+                            };
+                            map.insert(key, v);
+                        }
+                        TokenKind::String => {
+                            parser.advance();
+                            map.insert(key, Value::String(value_token.lexeme.clone()));
+                        }
+                        TokenKind::Number => {
+                            parser.advance();
+                            // Beat fraction support: NUMBER '/' NUMBER
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance(); // '/'
+                                if let Some(den) = parser.peek_clone() {
+                                    if den.kind == TokenKind::Number
+                                        || den.kind == TokenKind::Identifier
+                                    {
+                                        parser.advance();
+                                        let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
+                                        map.insert(
+                                            key,
+                                            Value::Duration(devalang_types::Duration::Beat(beat)),
+                                        );
+                                        continue;
+                                    }
+                                }
+                            }
+                            // Decimal support NUMBER '.' NUMBER
+                            if let Some(next) = parser.peek_clone() {
+                                if next.kind == TokenKind::Dot {
+                                    parser.advance(); // '.'
+                                    if let Some(after) = parser.peek_clone() {
+                                        if after.kind == TokenKind::Number {
+                                            parser.advance();
+                                            let combined =
+                                                format!("{}.{}", value_token.lexeme, after.lexeme);
+                                            map.insert(
+                                                key,
+                                                Value::Number(
+                                                    combined.parse::<f32>().unwrap_or(0.0),
+                                                ),
+                                            );
+                                            continue;
+                                        }
+                                    }
+                                }
+                            }
+                            map.insert(
+                                key,
+                                Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0)),
+                            );
+                        }
+                        TokenKind::Boolean => {
+                            parser.advance();
+                            map.insert(
+                                key,
+                                Value::Boolean(value_token.lexeme.parse::<bool>().unwrap_or(false)),
+                            );
+                        }
+                        _ => {
+                            // Unknown value type, consume and store Unknown
+                            parser.advance();
+                            map.insert(key, Value::Unknown);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Value::Map(map)
+}
+
+pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    let Some(target_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    if target_token.kind != TokenKind::Identifier {
+        parser.advance(); // consume target token
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
+    }
+
+    let Some(arrow_token) = parser.peek_nth(1).cloned() else {
+        parser.advance(); // consume arrow token
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
+    };
+
+    if arrow_token.kind != TokenKind::Arrow {
+        parser.advance(); // consume method token
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
+    }
+
+    // We have a valid arrow call, so we consume the arrow token
+    let Some(method_token) = parser.peek_nth(2).cloned() else {
+        parser.advance();
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
+    };
+
+    if method_token.kind != TokenKind::Identifier {
+        parser.advance();
+        return Statement::unknown_with_pos(
+            method_token.indent,
+            method_token.line,
+            method_token.column,
+        );
+    }
+
+    // Consume the tokens for target, arrow, and method
+    parser.advance(); // target
+    parser.advance(); // ->
+    parser.advance(); // method
+
+    let mut args = Vec::new();
+    let mut paren_depth = 0;
+    let mut map_depth = 0;
+
+    while let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
+            break;
+        }
+        if token.kind == TokenKind::LParen {
+            paren_depth += 1;
+        }
+        if token.kind == TokenKind::RParen {
+            if paren_depth > 0 {
+                paren_depth -= 1;
+                parser.advance();
+                if paren_depth == 0 {
+                    break;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+        if token.kind == TokenKind::LBrace {
+            map_depth += 1;
+        }
+        if token.kind == TokenKind::RBrace {
+            if map_depth > 0 {
+                map_depth -= 1;
+                parser.advance();
+                if map_depth == 0 {
+                    continue;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+
+        parser.advance();
+
+        let value = match token.kind {
+            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
+            TokenKind::String => Value::String(token.lexeme.clone()),
+            TokenKind::Number => {
+                // support fraction literal as bare arg: 1/4
+                // note: token has already been advanced earlier in the loop
+                if let Some(TokenKind::Slash) = parser.peek_kind() {
+                    parser.advance(); // consume '/'
+                    if let Some(den) = parser.peek_clone() {
+                        if den.kind == TokenKind::Number || den.kind == TokenKind::Identifier {
+                            parser.advance();
+                            let beat = format!("{}/{}", token.lexeme, den.lexeme);
+                            Value::Duration(devalang_types::Duration::Beat(beat))
+                        } else {
+                            Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+                        }
+                    } else {
+                        Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+                    }
+                } else {
+                    Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+                }
+            }
+            TokenKind::LBrace => {
+                // Handle map literal (supports nested maps)
+
+                // We consumed the matching '}', so outer map_depth should be decremented
+                // if the caller tracks it.
+                parse_map_literal(parser)
+            }
+            _ => Value::Unknown,
+        };
+
+        args.push(value);
+
+        // Stop if we reach the end of the statement
+        if paren_depth == 0 && (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace)
+        {
+            break;
+        }
+    }
+
+    Statement {
+        kind: StatementKind::ArrowCall {
+            target: target_token.lexeme.clone(),
+            method: method_token.lexeme.clone(),
+            args,
+        },
+        value: Value::Null,
+        indent: target_token.indent,
+        line: target_token.line,
+        column: target_token.column,
+    }
+}