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

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,26 +72,35 @@ 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 =
-            parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+            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 {
@@ -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/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;

package/rust/core/parser/statement.rs

@@ -1,142 +1,11 @@
-use crate::core::{
-    lexer::token::Token,
-    shared::{duration::Duration, value::Value},
-};
-use serde::{Deserialize, Serialize};
+use crate::core::lexer::token::Token;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct Statement {
-    pub kind: StatementKind,
-    pub value: Value,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Statement {
-    pub fn unknown() -> Self {
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::Null,
-            indent: 0,
-            line: 0,
-            column: 0,
-        }
-    }
-
-    pub fn unknown_from_token(token: &Token) -> Self {
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::Null,
-            indent: token.indent,
-            line: token.line,
-            column: token.column,
-        }
-    }
+pub use devalang_types::{Duration, Statement, StatementKind, Value};
 
-    pub fn error(token: Token, message: String) -> Self {
-        Statement {
-            kind: StatementKind::Error { message },
-            value: Value::Null,
-            indent: token.indent,
-            line: token.line,
-            column: token.column,
-        }
-    }
+pub fn unknown_from_token(token: &Token) -> Statement {
+    Statement::unknown_with_pos(token.indent, token.line, token.column)
 }
 
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub enum StatementKind {
-    // ───── Core Instructions ─────
-    Tempo,
-    Bank {
-        alias: Option<String>,
-    },
-    Print,
-    Load {
-        source: String,
-        alias: String,
-    },
-    Use {
-        name: String,
-        alias: Option<String>,
-    },
-    Let {
-        name: String,
-    },
-    Automate {
-        target: String,
-    },
-    ArrowCall {
-        target: String,
-        method: String,
-        args: Vec<Value>,
-    },
-    Function {
-        name: String,
-        parameters: Vec<String>,
-        body: Vec<Statement>,
-    },
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Playback / Scheduling ─────
-    Trigger {
-        entity: String,
-        duration: Duration,
-        effects: Option<Value>,
-    },
-    Sleep,
-    Call {
-        name: String,
-        args: Vec<Value>,
-    },
-    Spawn {
-        name: String,
-        args: Vec<Value>,
-    },
-    Loop,
-
-    // ───── Structure & Logic ─────
-    Group,
-
-    // ───── Module System ─────
-    Include(String),
-    Export {
-        names: Vec<String>,
-        source: String,
-    },
-    Import {
-        names: Vec<String>,
-        source: String,
-    },
-
-    // ───── Conditions ─────
-    If,
-    Else,
-    ElseIf,
-
-    // ───── Internal / Utility ─────
-    Comment,
-    Indent,
-    Dedent,
-    NewLine,
-
-    // ───── Events / Live coding ─────
-    On {
-        event: String,
-        args: Option<Vec<Value>>,
-        body: Vec<Statement>,
-    },
-    Emit {
-        event: String,
-        payload: Option<Value>,
-    },
-
-    // ───── Error Handling ─────
-    Unknown,
-    Error {
-        message: String,
-    },
+pub fn error_from_token(token: Token, message: String) -> Statement {
+    Statement::error_with_pos(token.indent, token.line, token.column, message)
 }