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

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

@@ -0,0 +1,223 @@
+use crate::core::lexer::token::TokenKind;
+use devalang_types::Value;
+
+pub fn parse_map_value(parser: &mut crate::core::parser::driver::parser::Parser) -> Option<Value> {
+    let logger = devalang_utils::logger::Logger::new();
+    use devalang_utils::logger::LogLevel;
+    if !parser.match_token(TokenKind::LBrace) {
+        return None;
+    }
+
+    let mut map = std::collections::HashMap::new();
+
+    while !parser.check_token(TokenKind::RBrace) && !parser.is_eof() {
+        // Skip separators and formatting before the key
+        while parser.check_token(TokenKind::Newline)
+            || parser.check_token(TokenKind::Whitespace)
+            || parser.check_token(TokenKind::Indent)
+            || parser.check_token(TokenKind::Dedent)
+            || parser.check_token(TokenKind::Comma)
+        {
+            parser.advance();
+        }
+
+        // Check if we are at the closing brace of the map
+        if parser.check_token(TokenKind::RBrace) {
+            break;
+        }
+
+        let key = if let Some(token) = parser.advance() {
+            match token.kind {
+                TokenKind::Whitespace
+                | TokenKind::Indent
+                | TokenKind::Dedent
+                | TokenKind::Newline => {
+                    continue;
+                }
+                _ => token.lexeme.clone(),
+            }
+        } else {
+            break;
+        };
+
+        // Skip newlines and whitespace before colon
+        while parser.check_token(TokenKind::Newline) || parser.check_token(TokenKind::Whitespace) {
+            parser.advance();
+        }
+
+        if !parser.match_token(TokenKind::Colon) {
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Expected ':' after map key '{}'", key),
+            );
+            break;
+        }
+
+        // Skip separators and formatting before value
+        while parser.check_token(TokenKind::Newline)
+            || parser.check_token(TokenKind::Whitespace)
+            || parser.check_token(TokenKind::Indent)
+            || parser.check_token(TokenKind::Dedent)
+            || parser.check_token(TokenKind::Comma)
+        {
+            parser.advance();
+        }
+
+        let value = if let Some(token) = parser.peek_clone() {
+            match token.kind {
+                TokenKind::String => {
+                    parser.advance();
+                    Value::String(token.lexeme.clone())
+                }
+                TokenKind::Number => {
+                    // Handle number, decimal number and optional fraction form (e.g., 1/4)
+                    let mut number_str = token.lexeme.clone();
+                    parser.advance(); // consume the first number
+
+                    // decimal support: number '.' number
+                    if let Some(dot_token) = parser.peek_clone() {
+                        if dot_token.kind == TokenKind::Dot {
+                            parser.advance(); // consume the dot
+
+                            if let Some(decimal_token) = parser.peek_clone() {
+                                if decimal_token.kind == TokenKind::Number {
+                                    parser.advance(); // consume the number after the dot
+                                    number_str.push('.');
+                                    number_str.push_str(&decimal_token.lexeme);
+                                } else {
+                                    logger.log_message(
+                                        LogLevel::Error,
+                                        &format!(
+                                            "Expected number after dot, got {:?}",
+                                            decimal_token
+                                        ),
+                                    );
+                                    return Some(Value::Null);
+                                }
+                            } else {
+                                logger.log_message(
+                                    LogLevel::Error,
+                                    "Expected number after dot, but reached EOF",
+                                );
+                                return Some(Value::Null);
+                            }
+                        }
+                    }
+
+                    // Fraction support: number '/' number  -> Duration::Beat("num/den")
+                    if let Some(slash_tok) = parser.peek_clone() {
+                        if slash_tok.kind == TokenKind::Slash {
+                            // consume '/'
+                            parser.advance();
+                            if let Some(den_tok) = parser.peek_clone() {
+                                match den_tok.kind {
+                                    TokenKind::Number | TokenKind::Identifier => {
+                                        let frac = format!("{}/{}", number_str, den_tok.lexeme);
+                                        parser.advance();
+                                        return Some(Value::Duration(
+                                            devalang_types::Duration::Beat(frac),
+                                        ));
+                                    }
+                                    _ => {
+                                        logger.log_message(
+                                            LogLevel::Error,
+                                            &format!(
+                                                "Expected number or identifier after '/', got {:?}",
+                                                den_tok
+                                            ),
+                                        );
+                                        return Some(Value::Null);
+                                    }
+                                }
+                            } else {
+                                logger.log_message(
+                                    LogLevel::Error,
+                                    "Expected denominator after '/', but reached EOF",
+                                );
+                                return Some(Value::Null);
+                            }
+                        }
+                    }
+
+                    Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
+                }
+
+                TokenKind::Identifier => {
+                    // Support dotted identifiers in map values: alias.param or nested
+                    let current_line = token.line;
+                    let mut parts: Vec<String> = vec![token.lexeme.clone()];
+                    parser.advance();
+                    loop {
+                        let Some(next) = parser.peek_clone() else {
+                            break;
+                        };
+                        if next.line != current_line {
+                            break;
+                        }
+                        if next.kind == TokenKind::Dot {
+                            // Consume '.' and the following identifier/number on same line
+                            parser.advance(); // dot
+                            if let Some(id2) = parser.peek_clone() {
+                                if id2.line == current_line
+                                    && (id2.kind == TokenKind::Identifier
+                                        || id2.kind == TokenKind::Number)
+                                {
+                                    parts.push(id2.lexeme.clone());
+                                    parser.advance(); // consume part
+                                    continue;
+                                }
+                            }
+                            break;
+                        } else {
+                            break;
+                        }
+                    }
+                    Value::Identifier(parts.join("."))
+                }
+                TokenKind::LBracket => {
+                    // Allow arrays as map values
+                    if let Some(v) =
+                        crate::core::parser::driver::parse_array::parse_array_value(parser)
+                    {
+                        v
+                    } else {
+                        Value::Null
+                    }
+                }
+                TokenKind::LBrace => {
+                    // Allow inline nested maps as map values
+                    if let Some(v) = parse_map_value(parser) {
+                        v
+                    } else {
+                        Value::Null
+                    }
+                }
+                _ => {
+                    logger.log_message(
+                        LogLevel::Error,
+                        &format!("Unexpected token in map value: {:?}", token),
+                    );
+                    Value::Null
+                }
+            }
+        } else {
+            Value::Null
+        };
+
+        map.insert(key, value);
+
+        // Optionally skip a trailing comma after the value
+        while parser.check_token(TokenKind::Comma)
+            || parser.check_token(TokenKind::Whitespace)
+            || parser.check_token(TokenKind::Newline)
+        {
+            parser.advance();
+        }
+    }
+
+    if !parser.match_token(TokenKind::RBrace) {
+        logger.log_message(LogLevel::Error, "Expected '}' at end of map");
+    }
+
+    Some(Value::Map(map))
+}

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;
                                     }
                                 }
@@ -219,7 +224,26 @@ 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::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)