@devaloop/devalang 0.0.1-alpha.14 → 0.0.1-alpha.15

package/rust/core/parser/driver.rs

@@ -107,10 +107,11 @@ impl Parser {
         tokens: Vec<Token>,
         global_store: &mut GlobalStore
     ) -> Vec<Statement> {
-        // Filtrer les tokens Whitespace et Newline avant parsing
+        // Filtrer uniquement les espaces, mais conserver les Newline car
+        // certaines constructions (ex: print ...) s'appuient sur la fin de ligne.
         self.tokens = tokens
             .into_iter()
-            .filter(|t| t.kind != TokenKind::Whitespace && t.kind != TokenKind::Newline)
+            .filter(|t| t.kind != TokenKind::Whitespace)
             .collect();
         self.token_index = 0;
 
@@ -197,12 +198,13 @@ impl Parser {
         let mut map = std::collections::HashMap::new();
 
         while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            // Skip newlines, whitespace, indent, dedent before the key
+            // 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::Dedent) ||
+                self.check_token(TokenKind::Comma)
             {
                 self.advance();
             }
@@ -236,8 +238,14 @@ impl Parser {
                 break;
             }
 
-            // Skip newlines and whitespace before value
-            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+            // 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();
             }
 
@@ -291,6 +299,11 @@ impl Parser {
             };
 
             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) {
@@ -300,6 +313,79 @@ impl Parser {
         Some(Value::Map(map))
     }
 
+    // Parse an array value like [1, 2, 3] or ["a", b]
+    pub fn parse_array_value(&mut self) -> Option<Value> {
+        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) {
+            println!("Expected ']' at end of array");
+        }
+
+        Some(Value::Array(arr))
+    }
+
     pub fn peek(&self) -> Option<&Token> {
         self.tokens.get(self.token_index)
     }
@@ -333,14 +419,10 @@ impl Parser {
     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 {
+            if condition(token) {
                 break;
             }
-            if condition(token) {
+            if token.kind == TokenKind::EOF {
                 break;
             }
             collected.push(self.advance().unwrap().clone());

package/rust/core/parser/handler/arrow_call.rs

@@ -5,7 +5,104 @@ use crate::core::{
     store::global::GlobalStore,
 };
 
-pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+fn parse_map_literal(parser: &mut Parser) -> Value {
+    // Assumes '{' has already been consumed by caller
+    let mut map = std::collections::HashMap::new();
+    loop {
+        let Some(inner_token) = parser.peek_clone() else { break; };
+
+        match inner_token.kind {
+            TokenKind::RBrace => {
+                parser.advance(); // consume '}'
+                break;
+            }
+            TokenKind::Newline | TokenKind::Comma => {
+                parser.advance();
+                continue;
+            }
+            _ => {}
+        }
+
+        // Key
+        parser.advance();
+        let key = inner_token.lexeme.clone();
+
+        // Expect ':'
+        if let Some(colon_token) = parser.peek_clone() {
+            if colon_token.kind == TokenKind::Colon {
+                parser.advance(); // consume ':'
+
+                // Value
+                if let Some(value_token) = parser.peek_clone() {
+                    match value_token.kind {
+                        TokenKind::LBrace => {
+                            parser.advance(); // consume '{'
+                            let nested = parse_map_literal(parser);
+                            map.insert(key, nested);
+                        }
+                        TokenKind::Identifier => {
+                            parser.advance();
+                            let v = if value_token.lexeme == "true" {
+                                Value::Boolean(true)
+                            } else if value_token.lexeme == "false" {
+                                Value::Boolean(false)
+                            } else {
+                                Value::Identifier(value_token.lexeme.clone())
+                            };
+                            map.insert(key, v);
+                        }
+                        TokenKind::String => {
+                            parser.advance();
+                            map.insert(key, Value::String(value_token.lexeme.clone()));
+                        }
+                        TokenKind::Number => {
+                            parser.advance();
+                            // Beat fraction support: NUMBER '/' NUMBER
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance(); // '/'
+                                if let Some(den) = parser.peek_clone() {
+                                    if den.kind == TokenKind::Number {
+                                        parser.advance();
+                                        let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
+                                        map.insert(key, Value::Beat(beat));
+                                        continue;
+                                    }
+                                }
+                            }
+                            // Decimal support NUMBER '.' NUMBER
+                            if let Some(next) = parser.peek_clone() {
+                                if next.kind == TokenKind::Dot {
+                                    parser.advance(); // '.'
+                                    if let Some(after) = parser.peek_clone() {
+                                        if after.kind == TokenKind::Number {
+                                            parser.advance();
+                                            let combined = format!("{}.{}", value_token.lexeme, after.lexeme);
+                                            map.insert(key, Value::Number(combined.parse::<f32>().unwrap_or(0.0)));
+                                            continue;
+                                        }
+                                    }
+                                }
+                            }
+                            map.insert(key, Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0)));
+                        }
+                        TokenKind::Boolean => {
+                            parser.advance();
+                            map.insert(key, Value::Boolean(value_token.lexeme.parse::<bool>().unwrap_or(false)));
+                        }
+                        _ => {
+                            // Unknown value type, consume and store Unknown
+                            parser.advance();
+                            map.insert(key, Value::Unknown);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Value::Map(map)
+}
+
+pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     let Some(target_token) = parser.peek_clone() else {
         return Statement::unknown();
     };
@@ -94,93 +191,16 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
 
         parser.advance();
 
-        let value = match token.kind {
+    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::LBrace => {
-                // Handle map literal
-                let mut map = std::collections::HashMap::new();
-                while let Some(inner_token) = parser.peek_clone() {
-                    if inner_token.kind == TokenKind::RBrace {
-                        parser.advance(); // consume RBrace
-                        break;
-                    }
-                    if inner_token.kind == TokenKind::Newline || inner_token.kind == TokenKind::EOF {
-                        break;
-                    }
-                    parser.advance(); // consume key token
-                    let key = inner_token.lexeme.clone();
-                    if let Some(colon_token) = parser.peek_clone() {
-                        if colon_token.kind == TokenKind::Colon {
-                            parser.advance(); // consume colon
-                            if let Some(value_token) = parser.peek_clone() {
-                                parser.advance(); // consume value token
-                                let value = match value_token.kind {
-                                    TokenKind::Identifier => {
-                                        // Interpret bare true/false as booleans
-                                        if value_token.lexeme == "true" {
-                                            Value::Boolean(true)
-                                        } else if value_token.lexeme == "false" {
-                                            Value::Boolean(false)
-                                        } else {
-                                            Value::Identifier(value_token.lexeme.clone())
-                                        }
-                                    },
-                                    TokenKind::String => Value::String(value_token.lexeme.clone()),
-                                    TokenKind::Number => {
-                                        // Support decimals (e.g., 0.8) and beats (e.g., 1/4)
-                                        if let Some(TokenKind::Slash) = parser.peek_kind() {
-                                            // Beat fraction
-                                            parser.advance(); // consume '/'
-                                            if let Some(denominator_token) = parser.peek_clone() {
-                                                if denominator_token.kind == TokenKind::Number {
-                                                    parser.advance(); // consume denominator
-                                                    let denominator = denominator_token.lexeme.clone();
-                                                    Value::Beat(format!("{}/{}", value_token.lexeme, denominator))
-                                                } else {
-                                                    Value::Unknown
-                                                }
-                                            } else {
-                                                Value::Unknown
-                                            }
-                                        } else if let Some(next) = parser.peek_clone() {
-                                            // Decimal number handling: NUMBER '.' NUMBER -> f32
-                                            if next.kind == TokenKind::Dot {
-                                                // consume '.'
-                                                parser.advance();
-                                                if let Some(after_dot) = parser.peek_clone() {
-                                                    if after_dot.kind == TokenKind::Number {
-                                                        parser.advance(); // consume fractional digits
-                                                        let combined = format!("{}.{}", value_token.lexeme, after_dot.lexeme);
-                                                        Value::Number(combined.parse::<f32>().unwrap_or(0.0))
-                                                    } else {
-                                                        // Lone dot without number, fallback to integer part
-                                                        Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
-                                                    }
-                                                } else {
-                                                    Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
-                                                }
-                                            } else {
-                                                // Regular integer number
-                                                Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
-                                            }
-                                        } else {
-                                            Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
-                                        }
-                                    }
-                                    TokenKind::Boolean =>
-                                        Value::Boolean(
-                                            value_token.lexeme.parse::<bool>().unwrap_or(false)
-                                        ),
-                                    _ => Value::Unknown,
-                                };
-                                map.insert(key, value);
-                            }
-                        }
-                    }
-                }
-                Value::Map(map)
+        // Handle map literal (supports nested maps)
+        let map_val = parse_map_literal(parser);
+        // We consumed the matching '}', so outer map_depth should be decremented
+        // if the caller tracks it.
+        map_val
             }
             _ => Value::Unknown,
         };
@@ -188,11 +208,7 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
         args.push(value);
 
         // Stop if we reach the end of the statement
-        if
-            paren_depth == 0 &&
-            map_depth == 0 &&
-            (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace)
-        {
+    if paren_depth == 0 && (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace) {
             break;
         }
     }

package/rust/core/parser/handler/at.rs

@@ -4,7 +4,7 @@ use crate::core::{
     shared::value::Value,
     store::global::GlobalStore,
 };
-pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume '@'
 
     let Some(token) = parser.peek_clone() else {

package/rust/core/parser/handler/dot.rs

@@ -19,7 +19,7 @@ pub fn parse_dot_token(
     let current_line = dot_token.line;
 
     while let Some(token) = parser.peek_clone() {
-        // Ne jamais traverser une nouvelle ligne
+        // Never cross a newline
         if token.line != current_line {
             break;
         }
@@ -27,7 +27,7 @@ pub fn parse_dot_token(
             TokenKind::Identifier | TokenKind::Number => {
                 parts.push(token.lexeme.clone());
                 parser.advance();
-                // Le séparateur doit être un '.' sur la même ligne, sinon on s'arrête
+                // The separator must be a '.' on the same line, otherwise stop
                 if let Some(next) = parser.peek_clone() {
                     if next.line != current_line || next.kind != TokenKind::Dot {
                         break;
@@ -61,7 +61,7 @@ pub fn parse_dot_token(
     let mut value = Value::Null;
 
     if let Some(token) = parser.peek_clone() {
-        // La durée et la map d'effets ne sont valides que sur la même ligne
+    // Duration and effects map are only valid on the same line
         if token.line == current_line {
             match token.kind {
             TokenKind::Number => {

package/rust/core/parser/handler/identifier/automate.rs

@@ -0,0 +1,194 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{driver::Parser, statement::{Statement, StatementKind}},
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+// Grammar:
+// automate <identifier>:
+//     param <name> { <percent>% = <number> ... }
+// Produces StatementKind::Automate with value map:
+// { target: Identifier, params: Map<paramName, Map<percent, Number>> }
+pub fn parse_automate_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume 'automate'
+
+    // Expect target identifier
+    let Some(target_token) = parser.peek_clone() else {
+        return Statement::error(current_token, "Expected target after 'automate'".to_string());
+    };
+
+    if target_token.kind != TokenKind::Identifier && target_token.kind != TokenKind::String {
+        return Statement::error(target_token, "Expected valid target after 'automate'".to_string());
+    }
+    parser.advance(); // consume target
+
+    // Expect ':'
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(target_token, "Expected ':' after automate target".to_string());
+    };
+    if colon_token.kind != TokenKind::Colon {
+        return Statement::error(colon_token, "Expected ':' after automate target".to_string());
+    }
+    parser.advance(); // consume ':'
+
+    let base_indent = current_token.indent;
+
+    // Collect tokens inside block (indented > base_indent)
+    let mut index = parser.token_index;
+    let mut tokens_inside = Vec::new();
+    while index < parser.tokens.len() {
+        let tok = parser.tokens[index].clone();
+        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
+            break;
+        }
+        tokens_inside.push(tok);
+        index += 1;
+    }
+    parser.token_index = index;
+
+    // Now parse block manually to capture 'param' entries without reusing general parser kinds
+    let mut local = Parser {
+        resolve_modules: parser.resolve_modules,
+        tokens: tokens_inside,
+        token_index: 0,
+        current_module: parser.current_module.clone(),
+        previous: None,
+    };
+
+    let mut params: HashMap<String, Value> = HashMap::new();
+
+    while let Some(tok) = local.peek_clone() {
+        match tok.kind {
+            TokenKind::Identifier if tok.lexeme == "param" => {
+                local.advance(); // consume 'param'
+                // param name
+                let Some(name_tok) = local.peek_clone() else {
+                    return Statement::error(tok, "Expected parameter name after 'param'".to_string());
+                };
+                if name_tok.kind != TokenKind::Identifier && name_tok.kind != TokenKind::String {
+                    return Statement::error(name_tok, "Expected valid parameter name".to_string());
+                }
+                local.advance(); // consume name
+
+                // Expect '{'
+                if !local.match_token(TokenKind::LBrace) {
+                    return Statement::error(name_tok, "Expected '{' to start parameter block".to_string());
+                }
+
+                // Collect entries like: 0% = 0.0
+                let mut envelope: HashMap<String, Value> = HashMap::new();
+                while let Some(inner) = local.peek_clone() {
+                    if inner.kind == TokenKind::RBrace { local.advance(); break; }
+                    // Skip formatting tokens inside the param block
+                    if matches!(inner.kind, TokenKind::Newline | TokenKind::Indent | TokenKind::Dedent | TokenKind::Comma) {
+                        local.advance();
+                        continue;
+                    }
+
+                    // Read percentage token: could be number followed by '%' as Dot or Identifier? '%' not defined.
+                    // Our lexer has no Percent token, so accept either Number or Identifier containing e.g. '0%'.
+                    let percent_token = inner.clone();
+                    local.advance();
+
+                    let percent_key = percent_token.lexeme.clone();
+
+                    // Expect '='
+                    // Skip any stray formatting between key and '='
+                    while let Some(t) = local.peek_kind() {
+                        if matches!(t, TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline) { local.advance(); continue; }
+                        break;
+                    }
+                    if !local.match_token(TokenKind::Equals) {
+                        return Statement::error(percent_token, "Expected '=' in param entry".to_string());
+                    }
+
+                    // Read value (number or identifier)
+                    // Skip formatting before value
+                    while let Some(t) = local.peek_kind() {
+                        if matches!(t, TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline) { local.advance(); continue; }
+                        break;
+                    }
+
+                    let value = if let Some(vtok) = local.peek_clone() {
+                        match vtok.kind {
+                            // Handle negative numbers where '-' is lexed as Arrow
+                            TokenKind::Arrow => {
+                                // Check if next token is a number
+                                let mut num_str = String::from("-");
+                                local.advance(); // consume '-'
+                                if let Some(ntok) = local.peek_clone() {
+                                    if ntok.kind == TokenKind::Number {
+                                        num_str.push_str(&ntok.lexeme);
+                                        local.advance(); // consume number
+                                        if let Some(dot) = local.peek_clone() {
+                                            if dot.kind == TokenKind::Dot {
+                                                local.advance();
+                                                if let Some(frac) = local.peek_clone() {
+                                                    if frac.kind == TokenKind::Number {
+                                                        num_str.push('.');
+                                                        num_str.push_str(&frac.lexeme);
+                                                        local.advance();
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        Value::Number(num_str.parse::<f32>().unwrap_or(0.0))
+                                    } else {
+                                        Value::Unknown
+                                    }
+                                } else {
+                                    Value::Unknown
+                                }
+                            }
+                            TokenKind::Number => {
+                                // Possibly a float with dot
+                                let mut number_str = vtok.lexeme.clone();
+                                local.advance();
+                                if let Some(dot) = local.peek_clone() {
+                                    if dot.kind == TokenKind::Dot {
+                                        local.advance();
+                                        if let Some(frac) = local.peek_clone() {
+                                            if frac.kind == TokenKind::Number {
+                                                number_str.push('.');
+                                                number_str.push_str(&frac.lexeme);
+                                                local.advance();
+                                            }
+                                        }
+                                    }
+                                }
+                                Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
+                            }
+                            TokenKind::Identifier => { local.advance(); Value::Identifier(vtok.lexeme.clone()) }
+                            TokenKind::String => { local.advance(); Value::String(vtok.lexeme.clone()) }
+                            _ => { local.advance(); Value::Unknown }
+                        }
+                    } else { Value::Null };
+
+                    envelope.insert(percent_key, value);
+                }
+
+                params.insert(name_tok.lexeme.clone(), Value::Map(envelope));
+            }
+            _ => { local.advance(); }
+        }
+    }
+
+    let mut value_map = HashMap::new();
+    value_map.insert("target".to_string(), Value::String(target_token.lexeme.clone()));
+    value_map.insert("params".to_string(), Value::Map(params));
+
+    Statement {
+        kind: StatementKind::Automate { target: target_token.lexeme.clone() },
+        value: Value::Map(value_map),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/handler/identifier/function.rs

@@ -29,7 +29,6 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
     parser.advance(); // consume function name
 
     let mut parameters = Vec::new();
-    let mut body = Vec::new();
 
     // Expect '('
     if parser.peek_kind() != Some(TokenKind::LParen) {
@@ -68,8 +67,8 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
         body_tokens.push(parser.advance().unwrap().clone());
     }
 
-    // arse those tokens into block statements
-    body = parser.parse_block(body_tokens.clone(), global_store);
+    // Parse those tokens into block statements
+    let body = parser.parse_block(body_tokens.clone(), global_store);
 
     // Skip Dedent if present
     if let Some(tok) = parser.peek() {

package/rust/core/parser/handler/identifier/let_.rs

@@ -33,6 +33,22 @@ pub fn parse_let_token(
         return Statement::error(current_token, "Expected '=' after identifier".to_string());
     }
 
+    // If RHS begins with '$' or contains expression tokens ('+', '-', '*', '/', '(', '['),
+    // collect the rest of the line as a raw expression string.
+    if let Some(tok) = parser.peek_clone() {
+        let line = tok.line;
+        if tok.lexeme.starts_with('$') || matches!(tok.kind, TokenKind::Identifier | TokenKind::Number | TokenKind::LParen | TokenKind::LBracket) {
+            // Collect tokens until end of the current line
+            let collected = parser.collect_until(|t| t.line != line || matches!(t.kind, TokenKind::Newline | TokenKind::EOF));
+            let mut text = String::new();
+            for t in collected.iter() {
+                if matches!(t.kind, TokenKind::Newline | TokenKind::EOF) { break; }
+                text.push_str(&t.lexeme);
+            }
+            return Statement { kind: StatementKind::Let { name: identifier }, value: Value::String(text.trim().to_string()), indent: current_token.indent, line: current_token.line, column: current_token.column };
+        }
+    }
+
     let value = match parser.peek_clone() {
         Some(token) if token.kind == TokenKind::Dot => {
             let dot_stmt = parse_dot_token(parser, global_store);