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

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

@@ -1,160 +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,
-        )
-    }
-}
+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

@@ -180,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;
@@ -225,8 +241,6 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             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() {
@@ -244,34 +258,71 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
                     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::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,
     }
 }