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

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

@@ -1,126 +1,253 @@
-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,
+        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 {
+                                        parser.advance();
+                                        let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
+                                        map.insert(key, Value::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 => 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,
+    }
+}