@devaloop/devalang 0.0.1-beta.3 → 0.1.2

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

@@ -1,82 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_arrow_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,
-) {
-    // If next char is '>', this is an arrow '->'.
-    if let Some(&c) = chars.peek() {
-        if c == '>' {
-            let mut arrow_call = ch.to_string();
-            chars.next();
-            arrow_call.push(c);
-            *column += 1;
-
-            tokens.push(Token {
-                kind: TokenKind::Arrow,
-                lexeme: arrow_call,
-                line: *line,
-                column: *column,
-                indent: *current_indent,
-            });
-            return;
-        }
-    }
-
-    // Otherwise, treat '-' as the start of a negative number if followed by digits.
-    let mut lexeme = String::from("-");
-    if let Some(&next) = chars.peek() {
-        if next.is_ascii_digit() {
-            // consume digits
-            while let Some(&d) = chars.peek() {
-                if d.is_ascii_digit() {
-                    chars.next();
-                    lexeme.push(d);
-                    *column += 1;
-                } else {
-                    break;
-                }
-            }
-            // optional decimal part
-            if let Some(&dot) = chars.peek() {
-                if dot == '.' {
-                    chars.next();
-                    lexeme.push(dot);
-                    *column += 1;
-                    while let Some(&d) = chars.peek() {
-                        if d.is_ascii_digit() {
-                            chars.next();
-                            lexeme.push(d);
-                            *column += 1;
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            }
-
-            tokens.push(Token {
-                kind: TokenKind::Number,
-                lexeme,
-                line: *line,
-                column: *column,
-                indent: *current_indent,
-            });
-            return;
-        }
-    }
-
-    // Fallback: lone '-' not part of '->' or a number; emit Unknown to avoid mis-parsing as Arrow
-    tokens.push(Token {
-        kind: TokenKind::Unknown,
-        lexeme: "-".to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

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

@@ -1,21 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_at_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::At,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

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

@@ -1,41 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_rbrace_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::RBrace,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
-
-pub fn handle_lbrace_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::LBrace,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

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

@@ -1,21 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_colon_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::Colon,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

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

@@ -1,30 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_comment_lexer(
-    _char: 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 comment = String::new();
-
-    while let Some(&c) = chars.peek() {
-        if c == '\n' {
-            break;
-        }
-        comment.push(c);
-        chars.next();
-        *column += 1;
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::Comment,
-        lexeme: comment.trim().to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

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

@@ -1,21 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_dot_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::Dot,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

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

@@ -1,337 +0,0 @@
-use crate::core::lexer::{
-    handler::{
-        arrow::handle_arrow_lexer,
-        at::handle_at_lexer,
-        brace::{handle_lbrace_lexer, handle_rbrace_lexer},
-        colon::handle_colon_lexer,
-        comment::handle_comment_lexer,
-        dot::handle_dot_lexer,
-        identifier::handle_identifier_lexer,
-        indent::handle_indent_lexer,
-        newline::handle_newline_lexer,
-        number::handle_number_lexer,
-        operator::handle_operator_lexer,
-        parenthesis::{handle_lparen_lexer, handle_rparen_lexer},
-        slash::handle_slash_lexer,
-        string::handle_string_lexer,
-    },
-    token::{Token, TokenKind},
-};
-
-fn advance_char<I: Iterator<Item = char>>(
-    chars: &mut std::iter::Peekable<I>,
-    _line: &mut usize,
-    column: &mut usize,
-) -> Option<char> {
-    for c in chars.by_ref() {
-        if c == '\r' {
-            continue;
-        } else if c == '\n' {
-            // newline: don't increment column
-        } else {
-            *column += 1;
-        }
-        return Some(c);
-    }
-    None
-}
-
-pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
-    let mut tokens = Vec::new();
-
-    let mut line = 1;
-    let mut column = 1;
-
-    let mut indent_stack: Vec<usize> = vec![0];
-    let mut current_indent = 0;
-    let mut at_line_start = true;
-
-    let mut chars = content.chars().peekable();
-
-    while chars.peek().is_some() {
-        if at_line_start {
-            handle_indent_lexer(
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column,
-            );
-
-            at_line_start = false;
-        }
-
-        let Some(ch) = advance_char(&mut chars, &mut line, &mut column) else {
-            break;
-        };
-
-        match ch {
-            '\n' => {
-                handle_newline_lexer(
-                    ch,
-                    &mut chars,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                    &mut at_line_start,
-                    &mut current_indent,
-                );
-            }
-            ' ' | '\t' => {
-                // Already handled by indent_lexer
-            }
-            '#' => {
-                handle_comment_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            ':' => {
-                handle_colon_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '=' | '!' | '<' | '>' | '+' | '*' => {
-                handle_operator_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '/' => {
-                handle_slash_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '-' => {
-                handle_arrow_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-                // If not parsed as arrow or number, fallback as Minus token
-                if let Some(last) = tokens.last() {
-                    if last.kind == TokenKind::Unknown && last.lexeme == "-" {
-                        // replace last with Minus
-                        let _ = tokens.pop();
-                        tokens.push(Token {
-                            kind: TokenKind::Minus,
-                            lexeme: "-".to_string(),
-                            line,
-                            column,
-                            indent: current_indent,
-                        });
-                    }
-                }
-            }
-            '{' => {
-                handle_lbrace_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '}' => {
-                handle_rbrace_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '[' => {
-                tokens.push(Token {
-                    kind: TokenKind::LBracket,
-                    lexeme: "[".to_string(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-            }
-            ']' => {
-                tokens.push(Token {
-                    kind: TokenKind::RBracket,
-                    lexeme: "]".to_string(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-            }
-            ',' => {
-                tokens.push(Token {
-                    kind: TokenKind::Comma,
-                    lexeme: ",".to_string(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-            }
-            '(' => {
-                handle_lparen_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            ')' => {
-                handle_rparen_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '.' => {
-                handle_dot_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '@' => {
-                handle_at_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '$' => {
-                // Treat `$` as start of a special identifier like `$env` or `$math`
-                let mut ident = String::from("$");
-                while let Some(&c) = chars.peek() {
-                    if c.is_ascii_alphanumeric() || c == '_' {
-                        ident.push(c);
-                        chars.next();
-                        column += 1;
-                    } else {
-                        break;
-                    }
-                }
-                tokens.push(Token {
-                    kind: TokenKind::Identifier,
-                    lexeme: ident,
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-            }
-            '0'..='9' => {
-                handle_number_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            'a'..='z' | 'A'..='Z' | '_' => {
-                handle_identifier_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            '"' | '\'' => {
-                handle_string_lexer(
-                    ch,
-                    &mut chars,
-                    &mut current_indent,
-                    &mut indent_stack,
-                    &mut tokens,
-                    &mut line,
-                    &mut column,
-                );
-            }
-            _ => {
-                // Ignore unknown char
-            }
-        }
-    }
-
-    while indent_stack.len() > 1 {
-        indent_stack.pop();
-        current_indent = *indent_stack.last().unwrap();
-        tokens.push(Token {
-            kind: TokenKind::Dedent,
-            lexeme: String::new(),
-            line,
-            column,
-            indent: current_indent,
-        });
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::EOF,
-        lexeme: String::new(),
-        line: line + 1,
-        column: 0,
-        indent: 0,
-    });
-
-    // NOTE: Debug only
-    // for token in &tokens {
-    //     println!(
-    //         "{:?} @ line {}, col {}, indent {}",
-    //         token.kind,
-    //         token.line,
-    //         token.column,
-    //         token.indent
-    //     );
-    // }
-
-    Ok(tokens)
-}

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

@@ -1,47 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_identifier_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 ident = ch.to_string();
-
-    while let Some(&c) = chars.peek() {
-        if c.is_ascii_alphanumeric() || c == '_' {
-            ident.push(c);
-            chars.next();
-            *column += 1;
-        } else {
-            break;
-        }
-    }
-
-    let kind = match ident.as_str() {
-        "if" => TokenKind::If,
-        "else" => TokenKind::Else,
-        "bank" => TokenKind::Bank,
-        "pattern" => TokenKind::Pattern,
-        "bpm" => TokenKind::Tempo,
-        "loop" => TokenKind::Loop,
-        "for" => TokenKind::Loop,
-        "synth" => TokenKind::Synth,
-        "fn" => TokenKind::Function,
-        "as" => TokenKind::As,
-        "on" => TokenKind::On,
-        "emit" => TokenKind::Emit,
-        _ => TokenKind::Identifier,
-    };
-
-    tokens.push(Token {
-        kind: kind.clone(),
-        lexeme: ident,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}

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

@@ -1,66 +0,0 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_indent_lexer(
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    *current_indent = 0;
-    let mut col = *column;
-
-    while let Some(&c) = chars.peek() {
-        if c == ' ' {
-            *current_indent += 1;
-            chars.next();
-            col += 1;
-            tokens.push(Token {
-                kind: TokenKind::Whitespace,
-                lexeme: " ".to_string(),
-                line: *line,
-                column: col,
-                indent: *current_indent,
-            });
-        } else if c == '\t' {
-            *current_indent += 4;
-            chars.next();
-            col += 4;
-            tokens.push(Token {
-                kind: TokenKind::Whitespace,
-                lexeme: "\t".to_string(),
-                line: *line,
-                column: col,
-                indent: *current_indent,
-            });
-        } else {
-            break;
-        }
-    }
-
-    *column = col;
-
-    let last_indent = *indent_stack.last().unwrap();
-    if *current_indent > last_indent {
-        indent_stack.push(*current_indent);
-        tokens.push(Token {
-            kind: TokenKind::Indent,
-            lexeme: String::from("<INDENT>"),
-            line: *line,
-            column: *column,
-            indent: *current_indent,
-        });
-    } else {
-        while *current_indent < *indent_stack.last().unwrap() {
-            indent_stack.pop();
-            tokens.push(Token {
-                kind: TokenKind::Dedent,
-                lexeme: String::from("<DEDENT>"),
-                line: *line,
-                column: *column,
-                indent: *current_indent,
-            });
-        }
-    }
-}

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

@@ -1,15 +0,0 @@
-pub mod arrow;
-pub mod at;
-pub mod brace;
-pub mod colon;
-pub mod comment;
-pub mod dot;
-pub mod driver;
-pub mod identifier;
-pub mod indent;
-pub mod newline;
-pub mod number;
-pub mod operator;
-pub mod parenthesis;
-pub mod slash;
-pub mod string;