@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/core/lexer/handler/newline.rs

@@ -1,23 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_newline_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-    at_line_start: &mut bool,
-    current_indent: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::Newline,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: 0,
-        indent: *current_indent,
-    });
-
-    *line += 1;
-    *column = 1;
-    *at_line_start = true;
-}

package/rust/core/lexer/handler/number.rs

@@ -1,31 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_number_lexer(
-    ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    let mut number = ch.to_string();
-
-    while let Some(&c) = chars.peek() {
-        if c.is_ascii_digit() {
-            number.push(c);
-            chars.next();
-            *column += 1;
-        } else {
-            break;
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::Number,
-        lexeme: number,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

package/rust/core/lexer/handler/operator.rs

@@ -1,46 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_operator_lexer(
-    ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    let next = chars.peek().copied();
-
-    let (kind, len) = match (ch, next) {
-        ('=', Some('=')) => (TokenKind::DoubleEquals, 2),
-        ('!', Some('=')) => (TokenKind::NotEquals, 2),
-        ('>', Some('=')) => (TokenKind::GreaterEqual, 2),
-        ('<', Some('=')) => (TokenKind::LessEqual, 2),
-        ('+', _) => (TokenKind::Plus, 1),
-        ('*', _) => (TokenKind::Asterisk, 1),
-        ('=', _) => (TokenKind::Equals, 1),
-        ('>', _) => (TokenKind::Greater, 1),
-        ('<', _) => (TokenKind::Less, 1),
-        _ => {
-            return;
-        }
-    };
-
-    if len == 2 {
-        chars.next(); // consume second char
-    }
-
-    tokens.push(Token {
-        kind,
-        lexeme: if len == 2 {
-            format!("{}{}", ch, next.unwrap())
-        } else {
-            ch.to_string()
-        },
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += len;
-}

package/rust/core/lexer/handler/parenthesis.rs

@@ -1,41 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_rparen_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::RParen,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
-
-pub fn handle_lparen_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::LParen,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

package/rust/core/lexer/handler/slash.rs

@@ -1,21 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_slash_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    let slash = ch.to_string();
-
-    tokens.push(Token {
-        kind: TokenKind::Slash,
-        lexeme: slash,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

package/rust/core/lexer/handler/string.rs

@@ -1,63 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_string_lexer(
-    ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    let quote_char = ch;
-
-    let start_column = *column;
-    let start_line = *line;
-
-    *column += 1;
-
-    let mut string_content = String::new();
-
-    while let Some(&next_ch) = chars.peek() {
-        if next_ch == quote_char {
-            chars.next();
-            *column += 1;
-            break;
-        } else if next_ch == '\\' {
-            chars.next();
-            *column += 1;
-
-            if let Some(escaped) = chars.next() {
-                match escaped {
-                    'n' => string_content.push('\n'),
-                    't' => string_content.push('\t'),
-                    '\\' => string_content.push('\\'),
-                    '"' => string_content.push('"'),
-                    '\'' => string_content.push('\''),
-                    other => {
-                        string_content.push('\\');
-                        string_content.push(other);
-                    }
-                }
-                *column += 1;
-            }
-        } else {
-            chars.next();
-            if next_ch == '\n' {
-                *line += 1;
-                *column = 1;
-            } else {
-                *column += 1;
-            }
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        indent: *current_indent,
-        line: start_line,
-        column: start_column,
-    });
-}

package/rust/core/lexer/mod.rs

@@ -1,3 +0,0 @@
-pub mod driver;
-pub mod handler;
-pub mod token;

package/rust/core/lexer/token.rs

@@ -1,91 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Token {
-    pub kind: TokenKind,
-    pub lexeme: String,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Token {
-    pub fn is_error(&self) -> bool {
-        matches!(&self.kind, TokenKind::Error(_))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum TokenKind {
-    // ───── Keywords ─────
-    At,
-    Tempo,
-    Bank,
-    Pattern,
-    Loop,
-    Function,
-    As,
-    On,
-    Emit,
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Literals ─────
-    Identifier,
-    Number,
-    String,
-    Boolean,
-    Arrow,
-
-    // ───── Structures ─────
-    Map,
-    Array,
-
-    // ───── Symbols ─────
-    Colon,
-    Comma,
-    Equals,
-    Dot,
-    Slash,
-    Plus,
-    Asterisk,
-    Minus,
-
-    // ───── Operators ─────
-    DoubleEquals,
-    NotEquals,
-    GreaterEqual,
-    LessEqual,
-    Greater,
-    Less,
-
-    // ───── Brackets ─────
-    LBrace,   // {
-    RBrace,   // }
-    LBracket, // [
-    RBracket, // ]
-    LParen,   // (
-    RParen,   // )
-
-    // ───── Quotes ─────
-    Quote,   // '
-    DbQuote, // "
-
-    // ───── Formatting ─────
-    Newline,
-    Indent,
-    Dedent,
-    Comment,
-
-    // ───── Conditions ─────
-    If,
-    Else,
-    ElseIf,
-
-    // ───── Special / Internal ─────
-    Whitespace,
-    Unknown,
-    Error(String),
-    EOF,
-}

package/rust/core/mod.rs

@@ -1,9 +0,0 @@
-pub mod audio;
-pub mod builder;
-pub mod debugger;
-pub mod error;
-pub mod lexer;
-pub mod parser;
-pub mod plugin;
-pub mod preprocessor;
-pub mod store;

package/rust/core/parser/driver/block.rs

@@ -1,111 +0,0 @@
-use crate::core::lexer::token::Token;
-use crate::core::lexer::token::TokenKind;
-use crate::core::store::global::GlobalStore;
-
-pub fn collect_block_tokens(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-) -> Vec<Token> {
-    let mut tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            tokens.push(t.clone());
-        } else {
-            // Unexpected EOF while collecting block tokens: stop collecting
-            break;
-        }
-    }
-
-    tokens
-}
-
-pub fn collect_until<F>(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    condition: F,
-) -> Vec<Token>
-where
-    F: Fn(&Token) -> bool,
-{
-    let mut collected = Vec::new();
-    while let Some(token) = parser.peek() {
-        if condition(token) {
-            break;
-        }
-        if token.kind == TokenKind::EOF {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            collected.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    collected
-}
-
-pub fn parse_block(
-    parser: &crate::core::parser::driver::parser::Parser,
-    tokens: Vec<Token>,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut inner_parser = crate::core::parser::driver::parser::Parser {
-        resolve_modules: parser.resolve_modules,
-        tokens,
-        token_index: 0,
-        current_module: parser.current_module.clone(),
-        previous: None,
-    };
-
-    inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-}
-
-pub fn parse_block_until_next_else(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut block_tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        // Stop if we encounter an 'else' at same indent level
-        if tok.lexeme == "else" && tok.indent == base_indent {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            block_tokens.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    parse_block(parser, block_tokens, global_store)
-}
-
-pub fn parse_block_until_else_or_dedent(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        if tok.lexeme == "else" && tok.indent == base_indent {
-            break;
-        }
-        if tok.indent < base_indent && tok.kind != TokenKind::Newline {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            tokens.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    parse_block(parser, tokens, global_store)
-}

package/rust/core/parser/driver/cursor.rs

@@ -1,82 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn advance_impl(parser: &mut crate::core::parser::driver::parser::Parser) -> Option<&Token> {
-    if is_eof_impl(parser) {
-        return None;
-    }
-
-    parser.previous = parser.tokens.get(parser.token_index).cloned();
-    parser.token_index += 1;
-
-    parser.tokens.get(parser.token_index - 1)
-}
-
-pub fn peek_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<&Token> {
-    parser.tokens.get(parser.token_index)
-}
-
-pub fn peek_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
-    parser.tokens.get(parser.token_index).cloned()
-}
-
-pub fn peek_nth_impl(
-    parser: &crate::core::parser::driver::parser::Parser,
-    n: usize,
-) -> Option<&Token> {
-    if parser.token_index + n < parser.tokens.len() {
-        parser.tokens.get(parser.token_index + n)
-    } else {
-        None
-    }
-}
-
-pub fn peek_nth_kind_impl(
-    parser: &crate::core::parser::driver::parser::Parser,
-    n: usize,
-) -> Option<TokenKind> {
-    peek_nth_impl(parser, n).map(|t| t.kind.clone())
-}
-
-pub fn is_eof_impl(parser: &crate::core::parser::driver::parser::Parser) -> bool {
-    parser.token_index >= parser.tokens.len()
-}
-
-pub fn previous_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
-    parser.previous.clone()
-}
-
-pub fn match_token_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> bool {
-    if let Some(tok) = peek_impl(parser) {
-        if tok.kind == kind {
-            advance_impl(parser);
-            return true;
-        }
-    }
-    false
-}
-
-pub fn advance_if_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> bool {
-    match_token_impl(parser, kind)
-}
-
-pub fn peek_is_impl(parser: &crate::core::parser::driver::parser::Parser, expected: &str) -> bool {
-    peek_impl(parser).is_some_and(|t| t.lexeme == expected)
-}
-
-pub fn expect_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> Result<&Token, String> {
-    let tok = advance_impl(parser).ok_or("Unexpected end of input")?;
-    if tok.kind == kind {
-        Ok(tok)
-    } else {
-        Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-    }
-}

package/rust/core/parser/driver/driver_impl.rs

@@ -1,159 +0,0 @@
-use crate::core::lexer::token::TokenKind;
-use crate::core::parser::statement::StatementKind;
-use crate::core::store::global::GlobalStore;
-use devalang_types::Value;
-
-pub fn parse_tokens_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    tokens: Vec<crate::core::lexer::token::Token>,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    // Filter out Whitespace tokens but keep Newline tokens because some constructs (e.g., print ...)
-    // rely on end-of-line semantics.
-    parser.tokens = tokens
-        .into_iter()
-        .filter(|t| t.kind != TokenKind::Whitespace)
-        .collect();
-    parser.token_index = 0;
-
-    let mut statements = Vec::new();
-
-    while !crate::core::parser::driver::cursor::is_eof_impl(parser) {
-        let token = match crate::core::parser::driver::cursor::peek_impl(parser) {
-            Some(t) => t.clone(),
-            None => {
-                break;
-            }
-        };
-
-        if token.kind == TokenKind::Newline {
-            crate::core::parser::driver::cursor::advance_impl(parser);
-            continue;
-        }
-
-        // If the line starts with an Arrow ("->"), treat it as a continuation of the
-        // previous arrow call: reuse the target from the last parsed ArrowCall statement
-        // so chained effects on subsequent lines are supported.
-        let statement = if token.kind == TokenKind::Arrow {
-            // find previous ArrowCall target if any
-            let prev_target = statements.last().and_then(
-                |s: &crate::core::parser::statement::Statement| match &s.kind {
-                    StatementKind::ArrowCall { target, .. } => Some(target.clone()),
-                    _ => None,
-                },
-            );
-
-            crate::core::parser::handler::arrow_call::parse_arrow_continuation(
-                parser,
-                global_store,
-                prev_target,
-            )
-        } else {
-            match &token.kind {
-            TokenKind::At => crate::core::parser::handler::at::parse_at_token(parser, global_store),
-            TokenKind::Identifier => {
-                if
-                    let Some(next) = crate::core::parser::driver::cursor
-                        ::peek_nth_impl(parser, 1)
-                        .cloned()
-                {
-                    if next.kind == TokenKind::Arrow {
-                        crate::core::parser::handler::arrow_call::parse_arrow_call(
-                            parser,
-                            global_store
-                        )
-                    } else {
-                        crate::core::parser::handler::identifier::parse_identifier_token(
-                            parser,
-                            global_store
-                        )
-                    }
-                } else {
-                    crate::core::parser::handler::identifier::parse_identifier_token(
-                        parser,
-                        global_store
-                    )
-                }
-            }
-            TokenKind::Dot =>
-                crate::core::parser::handler::dot::parse_dot_token(parser, global_store),
-            TokenKind::Tempo =>
-                crate::core::parser::handler::tempo::parse_tempo_token(parser, global_store),
-            TokenKind::Bank =>
-                crate::core::parser::handler::bank::parse_bank_token(parser, global_store),
-            TokenKind::Pattern =>
-                crate::core::parser::handler::pattern::parse_pattern_token(parser, global_store),
-            TokenKind::Loop =>
-                crate::core::parser::handler::loop_::parse_loop_token(parser, global_store),
-            TokenKind::If =>
-                crate::core::parser::handler::condition::parse_condition_token(
-                    parser,
-                    global_store
-                ),
-            TokenKind::Function =>
-                crate::core::parser::handler::identifier::function::parse_function_token(
-                    parser,
-                    global_store
-                ),
-            TokenKind::On =>
-                crate::core::parser::handler::identifier::on::parse_on_token(parser, global_store),
-            TokenKind::Emit =>
-                crate::core::parser::handler::identifier::emit::parse_emit_token(
-                    parser,
-                    token.clone(),
-                    global_store
-                ),
-
-            | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
-            | TokenKind::Comment
-            | TokenKind::Equals
-            | TokenKind::Colon
-            | TokenKind::Number
-            | TokenKind::String
-            | TokenKind::LBrace
-            | TokenKind::RBrace
-            | TokenKind::Comma
-            | TokenKind::Dedent
-            | TokenKind::Indent => {
-                crate::core::parser::driver::cursor::advance_impl(parser);
-                continue;
-            }
-
-            TokenKind::EOF => {
-                break;
-            }
-
-            _ => {
-                crate::core::parser::driver::cursor::advance_impl(parser);
-                crate::core::parser::statement::Statement::unknown_with_pos(
-                    token.indent,
-                    token.line,
-                    token.column
-                )
-            }
-            }
-        };
-
-        statements.push(statement);
-    }
-
-    statements
-}
-
-pub fn parse_condition_until_colon_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-) -> Option<Value> {
-    let tokens =
-        crate::core::parser::driver::block::collect_until(parser, |t| t.kind == TokenKind::Colon);
-    if tokens.is_empty() {
-        return None;
-    }
-
-    let condition = tokens
-        .iter()
-        .map(|t| t.lexeme.clone())
-        .collect::<Vec<_>>()
-        .join(" ");
-
-    Some(Value::String(condition))
-}

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

@@ -1,6 +0,0 @@
-pub mod block;
-pub mod cursor;
-pub mod driver_impl;
-pub mod parse_array;
-pub mod parse_map;
-pub mod parser;