@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/core/lexer/token.rs

@@ -1,97 +1,91 @@
-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,
+    Pattern,
+    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,16 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
-            identifier::{function::parse_function_token, parse_identifier_token},
+            pattern::parse_pattern_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 +31,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 +64,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 +80,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 {
@@ -146,11 +157,12 @@ impl Parser {
                 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 => 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 +185,7 @@ impl Parser {
 
                 _ => {
                     self.advance();
-                    Statement::unknown_from_token(&token)
+                    Statement::unknown_with_pos(token.indent, token.line, token.column)
                 }
             };
 
@@ -184,7 +196,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> {
@@ -192,6 +204,8 @@ impl Parser {
     }
 
     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;
         }
@@ -234,7 +248,7 @@ impl Parser {
             }
 
             if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
+                logger.log_message(LogLevel::Error, &format!("Expected ':' after map key '{}'", key));
                 break;
             }
 
@@ -268,14 +282,11 @@ impl Parser {
                                         number_str.push('.');
                                         number_str.push_str(&decimal_token.lexeme);
                                     } else {
-                                        println!(
-                                            "Expected number after dot, got {:?}",
-                                            decimal_token
-                                        );
+                                        logger.log_message(LogLevel::Error, &format!("Expected number after dot, got {:?}", decimal_token));
                                         return Some(Value::Null);
                                     }
                                 } else {
-                                    println!("Expected number after dot, but reached EOF");
+                                    logger.log_message(LogLevel::Error, "Expected number after dot, but reached EOF");
                                     return Some(Value::Null);
                                 }
                             }
@@ -285,11 +296,37 @@ 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);
+                        logger.log_message(LogLevel::Error, &format!("Unexpected token in map value: {:?}", token));
                         Value::Null
                     }
                 }
@@ -309,7 +346,7 @@ impl Parser {
         }
 
         if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
+            logger.log_message(LogLevel::Error, "Expected '}' at end of map");
         }
 
         Some(Value::Map(map))
@@ -317,6 +354,8 @@ impl Parser {
 
     // 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;
         }
@@ -400,7 +439,7 @@ impl Parser {
         }
 
         if !self.match_token(TokenKind::RBracket) {
-            println!("Expected ']' at end of array");
+            logger.log_message(LogLevel::Error, "Expected ']' at end of array");
         }
 
         Some(Value::Array(arr))
@@ -430,7 +469,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 +492,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 +518,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 +557,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,
         };