@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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

@@ -1,10 +1,14 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
-    shared::value::Value,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
-pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume '@'
 
     let Some(token) = parser.peek_clone() else {
@@ -14,11 +18,96 @@ pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> St
     let keyword = token.lexeme.as_str();
 
     match keyword {
+        "use" => {
+            parser.advance(); // consume 'use'
+            let Some(use_token) = parser.previous_clone() else {
+                return Statement::unknown();
+            };
+
+            // Expect plugin author
+            let Some(author_token) = parser.peek_clone() else {
+                return crate::core::parser::statement::error_from_token(
+                    use_token,
+                    "Expected plugin author".to_string(),
+                );
+            };
+            if author_token.kind != TokenKind::Identifier {
+                return crate::core::parser::statement::error_from_token(
+                    author_token,
+                    "Expected identifier for plugin author".to_string(),
+                );
+            }
+            parser.advance(); // consume author
+
+            // Expect '.'
+            if !parser.match_token(TokenKind::Dot) {
+                return crate::core::parser::statement::error_from_token(
+                    author_token,
+                    "Expected '.' after plugin author".to_string(),
+                );
+            }
+
+            // Expect plugin name
+            let Some(plugin_token) = parser.peek_clone() else {
+                return crate::core::parser::statement::error_from_token(
+                    author_token,
+                    "Expected plugin name".to_string(),
+                );
+            };
+
+            let name = match plugin_token.kind {
+                TokenKind::Identifier | TokenKind::Number => {
+                    parser.advance();
+                    format!("{}.{}", author_token.lexeme, plugin_token.lexeme)
+                }
+                _ => {
+                    return crate::core::parser::statement::error_from_token(
+                        plugin_token,
+                        "Expected identifier or number for plugin name".to_string(),
+                    );
+                }
+            };
+
+            // Optional alias
+            let alias = if parser.match_token(TokenKind::As) {
+                let Some(alias_token) = parser.peek_clone() else {
+                    return crate::core::parser::statement::error_from_token(
+                        use_token,
+                        "Expected identifier after 'as'".to_string(),
+                    );
+                };
+                if alias_token.kind != TokenKind::Identifier {
+                    return crate::core::parser::statement::error_from_token(
+                        alias_token,
+                        "Expected identifier after 'as'".to_string(),
+                    );
+                }
+                parser.advance();
+                Some(alias_token.lexeme.clone())
+            } else {
+                None
+            };
+
+            Statement {
+                kind: StatementKind::Use {
+                    name: name.clone(),
+                    alias,
+                },
+                value: Value::Null,
+                indent: use_token.indent,
+                line: use_token.line,
+                column: use_token.column,
+            }
+        }
+
         "import" => {
             parser.advance(); // consume 'import'
 
             if !parser.match_token(TokenKind::LBrace) {
-                return Statement::error(token, "Expected '{{' after 'import'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected '{{' after 'import'".to_string(),
+                );
             }
 
             let mut names = Vec::new();
@@ -36,31 +125,44 @@ pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> St
                         break;
                     }
                     _ => {
-                        let message = format!(
-                            "Unexpected token in import list: {:?}",
-                            token.kind.clone()
+                        let message =
+                            format!("Unexpected token in import list: {:?}", token.kind.clone());
+                        return crate::core::parser::statement::error_from_token(
+                            token.clone(),
+                            message,
                         );
-                        return Statement::error(token.clone(), message);
                     }
                 }
             }
 
             let Some(from_token) = parser.peek_clone() else {
-                return Statement::error(token, "Expected 'from' after import list".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected 'from' after import list".to_string(),
+                );
             };
 
             if from_token.lexeme != "from" {
-                return Statement::error(token, "Expected keyword 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected keyword 'from'".to_string(),
+                );
             }
 
             parser.advance(); // consume 'from'
 
             let Some(source_token) = parser.peek() else {
-                return Statement::error(token, "Expected string after 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'from'".to_string(),
+                );
             };
 
             if source_token.kind != TokenKind::String {
-                return Statement::error(token, "Expected string after 'from'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'from'".to_string(),
+                );
             }
 
             let source = source_token.lexeme.clone();
@@ -91,7 +193,10 @@ pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> St
                 } else if token.kind == TokenKind::RBrace {
                     break; // Stop at the closing brace
                 } else {
-                    return Statement::error(token, "Unexpected token in export list".to_string());
+                    return crate::core::parser::statement::error_from_token(
+                        token,
+                        "Unexpected token in export list".to_string(),
+                    );
                 }
             }
 
@@ -110,35 +215,47 @@ pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> St
         "load" => {
             parser.advance(); // consume 'load'
 
-            // Exemple : @load "preset.mydeva"
+            // Example: @load "preset.mydeva"
             let Some(path_token) = parser.peek() else {
-                return Statement::error(token, "Expected string after 'load'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'load'".to_string(),
+                );
             };
 
             if path_token.kind != TokenKind::String {
-                return Statement::error(token, "Expected string after 'load'".to_string());
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected string after 'load'".to_string(),
+                );
             }
 
             let path = path_token.lexeme.clone();
 
             parser.advance(); // consume string
-            parser.advance(); // consume 'as'
 
-            let Some(as_token) = parser.peek_clone() else {
-                return Statement::error(
+            if !parser.match_token(TokenKind::As) {
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected 'as' after path in load statement".to_string(),
+                );
+            }
+
+            let Some(alias_token) = parser.peek_clone() else {
+                return crate::core::parser::statement::error_from_token(
                     token,
-                    "Expected 'as' after path in load statement".to_string()
+                    "Expected identifier after 'as' in load statement".to_string(),
                 );
             };
 
-            if as_token.kind != TokenKind::Identifier {
-                return Statement::error(
+            if alias_token.kind != TokenKind::Identifier {
+                return crate::core::parser::statement::error_from_token(
                     token,
-                    "Expected identifier after 'as' in load statement".to_string()
+                    "Expected identifier after 'as' in load statement".to_string(),
                 );
             }
 
-            let alias = as_token.lexeme.clone();
+            let alias = alias_token.lexeme.clone();
 
             parser.advance(); // consume identifier
 
@@ -156,7 +273,7 @@ pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> St
 
         _ => {
             let message = format!("Unknown keyword after '@' : {}", keyword);
-            Statement::error(token, message)
+            crate::core::parser::statement::error_from_token(token, message)
         }
     }
 }

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

@@ -1,41 +1,104 @@
+use devalang_types::Value;
+
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
 
 pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'bank'
+    // consume 'bank'
+    parser.advance();
 
-    let Some(bank_token) = parser.previous_clone() else {
+    let Some(bank_tok) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    let bank_value = if let Some(token) = parser.peek_clone() {
-        match token.kind {
-            TokenKind::Identifier => {
+    // Parse bank name
+    let bank_value: Value = match parser.peek_clone() {
+        Some(tok) => match tok.kind {
+            TokenKind::Identifier | TokenKind::Number => {
+                // base name
                 parser.advance();
-                Value::Identifier(token.lexeme.clone())
+                let mut base = tok.lexeme.clone();
+                // optional .suffix (identifier or number)
+                if let Some(dot) = parser.peek_clone() {
+                    if dot.kind == TokenKind::Dot {
+                        // consume '.' and the following ident/number
+                        parser.advance();
+                        if let Some(suffix) = parser.peek_clone() {
+                            match suffix.kind {
+                                TokenKind::Identifier | TokenKind::Number => {
+                                    parser.advance();
+                                    base.push('.');
+                                    base.push_str(&suffix.lexeme);
+                                    Value::String(base)
+                                }
+                                _ => Value::Identifier(base),
+                            }
+                        } else {
+                            Value::Identifier(base)
+                        }
+                    } else {
+                        match tok.kind {
+                            TokenKind::Identifier => Value::String(base),
+                            TokenKind::Number => Value::Number(base.parse::<f32>().unwrap_or(0.0)),
+                            _ => Value::Unknown,
+                        }
+                    }
+                } else {
+                    match tok.kind {
+                        TokenKind::Identifier => Value::String(base),
+                        TokenKind::Number => Value::Number(base.parse::<f32>().unwrap_or(0.0)),
+                        _ => Value::Unknown,
+                    }
+                }
             }
-            TokenKind::Number => {
+            TokenKind::String => {
                 parser.advance();
-                Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+                Value::String(tok.lexeme.clone())
             }
             _ => Value::Unknown,
-        }
-    } else {
-        return Statement::error(
-            bank_token,
-            "Expected identifier or number after 'bank'".to_string()
-        );
+        },
+        None => Value::Unknown,
     };
 
+    if matches!(bank_value, Value::Unknown | Value::Null) {
+        return crate::core::parser::statement::error_from_token(
+            bank_tok,
+            "Expected a bank name".to_string(),
+        );
+    }
+
+    // Optional alias: as <identifier>
+    let mut alias: Option<String> = None;
+    if parser.peek_is("as") {
+        // consume 'as'
+        parser.advance();
+        let Some(next) = parser.peek_clone() else {
+            return crate::core::parser::statement::error_from_token(
+                bank_tok,
+                "Expected identifier after 'as'".to_string(),
+            );
+        };
+        if next.kind != TokenKind::Identifier {
+            return crate::core::parser::statement::error_from_token(
+                next,
+                "Expected identifier after 'as'".to_string(),
+            );
+        }
+        parser.advance();
+        alias = Some(next.lexeme.clone());
+    }
+
     Statement {
-        kind: StatementKind::Bank,
+        kind: StatementKind::Bank { alias },
         value: bank_value,
-        indent: bank_token.indent,
-        line: bank_token.line,
-        column: bank_token.column,
+        indent: bank_tok.indent,
+        line: bank_tok.line,
+        column: bank_tok.column,
     }
 }

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

@@ -1,10 +1,13 @@
-use std::collections::HashMap;
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{statement::{Statement, StatementKind}, driver::Parser},
-    shared::value::Value,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
+use devalang_types::Value;
+use std::collections::HashMap;
 
 pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume 'if'
@@ -13,7 +16,10 @@ pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore
     };
 
     let Some(condition) = parser.parse_condition_until_colon() else {
-        return Statement::error(if_token, "Expected condition after 'if'".to_string());
+        return crate::core::parser::statement::error_from_token(
+            if_token,
+            "Expected condition after 'if'".to_string(),
+        );
     };
 
     parser.advance_if(TokenKind::Colon);
@@ -40,7 +46,10 @@ pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore
         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());
+                return crate::core::parser::statement::error_from_token(
+                    tok.clone(),
+                    "Expected condition after 'else if'".to_string(),
+                );
             };
             parser.advance_if(TokenKind::Colon);
             Some(cond)

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

@@ -1,100 +1,136 @@
+use devalang_types::{Duration, Value};
+
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::{ duration::Duration, value::Value },
-    store::global::GlobalStore,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
 };
 
-pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume the dot token
-
+pub fn parse_dot_token(
+    parser: &mut Parser,
+    _global_store: &mut crate::core::store::global::GlobalStore,
+) -> Statement {
+    parser.advance(); // consume '.'
+    let logger = devalang_utils::logger::Logger::new();
+    use devalang_utils::logger::LogLevel;
     let Some(dot_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    // .kick
-    let Some(entity_token) = parser.peek_clone() else {
-        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,
-        };
-    };
-
-    parser.advance(); // consume entity
-    let entity = entity_token.lexeme.clone();
+    // Parse a single entity (namespace-friendly, stops at newline)
+    let mut parts = Vec::new();
+    let current_line = dot_token.line;
+
+    while let Some(token) = parser.peek_clone() {
+        // Never cross a newline
+        if token.line != current_line {
+            break;
+        }
+        match token.kind {
+            TokenKind::Identifier | TokenKind::Number => {
+                parts.push(token.lexeme.clone());
+                parser.advance();
+                // The separator must be a '.' on the same line, otherwise stop
+                if let Some(next) = parser.peek_clone() {
+                    if next.line != current_line || next.kind != TokenKind::Dot {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            TokenKind::Dot => {
+                parser.advance();
+            }
+            TokenKind::Newline | TokenKind::EOF | TokenKind::Indent | TokenKind::Dedent => {
+                break; // Stop at newline or dedent
+            }
+            _ => {
+                break;
+            }
+        }
+    }
 
-    // Check if there's a duration
-    let next = parser.peek_clone();
+    // Build entity name properly
+    let entity = if !parts.is_empty() {
+        parts.join(".") // only join within the same line
+    } else {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!("Empty entity after '.' at line {}", dot_token.line),
+        );
+        String::new()
+    };
 
-    let (duration, value) = match next {
-        // If no more tokens, it's just `.kick`
-        None => (Duration::Auto, Value::Null),
+    // Optional duration and effects map
+    let mut duration = Duration::Auto;
+    let mut value = Value::Null;
 
-        Some(token) =>
+    if let Some(token) = parser.peek_clone() {
+        // Duration and effects map are only valid on the same line
+        if token.line == current_line {
             match token.kind {
-                TokenKind::Newline | TokenKind::EOF => { (Duration::Auto, Value::Null) }
-
                 TokenKind::Number => {
-                    let duration_lexeme = token.lexeme.clone();
-                    parser.advance(); // consume duration
-
-                    // Try to parse optional value (ex: .kick 250 params)
-                    match parser.peek_clone() {
-                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                    let numerator = token.lexeme.clone();
+                    parser.advance();
+                    if let Some(peek) = parser.peek_clone() {
+                        if peek.line == current_line {
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance();
+                                if let Some(denominator_token) = parser.peek_clone() {
+                                    if denominator_token.line == current_line
+                                        && denominator_token.kind == TokenKind::Number
+                                    {
+                                        let denominator = denominator_token.lexeme.clone();
+                                        parser.advance();
+                                        duration = Duration::Beat(format!(
+                                            "{}/{}",
+                                            numerator, denominator
+                                        ));
+                                    }
+                                }
+                            } else {
+                                duration = parse_duration(numerator);
+                            }
+                        } else {
+                            duration = parse_duration(numerator);
                         }
-
-                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                    } else {
+                        duration = parse_duration(numerator);
+                    }
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
                         }
-
-                        _ => (parse_duration(duration_lexeme), Value::Null),
                     }
                 }
-
                 TokenKind::Identifier => {
-                    let duration_lexeme = token.lexeme.clone();
-                    parser.advance(); // consume duration
-
-                    // Try to parse optional value (ex: .kick auto params)
-                    match parser.peek_clone() {
-                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                    let id = token.lexeme.clone();
+                    parser.advance();
+                    duration = parse_duration(id);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
                         }
-
-                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
-                        }
-
-                        _ => (parse_duration(duration_lexeme), Value::Null),
                     }
                 }
-
-                _ => (Duration::Auto, Value::Null),
+                TokenKind::LBrace => {
+                    value = parser.parse_map_value().unwrap_or(Value::Null);
+                }
+                _ => {}
             }
-    };
+        }
+    }
 
     Statement {
-        kind: StatementKind::Trigger { entity, duration },
-        value,
+        kind: StatementKind::Trigger {
+            entity,
+            duration,
+            effects: Some(value.clone()),
+        },
+        value: Value::Null,
         indent: dot_token.indent,
         line: dot_token.line,
         column: dot_token.column,
@@ -104,8 +140,8 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 fn parse_duration(s: String) -> Duration {
     if s == "auto" {
         Duration::Auto
-    } else if s.parse::<f32>().is_ok() {
-        Duration::Number(s.parse().unwrap())
+    } else if let Ok(num) = s.parse::<f32>() {
+        Duration::Number(num)
     } else {
         Duration::Identifier(s)
     }