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

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,7 +1,7 @@
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
-        driver::Parser,
+        driver::parser::Parser,
         statement::{Statement, StatementKind},
     },
     store::global::GlobalStore,
@@ -66,10 +66,15 @@ fn parse_map_literal(parser: &mut Parser) -> Value {
                             if let Some(TokenKind::Slash) = parser.peek_kind() {
                                 parser.advance(); // '/'
                                 if let Some(den) = parser.peek_clone() {
-                                    if den.kind == TokenKind::Number {
+                                    if den.kind == TokenKind::Number
+                                        || den.kind == TokenKind::Identifier
+                                    {
                                         parser.advance();
                                         let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
-                                        map.insert(key, Value::Beat(beat));
+                                        map.insert(
+                                            key,
+                                            Value::Duration(devalang_types::Duration::Beat(beat)),
+                                        );
                                         continue;
                                     }
                                 }
@@ -175,6 +180,22 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
     parser.advance(); // ->
     parser.advance(); // method
 
+    let args = parse_arrow_args(parser);
+    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,
+    }
+}
+
+// Parse args after the method token. Reused by continuation parser.
+fn parse_arrow_args(parser: &mut Parser) -> Vec<Value> {
     let mut args = Vec::new();
     let mut paren_depth = 0;
     let mut map_depth = 0;
@@ -219,35 +240,89 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
         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)
+            TokenKind::Number => {
+                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 => 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;
         }
     }
 
+    args
+}
+
+// Parse an arrow continuation that begins with an Arrow token. If prev_target is Some,
+// use it as the call target; otherwise produce an Unknown statement.
+pub fn parse_arrow_continuation(
+    parser: &mut Parser,
+    _global_store: &mut GlobalStore,
+    prev_target: Option<String>,
+) -> Statement {
+    // We expect current token to be Arrow
+    let arrow_tok = parser.peek_clone();
+    if arrow_tok.is_none() {
+        return Statement::unknown();
+    }
+
+    // If there is no previous target, consume arrow and return unknown
+    let Some(target) = prev_target else {
+        parser.advance(); // consume Arrow
+        return Statement::unknown();
+    };
+
+    // consume '->'
+    parser.advance();
+
+    // next token should be method identifier
+    let Some(method_token) = parser.peek_nth(0).cloned() else {
+        return Statement::unknown();
+    };
+
+    if method_token.kind != TokenKind::Identifier {
+        parser.advance();
+        return Statement::unknown_with_pos(
+            method_token.indent,
+            method_token.line,
+            method_token.column,
+        );
+    }
+
+    // consume method
+    parser.advance();
+
+    let args = parse_arrow_args(parser);
+
     Statement {
         kind: StatementKind::ArrowCall {
-            target: target_token.lexeme.clone(),
+            target,
             method: method_token.lexeme.clone(),
             args,
         },
         value: Value::Null,
-        indent: target_token.indent,
-        line: target_token.line,
-        column: target_token.column,
+        indent: method_token.indent,
+        line: method_token.line,
+        column: method_token.column,
     }
 }