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

package/rust/core/parser/driver.rs

@@ -1,584 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        handler::{
-            arrow_call::parse_arrow_call,
-            at::parse_at_token,
-            bank::parse_bank_token,
-            condition::parse_condition_token,
-            dot::parse_dot_token,
-            identifier::{
-                emit::parse_emit_token, function::parse_function_token, on::parse_on_token,
-                parse_identifier_token,
-            },
-            loop_::parse_loop_token,
-            pattern::parse_pattern_token,
-            tempo::parse_tempo_token,
-        },
-        statement::Statement,
-    },
-    store::global::GlobalStore,
-};
-
-#[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> {
-        if self.is_eof() {
-            return None;
-        }
-
-        self.previous = self.tokens.get(self.token_index).cloned();
-        self.token_index += 1;
-
-        self.tokens.get(self.token_index - 1)
-    }
-
-    pub fn peek_is(&self, expected: &str) -> bool {
-        self.peek().is_some_and(|t| t.lexeme == expected)
-    }
-
-    pub fn peek_nth(&self, n: usize) -> Option<&Token> {
-        if self.token_index + n < self.tokens.len() {
-            self.tokens.get(self.token_index + n)
-        } else {
-            None
-        }
-    }
-
-    pub fn peek_nth_kind(&self, n: usize) -> Option<TokenKind> {
-        self.peek_nth(n).map(|t| t.kind.clone())
-    }
-
-    pub fn advance_if(&mut self, kind: TokenKind) -> bool {
-        self.match_token(kind)
-    }
-
-    pub fn match_token(&mut self, kind: TokenKind) -> bool {
-        if let Some(tok) = self.peek() {
-            if tok.kind == kind {
-                self.advance();
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn previous_clone(&self) -> Option<Token> {
-        self.previous.clone()
-    }
-
-    pub fn parse_block(
-        &self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore,
-    ) -> Vec<Statement> {
-        let mut inner_parser = Parser {
-            resolve_modules: self.resolve_modules,
-            tokens,
-            token_index: 0,
-            current_module: self.current_module.clone(),
-            previous: None,
-        };
-
-        inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-    }
-
-    pub fn parse_tokens(
-        &mut self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore,
-    ) -> Vec<Statement> {
-        // Filter out Whitespace tokens but keep Newline tokens because some constructs (e.g., print ...)
-        // rely on end-of-line semantics.
-        self.tokens = tokens
-            .into_iter()
-            .filter(|t| t.kind != TokenKind::Whitespace)
-            .collect();
-        self.token_index = 0;
-
-        let mut statements = Vec::new();
-
-        while !self.is_eof() {
-            let token = match self.peek() {
-                Some(t) => t.clone(),
-                None => {
-                    break;
-                }
-            };
-
-            if token.kind == TokenKind::Newline {
-                self.advance();
-                continue;
-            }
-
-            let statement = match &token.kind {
-                TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => {
-                    if let Some(next) = self.peek_nth(1).cloned() {
-                        if next.kind == TokenKind::Arrow {
-                            parse_arrow_call(self, global_store)
-                        } else {
-                            parse_identifier_token(self, global_store)
-                        }
-                    } else {
-                        parse_identifier_token(self, global_store)
-                    }
-                }
-                TokenKind::Dot => parse_dot_token(self, global_store),
-                TokenKind::Tempo => parse_tempo_token(self, global_store),
-                TokenKind::Bank => parse_bank_token(self, global_store),
-                TokenKind::Pattern => parse_pattern_token(self, global_store),
-                TokenKind::Loop => parse_loop_token(self, global_store),
-                TokenKind::If => parse_condition_token(self, global_store),
-                TokenKind::Function => parse_function_token(self, global_store),
-                TokenKind::On => parse_on_token(self, global_store),
-                TokenKind::Emit => parse_emit_token(self, token.clone(), global_store),
-
-                | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
-                | TokenKind::Comment
-                | TokenKind::Equals
-                | TokenKind::Colon
-                | TokenKind::Number
-                | TokenKind::String
-                | TokenKind::LBrace
-                | TokenKind::RBrace
-                | TokenKind::Comma
-                | TokenKind::Dedent
-                | TokenKind::Indent => {
-                    self.advance();
-                    continue;
-                }
-
-                TokenKind::EOF => {
-                    break;
-                }
-
-                _ => {
-                    self.advance();
-                    Statement::unknown_with_pos(token.indent, token.line, token.column)
-                }
-            };
-
-            statements.push(statement);
-        }
-
-        statements
-    }
-
-    pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().is_some_and(|t| t.kind == kind)
-    }
-
-    pub fn peek_kind(&self) -> Option<TokenKind> {
-        self.peek().map(|t| t.kind.clone())
-    }
-
-    pub fn parse_map_value(&mut self) -> Option<Value> {
-        let logger = devalang_utils::logger::Logger::new();
-        use devalang_utils::logger::LogLevel;
-        if !self.match_token(TokenKind::LBrace) {
-            return None;
-        }
-
-        let mut map = std::collections::HashMap::new();
-
-        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            // Skip separators and formatting before the key
-            while self.check_token(TokenKind::Newline)
-                || self.check_token(TokenKind::Whitespace)
-                || self.check_token(TokenKind::Indent)
-                || self.check_token(TokenKind::Dedent)
-                || self.check_token(TokenKind::Comma)
-            {
-                self.advance();
-            }
-
-            // Check if we are at the closing brace of the map
-            if self.check_token(TokenKind::RBrace) {
-                break;
-            }
-
-            let key = if let Some(token) = self.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 self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
-                self.advance();
-            }
-
-            if !self.match_token(TokenKind::Colon) {
-                logger.log_message(
-                    LogLevel::Error,
-                    &format!("Expected ':' after map key '{}'", key),
-                );
-                break;
-            }
-
-            // Skip separators and formatting before value
-            while self.check_token(TokenKind::Newline)
-                || self.check_token(TokenKind::Whitespace)
-                || self.check_token(TokenKind::Indent)
-                || self.check_token(TokenKind::Dedent)
-                || self.check_token(TokenKind::Comma)
-            {
-                self.advance();
-            }
-
-            let value = if let Some(token) = self.peek_clone() {
-                match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        let mut number_str = token.lexeme.clone();
-                        self.advance(); // consume the first number
-
-                        if let Some(dot_token) = self.peek_clone() {
-                            if dot_token.kind == TokenKind::Dot {
-                                self.advance(); // consume the dot
-
-                                if let Some(decimal_token) = self.peek_clone() {
-                                    if decimal_token.kind == TokenKind::Number {
-                                        self.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);
-                                }
-                            }
-                        }
-
-                        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()];
-                        self.advance();
-                        loop {
-                            let Some(next) = self.peek_clone() else { break };
-                            if next.line != current_line {
-                                break;
-                            }
-                            if next.kind == TokenKind::Dot {
-                                // Consume '.' and the following identifier/number on same line
-                                self.advance(); // dot
-                                if let Some(id2) = self.peek_clone() {
-                                    if id2.line == current_line
-                                        && (id2.kind == TokenKind::Identifier
-                                            || id2.kind == TokenKind::Number)
-                                    {
-                                        parts.push(id2.lexeme.clone());
-                                        self.advance(); // consume part
-                                        continue;
-                                    }
-                                }
-                                break;
-                            } else {
-                                break;
-                            }
-                        }
-                        Value::Identifier(parts.join("."))
-                    }
-                    _ => {
-                        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 self.check_token(TokenKind::Comma)
-                || self.check_token(TokenKind::Whitespace)
-                || self.check_token(TokenKind::Newline)
-            {
-                self.advance();
-            }
-        }
-
-        if !self.match_token(TokenKind::RBrace) {
-            logger.log_message(LogLevel::Error, "Expected '}' at end of map");
-        }
-
-        Some(Value::Map(map))
-    }
-
-    // Parse an array value like [1, 2, 3] or ["a", b]
-    pub fn parse_array_value(&mut self) -> Option<Value> {
-        let logger = devalang_utils::logger::Logger::new();
-        use devalang_utils::logger::LogLevel;
-        if !self.match_token(TokenKind::LBracket) {
-            return None;
-        }
-
-        let mut arr: Vec<Value> = Vec::new();
-
-        while !self.check_token(TokenKind::RBracket) && !self.is_eof() {
-            // Skip formatting tokens
-            while self.check_token(TokenKind::Newline)
-                || self.check_token(TokenKind::Whitespace)
-                || self.check_token(TokenKind::Indent)
-                || self.check_token(TokenKind::Dedent)
-                || self.check_token(TokenKind::Comma)
-            {
-                self.advance();
-            }
-
-            if self.check_token(TokenKind::RBracket) {
-                break;
-            }
-
-            if let Some(token) = self.peek_clone() {
-                let value = match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        // Support simple decimals split as number '.' number
-                        let mut number_str = token.lexeme.clone();
-                        self.advance();
-                        if let Some(dot) = self.peek_clone() {
-                            if dot.kind == TokenKind::Dot {
-                                if let Some(next) = self.peek_nth(1).cloned() {
-                                    if next.kind == TokenKind::Number {
-                                        self.advance(); // consume dot
-                                        self.advance(); // consume next number
-                                        number_str.push('.');
-                                        number_str.push_str(&next.lexeme);
-                                    }
-                                }
-                            }
-                        }
-                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
-                    }
-                    TokenKind::Identifier => {
-                        self.advance();
-                        Value::Identifier(token.lexeme.clone())
-                    }
-                    TokenKind::LBrace => {
-                        // Allow inline maps inside arrays
-                        if let Some(v) = self.parse_map_value() {
-                            v
-                        } else {
-                            Value::Null
-                        }
-                    }
-                    TokenKind::LBracket => {
-                        // Nested arrays
-                        if let Some(v) = self.parse_array_value() {
-                            v
-                        } else {
-                            Value::Null
-                        }
-                    }
-                    _ => {
-                        self.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 !self.match_token(TokenKind::RBracket) {
-            logger.log_message(LogLevel::Error, "Expected ']' at end of array");
-        }
-
-        Some(Value::Array(arr))
-    }
-
-    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> {
-        let mut tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
-                break;
-            }
-            if let Some(t) = self.advance() {
-                tokens.push(t.clone());
-            } else {
-                // Unexpected EOF while collecting block tokens: stop collecting
-                break;
-            }
-        }
-
-        tokens
-    }
-
-    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token>
-    where
-        F: Fn(&Token) -> bool,
-    {
-        let mut collected = Vec::new();
-        while let Some(token) = self.peek() {
-            if condition(token) {
-                break;
-            }
-            if token.kind == TokenKind::EOF {
-                break;
-            }
-            if let Some(t) = self.advance() {
-                collected.push(t.clone());
-            } else {
-                break;
-            }
-        }
-
-        collected
-    }
-
-    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> {
-        let mut block_tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            // Stop if we encounter an 'else' at same indent level
-            if tok.lexeme == "else" && tok.indent == base_indent {
-                break;
-            }
-            if let Some(t) = self.advance() {
-                block_tokens.push(t.clone());
-            } else {
-                break;
-            }
-        }
-
-        self.parse_block(block_tokens, global_store)
-    }
-
-    pub fn parse_condition_until_colon(&mut self) -> Option<Value> {
-        let tokens = self.collect_until(|t| t.kind == TokenKind::Colon);
-        if tokens.is_empty() {
-            return None;
-        }
-
-        let condition = tokens
-            .iter()
-            .map(|t| t.lexeme.clone())
-            .collect::<Vec<_>>()
-            .join(" ");
-
-        Some(Value::String(condition))
-    }
-
-    pub fn parse_block_until_else_or_dedent(
-        &mut self,
-        base_indent: usize,
-        global_store: &mut GlobalStore,
-    ) -> Vec<Statement> {
-        let mut tokens = Vec::new();
-
-        while let Some(tok) = self.peek() {
-            if tok.lexeme == "else" && tok.indent == base_indent {
-                break;
-            }
-            if tok.indent < base_indent && tok.kind != TokenKind::Newline {
-                break;
-            }
-            if let Some(t) = self.advance() {
-                tokens.push(t.clone());
-            } else {
-                break;
-            }
-        }
-
-        self.parse_block(tokens, global_store)
-    }
-}