@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.11

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

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{statement::{Statement, StatementKind}, driver::Parser},
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'if'
+    let Some(if_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    let Some(condition) = parser.parse_condition_until_colon() else {
+        return Statement::error(if_token, "Expected condition after 'if'".to_string());
+    };
+
+    parser.advance_if(TokenKind::Colon);
+    let base_indent = if_token.indent;
+
+    let if_body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
+
+    let mut root_map = HashMap::new();
+    root_map.insert("condition".to_string(), condition);
+    root_map.insert("body".to_string(), Value::Block(if_body));
+
+    let mut current = &mut root_map;
+
+    // Loop for else / else if
+    while let Some(tok) = parser.peek_clone() {
+        // Only continue if we see `else` at same indent level
+        if tok.lexeme != "else" || tok.indent != base_indent {
+            break;
+        }
+
+        parser.advance(); // consume 'else'
+
+        // Check if it's an 'else if'
+        let next_condition = if parser.peek_is("if") {
+            parser.advance(); // consume 'if'
+            let Some(cond) = parser.parse_condition_until_colon() else {
+                return Statement::error(tok.clone(), "Expected condition after 'else if'".to_string());
+            };
+            parser.advance_if(TokenKind::Colon);
+            Some(cond)
+        } else {
+            parser.advance_if(TokenKind::Colon);
+            None
+        };
+
+        let body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
+
+        let mut next_map = HashMap::new();
+        if let Some(cond) = next_condition {
+            next_map.insert("condition".to_string(), cond);
+        }
+        next_map.insert("body".to_string(), Value::Block(body));
+
+        current.insert("next".to_string(), Value::Map(next_map));
+        current = match current.get_mut("next") {
+            Some(Value::Map(map)) => map,
+            _ => break,
+        };
+    }
+
+    Statement {
+        kind: StatementKind::If,
+        value: Value::Map(root_map),
+        indent: if_token.indent,
+        line: if_token.line,
+        column: if_token.column,
+    }
+}

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

@@ -0,0 +1,178 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::{ duration::Duration, value::Value },
+    store::global::GlobalStore,
+};
+
+pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume the first dot
+
+    let Some(dot_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Parse namespaced identifier: .808.kick.snare
+    let mut parts = Vec::new();
+
+    loop {
+        let Some(token) = parser.peek_clone() else {
+            break;
+        };
+
+        match token.kind {
+            // Stop if we encounter a likely duration keyword
+            TokenKind::Number => {
+                // If there's a slash after the number, it's probably a fraction (1/4)
+                if let Some(TokenKind::Slash) = parser.peek_nth_kind(1) {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Identifier => {
+                // Stop if it's the duration keyword "auto"
+                if token.lexeme == "auto" {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Dot => {
+                parser.advance(); // consume dot
+            }
+
+            _ => {
+                break;
+            }
+        }
+    }
+
+    let entity = parts.join(".");
+
+    if entity.is_empty() {
+        return Statement {
+            kind: StatementKind::Trigger {
+                entity: String::new(),
+                duration: Duration::Auto,
+            },
+            value: Value::Null,
+            indent: dot_token.indent,
+            line: dot_token.line,
+            column: dot_token.column,
+        };
+    }
+
+    // Check if there's a duration
+    let next = parser.peek_clone();
+
+    let (duration, value) = match next {
+        None => (Duration::Auto, Value::Null),
+
+        Some(token) =>
+            match token.kind {
+                TokenKind::Newline | TokenKind::EOF => (Duration::Auto, Value::Null),
+
+                TokenKind::Number => {
+                    let numerator = token.lexeme.clone();
+                    parser.advance(); // consume numerator
+
+                    if let Some(TokenKind::Slash) = parser.peek_kind() {
+                        parser.advance(); // consume slash
+
+                        if let Some(denominator_token) = parser.peek_clone() {
+                            if denominator_token.kind == TokenKind::Number {
+                                let denominator = denominator_token.lexeme.clone();
+                                parser.advance(); // consume denominator
+
+                                let beat_str = format!("{}/{}", numerator, denominator);
+                                let beat_duration = Duration::Beat(beat_str);
+
+                                let val = match parser.peek_clone() {
+                                    Some(param_token) if
+                                        param_token.kind == TokenKind::Identifier
+                                    => {
+                                        parser.advance();
+                                        Value::Identifier(param_token.lexeme.clone())
+                                    }
+                                    Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                                        parser.parse_map_value().unwrap_or(Value::Null)
+                                    }
+                                    _ => Value::Null,
+                                };
+
+                                return Statement {
+                                    kind: StatementKind::Trigger {
+                                        entity,
+                                        duration: beat_duration,
+                                    },
+                                    value: val,
+                                    indent: dot_token.indent,
+                                    line: dot_token.line,
+                                    column: dot_token.column,
+                                };
+                            }
+                        }
+                    }
+
+                    // fallback: simple numeric duration
+                    let duration = parse_duration(numerator);
+
+                    let val = match parser.peek_clone() {
+                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
+                            parser.advance();
+                            Value::Identifier(param_token.lexeme.clone())
+                        }
+                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                            parser.parse_map_value().unwrap_or(Value::Null)
+                        }
+                        _ => Value::Null,
+                    };
+
+                    (duration, val)
+                }
+
+                TokenKind::Identifier => {
+                    let duration_lexeme = token.lexeme.clone();
+                    parser.advance(); // consume duration
+
+                    let val = match parser.peek_clone() {
+                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
+                            parser.advance();
+                            Value::Identifier(param_token.lexeme.clone())
+                        }
+                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                            parser.parse_map_value().unwrap_or(Value::Null)
+                        }
+                        _ => Value::Null,
+                    };
+
+                    (parse_duration(duration_lexeme), val)
+                }
+
+                _ => (Duration::Auto, Value::Null),
+            }
+    };
+
+    Statement {
+        kind: StatementKind::Trigger { entity, duration },
+        value,
+        indent: dot_token.indent,
+        line: dot_token.line,
+        column: dot_token.column,
+    }
+}
+
+fn parse_duration(s: String) -> Duration {
+    if s == "auto" {
+        Duration::Auto
+    } else if let Ok(num) = s.parse::<f32>() {
+        Duration::Number(num)
+    } else {
+        Duration::Identifier(s)
+    }
+}

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

@@ -0,0 +1,41 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_call_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "call"
+
+    let value = if let Some(token) = parser.peek_clone() {
+        parser.advance();
+        match token.kind {
+            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
+            TokenKind::String => Value::String(token.lexeme.clone()),
+            _ => {
+                return Statement::error(
+                    token,
+                    "Expected identifier or string after 'call'".to_string()
+                );
+            }
+        }
+    } else {
+        return Statement::error(
+            current_token,
+            "Expected identifier or string after 'call'".to_string()
+        );
+    };
+
+    return Statement {
+        kind: StatementKind::Call,
+        value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    };
+}

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

@@ -0,0 +1,75 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+use std::collections::HashMap;
+
+pub fn parse_group_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "group"
+
+    let Some(identifier_token) = parser.peek_clone() else {
+        return Statement::error(current_token, "Expected identifier after 'group'".to_string());
+    };
+
+    if identifier_token.kind != TokenKind::Identifier && identifier_token.kind != TokenKind::String {
+        return Statement::error(identifier_token, "Expected valid identifier".to_string());
+    }
+
+    parser.advance(); // consume identifier
+
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(
+            identifier_token,
+            "Expected ':' after group identifier".to_string()
+        );
+    };
+
+    if colon_token.kind != TokenKind::Colon {
+        return Statement::error(
+            colon_token.clone(),
+            "Expected ':' after group identifier".to_string()
+        );
+    }
+
+    parser.advance(); // consume ':'
+
+    let base_indent = current_token.indent;
+
+    // Clone without consuming tokens
+    let mut index = parser.token_index;
+    let mut tokens_inside_group = Vec::new();
+
+    while index < parser.tokens.len() {
+        let token = parser.tokens[index].clone();
+
+        if token.indent <= base_indent && token.kind != TokenKind::Newline {
+            break;
+        }
+
+        tokens_inside_group.push(token);
+        index += 1;
+    }
+
+    // Advance index once to skip the processed tokens
+    parser.token_index = index;
+
+    let body = parser.parse_block(tokens_inside_group, global_store);
+
+    let mut value_map = HashMap::new();
+    value_map.insert("identifier".to_string(), Value::String(identifier_token.lexeme.clone()));
+    value_map.insert("body".to_string(), Value::Block(body));
+
+    return Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(value_map),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    };
+}

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

@@ -0,0 +1,133 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{
+        driver::Parser,
+        handler::identifier::synth::parse_synth_token,
+        statement::{ Statement, StatementKind },
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_let_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "let"
+
+    let identifier = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Identifier {
+            parser.advance();
+            token.lexeme.clone()
+        } else {
+            return Statement::error(token, "Expected identifier after 'let'".to_string());
+        }
+    } else {
+        return Statement::error(current_token, "Expected identifier after 'let'".to_string());
+    };
+
+    if !parser.match_token(TokenKind::Equals) {
+        return Statement::error(current_token, "Expected '=' after identifier".to_string());
+    }
+
+    if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Synth {
+            let synth_stmt = parse_synth_token(parser, token.clone(), global_store);
+
+            return Statement {
+                kind: StatementKind::Let { name: identifier },
+                value: synth_stmt.value,
+                indent: current_token.indent,
+                line: current_token.line,
+                column: current_token.column,
+            };
+        }
+    }
+
+    let value = match parser.peek_clone() {
+        Some(token) if token.kind == TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::String => {
+            parser.advance();
+            Value::String(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::Number => {
+            parser.advance();
+            Value::Number(token.lexeme.parse().unwrap_or(0.0))
+        }
+        Some(token) if token.kind == TokenKind::Boolean => {
+            parser.advance();
+            Value::Boolean(token.lexeme.parse().unwrap_or(false))
+        }
+        Some(token) if token.kind == TokenKind::LBrace => {
+            parser.advance(); // consume '{'
+            let mut map = HashMap::new();
+
+            while let Some(key_token) = parser.peek_clone() {
+                if key_token.kind == TokenKind::RBrace {
+                    parser.advance(); // consume '}'
+                    break;
+                }
+
+                if key_token.kind != TokenKind::Identifier {
+                    return Statement::error(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);
+                }
+
+                let val = match parser.peek_clone() {
+                    Some(t) if t.kind == TokenKind::Number => {
+                        parser.advance();
+                        Value::Number(t.lexeme.parse().unwrap_or(0.0))
+                    }
+                    Some(t) if t.kind == TokenKind::String => {
+                        parser.advance();
+                        Value::String(t.lexeme.clone())
+                    }
+                    Some(t) if t.kind == TokenKind::Identifier => {
+                        parser.advance();
+                        Value::Identifier(t.lexeme.clone())
+                    }
+                    _ => Value::Null,
+                };
+
+                if val == Value::Null {
+                    let message = format!("Invalid value for key '{}'", key);
+                    return Statement::error(token, message);
+                }
+
+                map.insert(key, val);
+
+                if let Some(t) = parser.peek() {
+                    if t.kind == TokenKind::Comma {
+                        parser.advance(); // skip comma
+                    }
+                }
+            }
+
+            Value::Map(map)
+        }
+        other => {
+            let message = format!("Unexpected value token in let: {:?}", other);
+            return Statement::error(current_token, message);
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Let { name: identifier },
+        value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -0,0 +1,51 @@
+pub mod let_;
+pub mod group;
+pub mod call;
+pub mod spawn;
+pub mod sleep;
+pub mod synth;
+
+use crate::core::{
+    parser::{
+        driver::Parser,
+        handler::{
+            identifier::{
+                call::parse_call_token,
+                group::parse_group_token,
+                let_::parse_let_token,
+                sleep::parse_sleep_token,
+                spawn::parse_spawn_token,
+                synth::parse_synth_token
+            },
+        },
+        statement::Statement,
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    let Some(current_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    let current_token_clone = current_token.clone();
+    let current_token_lexeme = current_token_clone.lexeme.clone();
+
+    let statement = 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),
+        "spawn" => parse_spawn_token(parser, current_token_clone, global_store),
+        "sleep" => parse_sleep_token(parser, current_token_clone, global_store),
+        "synth" => parse_synth_token(parser, current_token_clone, global_store),
+        _ => {
+            parser.advance(); // consume identifier
+
+            println!("Unrecognized identifier: {}", current_token_lexeme);
+
+            return Statement::error(current_token_clone, "Unexpected identifier".to_string());
+        }
+    };
+
+    return statement;
+}

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

@@ -0,0 +1,33 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_sleep_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "sleep"
+
+    let duration = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Number {
+            parser.advance();
+            token.lexeme.parse().unwrap_or(0.0)
+        } else {
+            return Statement::error(token, "Expected number after 'sleep'".to_string());
+        }
+    } else {
+        return Statement::error(current_token, "Expected number after 'sleep'".to_string());
+    };
+
+    return 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

@@ -0,0 +1,41 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_spawn_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+        parser.advance(); // consume "spawn"
+
+        let value = if let Some(token) = parser.peek_clone() {
+            parser.advance();
+            match token.kind {
+                TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
+                TokenKind::String => Value::String(token.lexeme.clone()),
+                _ => {
+                    return Statement::error(
+                        token,
+                        "Expected identifier or string after 'spawn'".to_string()
+                    );
+                }
+            }
+        } else {
+            return Statement::error(
+                current_token,
+                "Expected identifier or string after 'spawn'".to_string()
+            );
+        };
+
+        return Statement {
+            kind: StatementKind::Spawn,
+            value,
+            indent: current_token.indent,
+            line: current_token.line,
+            column: current_token.column,
+        };
+}

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

@@ -0,0 +1,65 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_synth_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume 'synth'
+
+    let Some(synth_token) = parser.previous_clone() else {
+        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());
+    };
+
+    let synth_waveform = identifier_token.lexeme.clone();
+
+    parser.advance(); // consume identifier
+
+    // Expect synth optional parameters map
+    let mut parameters = HashMap::new();
+
+    if let Some(params) = parser.parse_map_value() {
+        // If parameters are provided, we expect a map
+        if let Value::Map(map) = params {
+            parameters = map;
+        } else {
+            return Statement::error(synth_token, "Expected a map for synth parameters".to_string());
+        }
+    } else {
+        // If no parameters are provided, we can still create the statement with an empty map
+        parameters = HashMap::new();
+    }
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(
+            HashMap::from([
+                ("entity".to_string(), Value::String("synth".to_string())),
+                (
+                    "value".to_string(),
+                    Value::Map(
+                        HashMap::from([
+                            ("waveform".to_string(), Value::String(synth_waveform)),
+                            ("parameters".to_string(), Value::Map(parameters)),
+                        ])
+                    ),
+                ),
+            ])
+        ),
+        indent: synth_token.indent,
+        line: synth_token.line,
+        column: synth_token.column,
+    }
+}