@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,120 +0,0 @@
-use crate::core::lexer::token::TokenKind;
-use devalang_types::Value;
-
-pub fn parse_array_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::LBracket) {
-        return None;
-    }
-
-    let mut arr: Vec<Value> = Vec::new();
-
-    while !parser.check_token(TokenKind::RBracket) && !parser.is_eof() {
-        // Skip formatting tokens
-        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();
-        }
-
-        if parser.check_token(TokenKind::RBracket) {
-            break;
-        }
-
-        if let Some(token) = parser.peek_clone() {
-            let value = match token.kind {
-                TokenKind::String => {
-                    parser.advance();
-                    Value::String(token.lexeme.clone())
-                }
-                TokenKind::Number => {
-                    // Support decimals and fraction literals (e.g., 1/4 -> Duration::Beat("1/4"))
-                    let mut number_str = token.lexeme.clone();
-                    parser.advance();
-                    if let Some(dot) = parser.peek_clone() {
-                        if dot.kind == TokenKind::Dot {
-                            if let Some(next) = parser.peek_nth(1).cloned() {
-                                if next.kind == TokenKind::Number {
-                                    parser.advance(); // consume dot
-                                    parser.advance(); // consume next number
-                                    number_str.push('.');
-                                    number_str.push_str(&next.lexeme);
-                                }
-                            }
-                        }
-                    }
-
-                    // Fraction form: number '/' number or identifier
-                    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();
-                                        Value::Duration(devalang_types::Duration::Beat(frac))
-                                    }
-                                    _ => Value::Number(number_str.parse::<f32>().unwrap_or(0.0)),
-                                }
-                            } else {
-                                Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
-                            }
-                        } else {
-                            Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
-                        }
-                    } else {
-                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
-                    }
-                }
-                TokenKind::Identifier => {
-                    parser.advance();
-                    Value::Identifier(token.lexeme.clone())
-                }
-                TokenKind::LBrace => {
-                    // Allow inline maps inside arrays
-                    if let Some(v) = crate::core::parser::driver::parse_map::parse_map_value(parser)
-                    {
-                        v
-                    } else {
-                        Value::Null
-                    }
-                }
-                TokenKind::LBracket => {
-                    // Nested arrays
-                    if let Some(v) = parse_array_value(parser) {
-                        v
-                    } else {
-                        Value::Null
-                    }
-                }
-                _ => {
-                    parser.advance();
-                    Value::Null
-                }
-            };
-
-            // Only push non-null (retain alignment with permissive parsing)
-            if value != Value::Null {
-                arr.push(value);
-            }
-
-            // Optional trailing comma handled by the skipper at loop start
-        } else {
-            break;
-        }
-    }
-
-    if !parser.match_token(TokenKind::RBracket) {
-        logger.log_message(LogLevel::Error, "Expected ']' at end of array");
-    }
-
-    Some(Value::Array(arr))
-}

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

@@ -1,247 +0,0 @@
-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();
-        }
-
-        // Accept both 'key: value' and short form 'key value' for convenience.
-        let mut saw_colon = false;
-        if parser.match_token(TokenKind::Colon) {
-            saw_colon = true;
-        } else {
-            // Peek to see if the next token looks like a value; if so, accept short form.
-            if let Some(peek) = parser.peek_clone() {
-                match peek.kind {
-                    TokenKind::String
-                    | TokenKind::Number
-                    | TokenKind::Identifier
-                    | TokenKind::LBracket
-                    | TokenKind::LBrace => {
-                        // short form accepted, do not consume here; value parsing will handle it
-                    }
-                    _ => {
-                        logger.log_message(
-                            LogLevel::Error,
-                            &format!("Expected ':' after map key '{}'", key),
-                        );
-                        break;
-                    }
-                }
-            } else {
-                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

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