@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/core/parser/driver.rs

@@ -1,312 +1,584 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        handler::{
-            at::parse_at_token,
-            bank::parse_bank_token,
-            condition::parse_condition_token,
-            dot::parse_dot_token,
-            identifier::parse_identifier_token,
-            loop_::parse_loop_token,
-            tempo::parse_tempo_token,
-        },
-        statement::{ Statement, StatementKind },
-    },
-    shared::value::Value,
-    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 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(); // mémorise avant de bouger
-        self.token_index += 1;
-
-        self.tokens.get(self.token_index - 1)
-    }
-
-    pub fn peek_is(&self, expected: &str) -> bool {
-        self.peek().map_or(false, |t| t.lexeme == expected)
-    }
-
-    pub fn advance_if(&mut self, kind: TokenKind) -> bool {
-        if self.match_token(kind) { true } else { false }
-    }
-
-    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> {
-        self.tokens = tokens;
-        self.token_index = 0;
-
-        let mut statements = Vec::new();
-
-        while !self.is_eof() {
-            let token = match self.peek() {
-                Some(t) => t.clone(),
-                None => {
-                    break;
-                }
-            };
-
-            let mut statement = match &token.kind {
-                TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => 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::Loop => parse_loop_token(self, global_store),
-                TokenKind::If => parse_condition_token(self, 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::Newline
-                | TokenKind::Dedent
-                | TokenKind::Indent => {
-                    self.advance();
-                    continue;
-                }
-
-                TokenKind::EOF => {
-                    break;
-                }
-
-                _ => {
-                    println!("Unhandled token: {:?}", token);
-                    self.advance();
-                    Statement::unknown()
-                }
-            };
-
-            statements.push(statement);
-        }
-
-        statements
-    }
-
-    pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().map_or(false, |t| t.kind == kind)
-    }
-
-    pub fn parse_map_value(&mut self) -> Option<Value> {
-        if !self.match_token(TokenKind::LBrace) {
-            return None;
-        }
-
-        let mut map = std::collections::HashMap::new();
-
-        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
-            } else {
-                break;
-            };
-
-            if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
-                break;
-            }
-
-            let value = if let Some(token) = self.peek_clone() {
-                match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
-                    }
-                    TokenKind::Identifier => {
-                        self.advance();
-                        Value::Identifier(token.lexeme.clone())
-                    }
-                    _ => {
-                        println!("Unexpected token in map value: {:?}", token);
-                        Value::Null
-                    }
-                }
-            } else {
-                Value::Null
-            };
-
-            map.insert(key, value);
-        }
-
-        if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
-        }
-
-        Some(Value::Map(map))
-    }
-
-    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;
-            }
-            tokens.push(self.advance().unwrap().clone());
-        }
-
-        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 token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
-                self.advance(); // Skip newlines and indents
-                continue;
-            }
-            if token.kind == TokenKind::EOF {
-                break;
-            }
-            if condition(token) {
-                break;
-            }
-            collected.push(self.advance().unwrap().clone());
-        }
-        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;
-            }
-            block_tokens.push(self.advance().unwrap().clone());
-        }
-
-        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;
-            }
-            tokens.push(self.advance().unwrap().clone());
-        }
-
-        self.parse_block(tokens, global_store)
-    }
-}
+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)
+    }
+}