@devaloop/devalang 0.0.1-beta.2 → 0.1.1

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

@@ -1,277 +0,0 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-fn parse_map_literal(parser: &mut Parser) -> Value {
-    // Assumes '{' has already been consumed by caller
-    let mut map = std::collections::HashMap::new();
-    loop {
-        let Some(inner_token) = parser.peek_clone() else {
-            break;
-        };
-
-        match inner_token.kind {
-            TokenKind::RBrace => {
-                parser.advance(); // consume '}'
-                break;
-            }
-            TokenKind::Newline | TokenKind::Comma => {
-                parser.advance();
-                continue;
-            }
-            _ => {}
-        }
-
-        // Key
-        parser.advance();
-        let key = inner_token.lexeme.clone();
-
-        // Expect ':'
-        if let Some(colon_token) = parser.peek_clone() {
-            if colon_token.kind == TokenKind::Colon {
-                parser.advance(); // consume ':'
-
-                // Value
-                if let Some(value_token) = parser.peek_clone() {
-                    match value_token.kind {
-                        TokenKind::LBrace => {
-                            parser.advance(); // consume '{'
-                            let nested = parse_map_literal(parser);
-                            map.insert(key, nested);
-                        }
-                        TokenKind::Identifier => {
-                            parser.advance();
-                            let v = if value_token.lexeme == "true" {
-                                Value::Boolean(true)
-                            } else if value_token.lexeme == "false" {
-                                Value::Boolean(false)
-                            } else {
-                                Value::Identifier(value_token.lexeme.clone())
-                            };
-                            map.insert(key, v);
-                        }
-                        TokenKind::String => {
-                            parser.advance();
-                            map.insert(key, Value::String(value_token.lexeme.clone()));
-                        }
-                        TokenKind::Number => {
-                            parser.advance();
-                            // Beat fraction support: NUMBER '/' NUMBER
-                            if let Some(TokenKind::Slash) = parser.peek_kind() {
-                                parser.advance(); // '/'
-                                if let Some(den) = parser.peek_clone() {
-                                    if den.kind == TokenKind::Number
-                                        || den.kind == TokenKind::Identifier
-                                    {
-                                        parser.advance();
-                                        let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
-                                        map.insert(
-                                            key,
-                                            Value::Duration(devalang_types::Duration::Beat(beat)),
-                                        );
-                                        continue;
-                                    }
-                                }
-                            }
-                            // Decimal support NUMBER '.' NUMBER
-                            if let Some(next) = parser.peek_clone() {
-                                if next.kind == TokenKind::Dot {
-                                    parser.advance(); // '.'
-                                    if let Some(after) = parser.peek_clone() {
-                                        if after.kind == TokenKind::Number {
-                                            parser.advance();
-                                            let combined =
-                                                format!("{}.{}", value_token.lexeme, after.lexeme);
-                                            map.insert(
-                                                key,
-                                                Value::Number(
-                                                    combined.parse::<f32>().unwrap_or(0.0),
-                                                ),
-                                            );
-                                            continue;
-                                        }
-                                    }
-                                }
-                            }
-                            map.insert(
-                                key,
-                                Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0)),
-                            );
-                        }
-                        TokenKind::Boolean => {
-                            parser.advance();
-                            map.insert(
-                                key,
-                                Value::Boolean(value_token.lexeme.parse::<bool>().unwrap_or(false)),
-                            );
-                        }
-                        _ => {
-                            // Unknown value type, consume and store Unknown
-                            parser.advance();
-                            map.insert(key, Value::Unknown);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    Value::Map(map)
-}
-
-pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    let Some(target_token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    if target_token.kind != TokenKind::Identifier {
-        parser.advance(); // consume target token
-        return Statement::unknown_with_pos(
-            target_token.indent,
-            target_token.line,
-            target_token.column,
-        );
-    }
-
-    let Some(arrow_token) = parser.peek_nth(1).cloned() else {
-        parser.advance(); // consume arrow token
-        return Statement::unknown_with_pos(
-            target_token.indent,
-            target_token.line,
-            target_token.column,
-        );
-    };
-
-    if arrow_token.kind != TokenKind::Arrow {
-        parser.advance(); // consume method token
-        return Statement::unknown_with_pos(
-            target_token.indent,
-            target_token.line,
-            target_token.column,
-        );
-    }
-
-    // We have a valid arrow call, so we consume the arrow token
-    let Some(method_token) = parser.peek_nth(2).cloned() else {
-        parser.advance();
-        return Statement::unknown_with_pos(
-            target_token.indent,
-            target_token.line,
-            target_token.column,
-        );
-    };
-
-    if method_token.kind != TokenKind::Identifier {
-        parser.advance();
-        return Statement::unknown_with_pos(
-            method_token.indent,
-            method_token.line,
-            method_token.column,
-        );
-    }
-
-    // Consume the tokens for target, arrow, and method
-    parser.advance(); // target
-    parser.advance(); // ->
-    parser.advance(); // method
-
-    let mut args = Vec::new();
-    let mut paren_depth = 0;
-    let mut map_depth = 0;
-
-    while let Some(token) = parser.peek_clone() {
-        if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
-            break;
-        }
-        if token.kind == TokenKind::LParen {
-            paren_depth += 1;
-        }
-        if token.kind == TokenKind::RParen {
-            if paren_depth > 0 {
-                paren_depth -= 1;
-                parser.advance();
-                if paren_depth == 0 {
-                    break;
-                }
-                continue;
-            } else {
-                break;
-            }
-        }
-        if token.kind == TokenKind::LBrace {
-            map_depth += 1;
-        }
-        if token.kind == TokenKind::RBrace {
-            if map_depth > 0 {
-                map_depth -= 1;
-                parser.advance();
-                if map_depth == 0 {
-                    continue;
-                }
-                continue;
-            } else {
-                break;
-            }
-        }
-
-        parser.advance();
-
-        let value = match token.kind {
-            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
-            TokenKind::String => Value::String(token.lexeme.clone()),
-            TokenKind::Number => {
-                // support fraction literal as bare arg: 1/4
-                // note: token has already been advanced earlier in the loop
-                if let Some(TokenKind::Slash) = parser.peek_kind() {
-                    parser.advance(); // consume '/'
-                    if let Some(den) = parser.peek_clone() {
-                        if den.kind == TokenKind::Number || den.kind == TokenKind::Identifier {
-                            parser.advance();
-                            let beat = format!("{}/{}", token.lexeme, den.lexeme);
-                            Value::Duration(devalang_types::Duration::Beat(beat))
-                        } else {
-                            Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
-                        }
-                    } else {
-                        Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
-                    }
-                } else {
-                    Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
-                }
-            }
-            TokenKind::LBrace => {
-                // Handle map literal (supports nested maps)
-
-                // We consumed the matching '}', so outer map_depth should be decremented
-                // if the caller tracks it.
-                parse_map_literal(parser)
-            }
-            _ => Value::Unknown,
-        };
-
-        args.push(value);
-
-        // Stop if we reach the end of the statement
-        if paren_depth == 0 && (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace)
-        {
-            break;
-        }
-    }
-
-    Statement {
-        kind: StatementKind::ArrowCall {
-            target: target_token.lexeme.clone(),
-            method: method_token.lexeme.clone(),
-            args,
-        },
-        value: Value::Null,
-        indent: target_token.indent,
-        line: target_token.line,
-        column: target_token.column,
-    }
-}

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

@@ -1,279 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume '@'
-
-    let Some(token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    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 crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected '{{' after 'import'".to_string(),
-                );
-            }
-
-            let mut names = Vec::new();
-            while let Some(token) = parser.peek() {
-                match &token.kind {
-                    TokenKind::Identifier => {
-                        names.push(token.lexeme.clone());
-                        parser.advance();
-                    }
-                    TokenKind::Comma => {
-                        parser.advance();
-                    }
-                    TokenKind::RBrace => {
-                        parser.advance();
-                        break;
-                    }
-                    _ => {
-                        let message =
-                            format!("Unexpected token in import list: {:?}", token.kind.clone());
-                        return crate::core::parser::statement::error_from_token(
-                            token.clone(),
-                            message,
-                        );
-                    }
-                }
-            }
-
-            let Some(from_token) = parser.peek_clone() else {
-                return crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected 'from' after import list".to_string(),
-                );
-            };
-
-            if from_token.lexeme != "from" {
-                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 crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected string after 'from'".to_string(),
-                );
-            };
-
-            if source_token.kind != TokenKind::String {
-                return crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected string after 'from'".to_string(),
-                );
-            }
-
-            let source = source_token.lexeme.clone();
-            parser.advance(); // consume string
-
-            Statement {
-                kind: StatementKind::Import { names, source },
-                value: Value::Null,
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            }
-        }
-
-        "export" => {
-            parser.advance(); // consume 'export'
-
-            parser.advance(); // consume '{'
-
-            let names_tokens = parser.collect_until(|t| TokenKind::RBrace == t.kind);
-            let mut names: Vec<String> = Vec::new();
-
-            for token in names_tokens {
-                if token.kind == TokenKind::Identifier {
-                    names.push(token.lexeme.clone());
-                } else if token.kind == TokenKind::Comma {
-                    continue; // Ignore commas
-                } else if token.kind == TokenKind::RBrace {
-                    break; // Stop at the closing brace
-                } else {
-                    return crate::core::parser::statement::error_from_token(
-                        token,
-                        "Unexpected token in export list".to_string(),
-                    );
-                }
-            }
-
-            Statement {
-                kind: StatementKind::Export {
-                    names: names.clone(),
-                    source: parser.current_module.clone(),
-                },
-                value: Value::Null,
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            }
-        }
-
-        "load" => {
-            parser.advance(); // consume 'load'
-
-            // Example: @load "preset.mydeva"
-            let Some(path_token) = parser.peek() else {
-                return crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected string after 'load'".to_string(),
-                );
-            };
-
-            if path_token.kind != TokenKind::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
-
-            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 identifier after 'as' in load statement".to_string(),
-                );
-            };
-
-            if alias_token.kind != TokenKind::Identifier {
-                return crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected identifier after 'as' in load statement".to_string(),
-                );
-            }
-
-            let alias = alias_token.lexeme.clone();
-
-            parser.advance(); // consume identifier
-
-            Statement {
-                kind: StatementKind::Load {
-                    source: path,
-                    alias,
-                },
-                value: Value::Null,
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            }
-        }
-
-        _ => {
-            let message = format!("Unknown keyword after '@' : {}", keyword);
-            crate::core::parser::statement::error_from_token(token, message)
-        }
-    }
-}

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

@@ -1,104 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    // consume 'bank'
-    parser.advance();
-
-    let Some(bank_tok) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Parse bank name
-    let bank_value: Value = match parser.peek_clone() {
-        Some(tok) => match tok.kind {
-            TokenKind::Identifier | TokenKind::Number => {
-                // base name
-                parser.advance();
-                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::String => {
-                parser.advance();
-                Value::String(tok.lexeme.clone())
-            }
-            _ => Value::Unknown,
-        },
-        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 { alias },
-        value: bank_value,
-        indent: bank_tok.indent,
-        line: bank_tok.line,
-        column: bank_tok.column,
-    }
-}