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

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

@@ -7,9 +7,9 @@ use crate::core::{
         handler::{dot::parse_dot_token, identifier::synth::parse_synth_token},
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_let_token(
     parser: &mut Parser,
@@ -23,14 +23,23 @@ pub fn parse_let_token(
             parser.advance();
             token.lexeme.clone()
         } else {
-            return Statement::error(token, "Expected identifier after 'let'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                token,
+                "Expected identifier after 'let'".to_string(),
+            );
         }
     } else {
-        return Statement::error(current_token, "Expected identifier after 'let'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected identifier after 'let'".to_string(),
+        );
     };
 
     if !parser.match_token(TokenKind::Equals) {
-        return Statement::error(current_token, "Expected '=' after identifier".to_string());
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected '=' after identifier".to_string(),
+        );
     }
 
     // If RHS begins with '$' or contains expression tokens ('+', '-', '*', '/', '(', '['),
@@ -101,14 +110,17 @@ pub fn parse_let_token(
                 }
 
                 if key_token.kind != TokenKind::Identifier {
-                    return Statement::error(token, "Expected key identifier in map".to_string());
+                    return crate::core::parser::statement::error_from_token(
+                        token,
+                        "Expected key identifier in map".to_string(),
+                    );
                 }
                 parser.advance();
                 let key = key_token.lexeme.clone();
 
                 if !parser.match_token(TokenKind::Colon) {
                     let message = format!("Expected ':' after key '{}'", key);
-                    return Statement::error(token, message);
+                    return crate::core::parser::statement::error_from_token(token, message);
                 }
 
                 let val = match parser.peek_clone() {
@@ -129,7 +141,7 @@ pub fn parse_let_token(
 
                 if val == Value::Null {
                     let message = format!("Invalid value for key '{}'", key);
-                    return Statement::error(token, message);
+                    return crate::core::parser::statement::error_from_token(token, message);
                 }
 
                 map.insert(key, val);
@@ -144,13 +156,16 @@ pub fn parse_let_token(
             Value::Map(map)
         }
         _ => {
-            return Statement::error(current_token, "Unhandled value type after '='".to_string());
+            return crate::core::parser::statement::error_from_token(
+                current_token,
+                "Unhandled value type after '='".to_string(),
+            );
         }
     };
 
     Statement {
         kind: StatementKind::Let { name: identifier },
-        value: value,
+        value,
         indent: current_token.indent,
         line: current_token.line,
         column: current_token.column,

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

@@ -32,7 +32,7 @@ pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStor
     let current_token_clone = current_token.clone();
     let current_token_lexeme = current_token_clone.lexeme.clone();
 
-    let statement = match current_token_lexeme.as_str() {
+    match current_token_lexeme.as_str() {
         "let" => parse_let_token(parser, current_token_clone, global_store),
         "group" => parse_group_token(parser, current_token_clone, global_store),
         "call" => parse_call_token(parser, current_token_clone, global_store),
@@ -46,9 +46,10 @@ pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStor
         _ => {
             parser.advance(); // consume identifier
 
-            return Statement::error(current_token_clone, "Unexpected identifier".to_string());
+            crate::core::parser::statement::error_from_token(
+                current_token_clone,
+                "Unexpected identifier".to_string(),
+            )
         }
-    };
-
-    return statement;
+    }
 }

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

@@ -1,16 +1,14 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
-// Syntax:
-// on <identifier>:
-//   <indented block>
 pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     // consume 'on'
     let on_tok = match parser.peek_clone() {
@@ -23,9 +21,17 @@ pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
     let event_tok = match parser.peek_clone() {
         Some(tok) if tok.kind == TokenKind::Identifier => tok,
         Some(other) => {
-            return Statement::error(other, "Expected event name after 'on'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                other,
+                "Expected event name after 'on'".to_string(),
+            );
+        }
+        None => {
+            return crate::core::parser::statement::error_from_token(
+                on_tok,
+                "Expected event name after 'on'".to_string(),
+            );
         }
-        None => return Statement::error(on_tok, "Expected event name after 'on'".to_string()),
     };
     let event_name = event_tok.lexeme.clone();
     parser.advance();
@@ -68,7 +74,10 @@ pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> S
 
     // Expect ':' then block
     if parser.peek_kind() != Some(TokenKind::Colon) {
-        return Statement::error(event_tok, "Expected ':' after event name".to_string());
+        return crate::core::parser::statement::error_from_token(
+            event_tok,
+            "Expected ':' after event name".to_string(),
+        );
     }
     parser.advance(); // consume ':'
 

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

@@ -6,6 +6,7 @@ use crate::core::{
     },
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_print_token(
     parser: &mut Parser,
@@ -19,17 +20,13 @@ pub fn parse_print_token(
     // Accept: print <identifier|string|number|expression>
     let value = if collected.len() == 1 {
         match collected[0].kind {
-            TokenKind::Identifier => {
-                crate::core::shared::value::Value::Identifier(collected[0].lexeme.clone())
-            }
-            TokenKind::String => {
-                crate::core::shared::value::Value::String(collected[0].lexeme.clone())
-            }
+            TokenKind::Identifier => Value::Identifier(collected[0].lexeme.clone()),
+            TokenKind::String => Value::String(collected[0].lexeme.clone()),
             TokenKind::Number => {
                 let n = collected[0].lexeme.parse::<f32>().unwrap_or(0.0);
-                crate::core::shared::value::Value::Number(n)
+                Value::Number(n)
             }
-            _ => crate::core::shared::value::Value::String(collected[0].lexeme.clone()),
+            _ => Value::String(collected[0].lexeme.clone()),
         }
     } else {
         // Join tokens with spaces to preserve readability for expressions/text
@@ -39,7 +36,7 @@ pub fn parse_print_token(
             .map(|t| t.lexeme.clone())
             .collect::<Vec<_>>()
             .join(" ");
-        crate::core::shared::value::Value::String(text.trim().to_string())
+        Value::String(text.trim().to_string())
     };
 
     Statement {

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

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::{Token, TokenKind},
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -20,17 +21,23 @@ pub fn parse_sleep_token(
             parser.advance();
             token.lexeme.parse().unwrap_or(0.0)
         } else {
-            return Statement::error(token, "Expected number after 'sleep'".to_string());
+            return crate::core::parser::statement::error_from_token(
+                token,
+                "Expected number after 'sleep'".to_string(),
+            );
         }
     } else {
-        return Statement::error(current_token, "Expected number after 'sleep'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected number after 'sleep'".to_string(),
+        );
     };
 
-    return Statement {
+    Statement {
         kind: StatementKind::Sleep,
         value: Value::Number(duration),
         indent: current_token.indent,
         line: current_token.line,
         column: current_token.column,
-    };
+    }
 }

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

@@ -4,9 +4,9 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_spawn_token(
     parser: &mut Parser,
@@ -19,7 +19,7 @@ pub fn parse_spawn_token(
     let name_token = match parser.peek_clone() {
         Some(t) => t,
         None => {
-            return Statement::error(
+            return crate::core::parser::statement::error_from_token(
                 current_token,
                 "Expected function name after 'spawn'".to_string(),
             );
@@ -27,7 +27,7 @@ pub fn parse_spawn_token(
     };
 
     if name_token.kind != TokenKind::Identifier {
-        return Statement::error(
+        return crate::core::parser::statement::error_from_token(
             name_token,
             "Expected function name to be an identifier".to_string(),
         );
@@ -68,7 +68,7 @@ pub fn parse_spawn_token(
                         parser.advance(); // skip comma
                     }
                     _ => {
-                        return Statement::error(
+                        return crate::core::parser::statement::error_from_token(
                             token,
                             "Unexpected token in spawn arguments".to_string(),
                         );

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

@@ -1,12 +1,14 @@
 use std::collections::HashMap;
 
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::Token,
     parser::{
         driver::Parser,
+        handler::dot::parse_dot_token,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -21,14 +23,81 @@ pub fn parse_synth_token(
         return Statement::unknown();
     };
 
-    // Expect an identifier (synth waveform)
-    let Some(identifier_token) = parser.peek_clone() else {
-        return Statement::error(synth_token, "Expected identifier after 'synth'".to_string());
-    };
+    // Expect a provider/waveform identifier (can be dotted: alias.synth)
+    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
+    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
+        use crate::core::lexer::token::TokenKind;
 
-    let synth_waveform = identifier_token.lexeme.clone();
+        if first_token.kind == TokenKind::Dot {
+            // Parse dot-entity and extract its entity string
+            let dot_stmt = parse_dot_token(parser, _global_store);
+            // Extract entity if the parsed statement is a Trigger
+            match dot_stmt.kind {
+                StatementKind::Trigger { entity, .. } => entity,
+                _ => String::new(),
+            }
+        } else {
+            if first_token.kind != crate::core::lexer::token::TokenKind::Identifier
+                && first_token.kind != crate::core::lexer::token::TokenKind::Number
+                && first_token.kind != crate::core::lexer::token::TokenKind::Synth
+            {
+                return crate::core::parser::statement::error_from_token(
+                    first_token.clone(),
+                    "Expected identifier after 'synth'".to_string(),
+                );
+            }
 
-    parser.advance(); // consume identifier
+            // Collect dotted parts on the same line
+            let mut parts: Vec<String> = Vec::new();
+            let current_line = first_token.line;
+            loop {
+                let Some(tok) = parser.peek_clone() else {
+                    break;
+                };
+                if tok.line != current_line {
+                    break;
+                }
+                match tok.kind {
+                    crate::core::lexer::token::TokenKind::Identifier
+                    | crate::core::lexer::token::TokenKind::Number
+                    | crate::core::lexer::token::TokenKind::Synth => {
+                        parts.push(tok.lexeme.clone());
+                        parser.advance();
+                        // If next isn't a dot on same line, stop
+                        if let Some(next) = parser.peek_clone() {
+                            if !(next.line == current_line
+                                && next.kind == crate::core::lexer::token::TokenKind::Dot)
+                            {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    crate::core::lexer::token::TokenKind::Dot => {
+                        parser.advance();
+                    }
+                    _ => break,
+                }
+            }
+
+            parts.join(".")
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            synth_token,
+            "Expected identifier after 'synth'".to_string(),
+        );
+    };
+
+    // Skip formatting before optional parameters map
+    while parser.check_token(crate::core::lexer::token::TokenKind::Newline)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Indent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Dedent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Whitespace)
+    {
+        parser.advance();
+    }
 
     // Expect synth optional parameters map
     let parameters = if let Some(params) = parser.parse_map_value() {
@@ -36,7 +105,7 @@ pub fn parse_synth_token(
         if let Value::Map(map) = params {
             map
         } else {
-            return Statement::error(
+            return crate::core::parser::statement::error_from_token(
                 synth_token,
                 "Expected a map for synth parameters".to_string(),
             );
@@ -53,7 +122,8 @@ pub fn parse_synth_token(
             (
                 "value".to_string(),
                 Value::Map(HashMap::from([
-                    ("waveform".to_string(), Value::String(synth_waveform)),
+                    // Store waveform as identifier to allow resolution from variables/exports
+                    ("waveform".to_string(), Value::Identifier(synth_waveform)),
                     ("parameters".to_string(), Value::Map(parameters)),
                 ])),
             ),

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

@@ -1,10 +1,11 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
@@ -20,7 +21,12 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
 
     // Peek next to decide
     let Some(next_token) = parser.peek_clone() else {
-        return Statement::error(loop_token, "Expected iterator after loop/for".to_string());
+        return Statement::error_with_pos(
+            loop_token.indent,
+            loop_token.line,
+            loop_token.column,
+            "Expected iterator after loop/for".to_string(),
+        );
     };
 
     // Try to detect 'for <ident> in [array]:' form
@@ -66,22 +72,31 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
                     Value::Identifier(tok.lexeme.clone())
                 }
                 _ => {
-                    return Statement::error(
-                        loop_token,
+                    return Statement::error_with_pos(
+                        loop_token.indent,
+                        loop_token.line,
+                        loop_token.column,
                         "Expected array, number, string or identifier after 'in'".to_string(),
                     );
                 }
             }
         } else {
-            return Statement::error(
-                loop_token,
+            return Statement::error_with_pos(
+                loop_token.indent,
+                loop_token.line,
+                loop_token.column,
                 "Expected array, number, string or identifier after 'in'".to_string(),
             );
         };
 
         // Expect ':'
         if !parser.match_token(TokenKind::Colon) {
-            return Statement::error(loop_token, "Expected ':' after foreach header".to_string());
+            return Statement::error_with_pos(
+                loop_token.indent,
+                loop_token.line,
+                loop_token.column,
+                "Expected ':' after foreach header".to_string(),
+            );
         }
 
         let tokens =
@@ -109,8 +124,10 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
 
     // Fallback to legacy: loop <count>:
     let Some(iterator_token) = parser.peek_clone() else {
-        return Statement::error(
-            loop_token,
+        return Statement::error_with_pos(
+            loop_token.indent,
+            loop_token.line,
+            loop_token.column,
             "Expected number or identifier after 'loop'".to_string(),
         );
     };
@@ -133,8 +150,10 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
             Value::String(s)
         }
         _ => {
-            return Statement::error(
-                iterator_token.clone(),
+            return Statement::error_with_pos(
+                iterator_token.clone().indent,
+                iterator_token.clone().line,
+                iterator_token.clone().column,
                 "Expected a number, string or identifier as loop count".to_string(),
             );
         }
@@ -145,10 +164,16 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
             "Expected ':' after loop count, got {:?}",
             parser.peek_kind()
         );
-        return Statement::error(loop_token.clone(), message);
+        return Statement::error_with_pos(
+            loop_token.clone().indent,
+            loop_token.clone().line,
+            loop_token.clone().column,
+            message,
+        );
     }
 
-    let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+    let tokens =
+        parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
     let loop_body = parser.parse_block(tokens.clone(), global_store);
     if let Some(token) = parser.peek() {
         if token.kind == TokenKind::Dedent {

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

@@ -1,6 +1,7 @@
 pub mod arrow_call;
 pub mod at;
 pub mod bank;
+pub mod pattern;
 pub mod condition;
 pub mod dot;
 pub mod identifier;

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

@@ -0,0 +1,74 @@
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    // consume 'pattern'
+    parser.advance();
+
+    let Some(tok) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Parse pattern name
+    let mut name = String::new();
+    if let Some(next) = parser.peek_clone() {
+        if next.kind == TokenKind::Identifier {
+            parser.advance();
+            name = next.lexeme.clone();
+        }
+    }
+
+    // optional 'with <target>' sequence
+    let mut target: Option<String> = None;
+    if parser.peek_is("with") {
+        parser.advance(); // consume 'with'
+        if let Some(tok2) = parser.peek_clone() {
+            // target can be identifier or dotted identifier
+            if tok2.kind == TokenKind::Identifier {
+                parser.advance();
+                let mut base = tok2.lexeme.clone();
+                if let Some(dot) = parser.peek_clone() {
+                    if dot.kind == TokenKind::Dot {
+                        parser.advance();
+                        if let Some(suf) = parser.peek_clone() {
+                            if suf.kind == TokenKind::Identifier || suf.kind == TokenKind::Number {
+                                parser.advance();
+                                base.push('.');
+                                base.push_str(&suf.lexeme);
+                            }
+                        }
+                    }
+                }
+                target = Some(base);
+            }
+        }
+    }
+
+    // optional '=' and pattern string
+    let mut value: Value = Value::Null;
+    if parser.peek_is("=") {
+        parser.advance();
+        if let Some(tok3) = parser.peek_clone() {
+            if tok3.kind == TokenKind::String {
+                parser.advance();
+                value = Value::String(tok3.lexeme.clone());
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Pattern { name, target },
+        value,
+        indent: tok.indent,
+        line: tok.line,
+        column: tok.column,
+    }
+}

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

@@ -4,9 +4,9 @@ use crate::core::{
         driver::Parser,
         statement::{Statement, StatementKind},
     },
-    shared::value::Value,
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume 'bpm'
@@ -17,8 +17,10 @@ pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -
 
     // Expect a number or identifier
     let Some(value_token) = parser.peek_clone() else {
-        return Statement::error(
-            tempo_token,
+        return Statement::error_with_pos(
+            tempo_token.indent,
+            tempo_token.line,
+            tempo_token.column,
             "Expected a number or identifier after 'bpm'".to_string(),
         );
     };
@@ -33,8 +35,10 @@ pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -
             Value::Identifier(value_token.lexeme.clone())
         }
         _ => {
-            return Statement::error(
-                value_token.clone(),
+            return Statement::error_with_pos(
+                value_token.indent,
+                value_token.line,
+                value_token.column,
                 format!(
                     "Expected a number or identifier after 'bpm', got {:?}",
                     value_token.kind

package/rust/core/parser/mod.rs

@@ -1,4 +1,3 @@
 pub mod driver;
-
 pub mod handler;
 pub mod statement;