@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

package/rust/core/lexer/handler/colon.rs

@@ -4,7 +4,7 @@ pub fn handle_colon_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/comment.rs

@@ -4,7 +4,7 @@ pub fn handle_comment_lexer(
     _char: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

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

@@ -4,7 +4,7 @@ pub fn handle_dot_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/driver.rs

@@ -23,7 +23,7 @@ fn advance_char<I: Iterator<Item = char>>(
     _line: &mut usize,
     column: &mut usize,
 ) -> Option<char> {
-    while let Some(c) = chars.next() {
+    for c in chars.by_ref() {
         if c == '\r' {
             continue;
         } else if c == '\n' {

package/rust/core/lexer/handler/identifier.rs

@@ -4,7 +4,7 @@ pub fn handle_identifier_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/mod.rs

@@ -1,11 +1,10 @@
-pub mod driver;
-
 pub mod arrow;
 pub mod at;
 pub mod brace;
 pub mod colon;
 pub mod comment;
 pub mod dot;
+pub mod driver;
 pub mod identifier;
 pub mod indent;
 pub mod newline;

package/rust/core/lexer/handler/number.rs

@@ -4,7 +4,7 @@ pub fn handle_number_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/operator.rs

@@ -4,7 +4,7 @@ pub fn handle_operator_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/parenthesis.rs

@@ -4,7 +4,7 @@ pub fn handle_rparen_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,
@@ -24,7 +24,7 @@ pub fn handle_lparen_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/slash.rs

@@ -4,7 +4,7 @@ pub fn handle_slash_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/string.rs

@@ -4,7 +4,7 @@ pub fn handle_string_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/mod.rs

@@ -10,6 +10,12 @@ use std::path::Path;
 
 pub struct Lexer {}
 
+impl Default for Lexer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Lexer {
     pub fn new() -> Self {
         Lexer {}
@@ -19,36 +25,40 @@ impl Lexer {
         handle_content_lexing(source.to_string())
     }
 
-    pub fn lex_tokens(&self, entrypoint: &str) -> Vec<Token> {
+    pub fn lex_tokens(&self, entrypoint: &str) -> Result<Vec<Token>, String> {
         let path = normalize_path(entrypoint);
-        let resolved_path = Self::resolve_entry_path(&path);
+        let resolved_path = Self::resolve_entry_path(&path)?;
 
-        let file_content =
-            fs::read_to_string(&resolved_path).expect("Failed to read the entrypoint file");
+        let file_content = fs::read_to_string(&resolved_path).map_err(|e| {
+            format!(
+                "Failed to read the entrypoint file '{}': {}",
+                resolved_path, e
+            )
+        })?;
 
-        handle_content_lexing(file_content).expect("Failed to lex the content")
+        handle_content_lexing(file_content).map_err(|e| format!("Failed to lex the content: {}", e))
     }
 
-    fn resolve_entry_path(path: &str) -> String {
+    fn resolve_entry_path(path: &str) -> Result<String, String> {
         let candidate = Path::new(path);
 
         if candidate.is_dir() {
             let index_path = candidate.join("index.deva");
             if index_path.exists() {
-                return index_path.to_string_lossy().replace("\\", "/");
+                Ok(index_path.to_string_lossy().replace("\\", "/"))
             } else {
-                panic!(
+                Err(format!(
                     "Expected 'index.deva' in directory '{}', but it was not found",
                     path
-                );
+                ))
             }
         } else if candidate.is_file() {
-            return path.to_string();
+            return Ok(path.to_string());
         } else {
-            panic!(
+            return Err(format!(
                 "Provided entrypoint '{}' is not a valid file or directory",
                 path
-            );
+            ));
         }
     }
 }

package/rust/core/lexer/token.rs

@@ -1,97 +1,90 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Token {
-    pub kind: TokenKind,
-    pub lexeme: String,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Token {
-    pub fn is_error(&self) -> bool {
-        match &self.kind {
-            TokenKind::Error(_) => {
-                return true;
-            }
-            _ => {
-                return false;
-            }
-        };
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum TokenKind {
-    // ───── Keywords ─────
-    At,
-    Tempo,
-    Bank,
-    Loop,
-    Function,
-    As,
-    On,
-    Emit,
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Literals ─────
-    Identifier,
-    Number,
-    String,
-    Boolean,
-    Arrow,
-
-    // ───── Structures ─────
-    Map,
-    Array,
-
-    // ───── Symbols ─────
-    Colon,
-    Comma,
-    Equals,
-    Dot,
-    Slash,
-    Plus,
-    Asterisk,
-    Minus,
-
-    // ───── Operators ─────
-    DoubleEquals,
-    NotEquals,
-    GreaterEqual,
-    LessEqual,
-    Greater,
-    Less,
-
-    // ───── Brackets ─────
-    LBrace,   // {
-    RBrace,   // }
-    LBracket, // [
-    RBracket, // ]
-    LParen,   // (
-    RParen,   // )
-
-    // ───── Quotes ─────
-    Quote,   // '
-    DbQuote, // "
-
-    // ───── Formatting ─────
-    Newline,
-    Indent,
-    Dedent,
-    Comment,
-
-    // ───── Conditions ─────
-    If,
-    Else,
-    ElseIf,
-
-    // ───── Special / Internal ─────
-    Whitespace,
-    Unknown,
-    Error(String),
-    EOF,
-}
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Token {
+    pub kind: TokenKind,
+    pub lexeme: String,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Token {
+    pub fn is_error(&self) -> bool {
+        matches!(&self.kind, TokenKind::Error(_))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum TokenKind {
+    // ───── Keywords ─────
+    At,
+    Tempo,
+    Bank,
+    Loop,
+    Function,
+    As,
+    On,
+    Emit,
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Literals ─────
+    Identifier,
+    Number,
+    String,
+    Boolean,
+    Arrow,
+
+    // ───── Structures ─────
+    Map,
+    Array,
+
+    // ───── Symbols ─────
+    Colon,
+    Comma,
+    Equals,
+    Dot,
+    Slash,
+    Plus,
+    Asterisk,
+    Minus,
+
+    // ───── Operators ─────
+    DoubleEquals,
+    NotEquals,
+    GreaterEqual,
+    LessEqual,
+    Greater,
+    Less,
+
+    // ───── Brackets ─────
+    LBrace,   // {
+    RBrace,   // }
+    LBracket, // [
+    RBracket, // ]
+    LParen,   // (
+    RParen,   // )
+
+    // ───── Quotes ─────
+    Quote,   // '
+    DbQuote, // "
+
+    // ───── Formatting ─────
+    Newline,
+    Indent,
+    Dedent,
+    Comment,
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Special / Internal ─────
+    Whitespace,
+    Unknown,
+    Error(String),
+    EOF,
+}

package/rust/core/mod.rs

@@ -6,6 +6,5 @@ pub mod lexer;
 pub mod parser;
 pub mod plugin;
 pub mod preprocessor;
-pub mod shared;
 pub mod store;
 pub mod utils;

package/rust/core/parser/driver.rs

@@ -1,3 +1,5 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::{Token, TokenKind},
     parser::{
@@ -7,13 +9,15 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
-            identifier::{function::parse_function_token, parse_identifier_token},
+            identifier::{
+                emit::parse_emit_token, function::parse_function_token, on::parse_on_token,
+                parse_identifier_token,
+            },
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
         statement::Statement,
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -26,6 +30,12 @@ pub struct Parser {
     pub previous: Option<Token>,
 }
 
+impl Default for Parser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Parser {
     pub fn new() -> Self {
         Parser {
@@ -53,7 +63,7 @@ impl Parser {
     }
 
     pub fn peek_is(&self, expected: &str) -> bool {
-        self.peek().map_or(false, |t| t.lexeme == expected)
+        self.peek().is_some_and(|t| t.lexeme == expected)
     }
 
     pub fn peek_nth(&self, n: usize) -> Option<&Token> {
@@ -69,7 +79,7 @@ impl Parser {
     }
 
     pub fn advance_if(&mut self, kind: TokenKind) -> bool {
-        if self.match_token(kind) { true } else { false }
+        self.match_token(kind)
     }
 
     pub fn match_token(&mut self, kind: TokenKind) -> bool {
@@ -149,8 +159,8 @@ impl Parser {
                 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 => crate::core::parser::handler::identifier::on::parse_on_token(self, global_store),
-                TokenKind::Emit => crate::core::parser::handler::identifier::emit::parse_emit_token(self, token.clone(), 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
@@ -173,7 +183,7 @@ impl Parser {
 
                 _ => {
                     self.advance();
-                    Statement::unknown_from_token(&token)
+                    Statement::unknown_with_pos(token.indent, token.line, token.column)
                 }
             };
 
@@ -184,7 +194,7 @@ impl Parser {
     }
 
     pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().map_or(false, |t| t.kind == kind)
+        self.peek().is_some_and(|t| t.kind == kind)
     }
 
     pub fn peek_kind(&self) -> Option<TokenKind> {
@@ -285,8 +295,34 @@ impl Parser {
                     }
 
                     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();
-                        Value::Identifier(token.lexeme.clone())
+                        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("."))
                     }
                     _ => {
                         println!("Unexpected token in map value: {:?}", token);
@@ -430,7 +466,12 @@ impl Parser {
             if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
                 break;
             }
-            tokens.push(self.advance().unwrap().clone());
+            if let Some(t) = self.advance() {
+                tokens.push(t.clone());
+            } else {
+                // Unexpected EOF while collecting block tokens: stop collecting
+                break;
+            }
         }
 
         tokens
@@ -448,7 +489,11 @@ impl Parser {
             if token.kind == TokenKind::EOF {
                 break;
             }
-            collected.push(self.advance().unwrap().clone());
+            if let Some(t) = self.advance() {
+                collected.push(t.clone());
+            } else {
+                break;
+            }
         }
 
         collected
@@ -470,7 +515,11 @@ impl Parser {
             if tok.lexeme == "else" && tok.indent == base_indent {
                 break;
             }
-            block_tokens.push(self.advance().unwrap().clone());
+            if let Some(t) = self.advance() {
+                block_tokens.push(t.clone());
+            } else {
+                break;
+            }
         }
 
         self.parse_block(block_tokens, global_store)
@@ -505,7 +554,11 @@ impl Parser {
             if tok.indent < base_indent && tok.kind != TokenKind::Newline {
                 break;
             }
-            tokens.push(self.advance().unwrap().clone());
+            if let Some(t) = self.advance() {
+                tokens.push(t.clone());
+            } else {
+                break;
+            }
         }
 
         self.parse_block(tokens, global_store)

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

@@ -4,9 +4,9 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 fn parse_map_literal(parser: &mut Parser) -> Value {
     // Assumes '{' has already been consumed by caller
@@ -126,28 +126,48 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 
     if target_token.kind != TokenKind::Identifier {
         parser.advance(); // consume target token
-        return Statement::unknown_from_token(&target_token);
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
     }
 
     let Some(arrow_token) = parser.peek_nth(1).cloned() else {
         parser.advance(); // consume arrow token
-        return Statement::unknown_from_token(&target_token);
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
     };
 
     if arrow_token.kind != TokenKind::Arrow {
         parser.advance(); // consume method token
-        return Statement::unknown_from_token(&target_token);
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
     }
 
     // We have a valid arrow call, so we consume the arrow token
     let Some(method_token) = parser.peek_nth(2).cloned() else {
         parser.advance();
-        return Statement::unknown_from_token(&target_token);
+        return Statement::unknown_with_pos(
+            target_token.indent,
+            target_token.line,
+            target_token.column,
+        );
     };
 
     if method_token.kind != TokenKind::Identifier {
         parser.advance();
-        return Statement::unknown_from_token(&method_token);
+        return Statement::unknown_with_pos(
+            method_token.indent,
+            method_token.line,
+            method_token.column,
+        );
     }
 
     // Consume the tokens for target, arrow, and method
@@ -202,10 +222,10 @@ pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             TokenKind::Number => Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0)),
             TokenKind::LBrace => {
                 // 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
+                parse_map_literal(parser)
             }
             _ => Value::Unknown,
         };