@devaloop/devalang 0.0.1-alpha.7 → 0.0.1-alpha.9

package/rust/core/parser/driver.rs

@@ -0,0 +1,331 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{
+        handler::{
+            arrow_call::parse_arrow_call,
+            at::parse_at_token,
+            bank::parse_bank_token,
+            condition::parse_condition_token,
+            dot::parse_dot_token,
+            identifier::parse_identifier_token,
+            loop_::parse_loop_token,
+            tempo::parse_tempo_token,
+        },
+        statement::Statement,
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Parser {
+    pub resolve_modules: bool,
+    pub tokens: Vec<Token>,
+    pub token_index: usize,
+    pub current_module: String,
+    pub previous: Option<Token>,
+}
+
+impl Parser {
+    pub fn new() -> Self {
+        Parser {
+            resolve_modules: false,
+            tokens: Vec::new(),
+            token_index: 0,
+            current_module: String::new(),
+            previous: None,
+        }
+    }
+
+    pub fn set_current_module(&mut self, module_path: String) {
+        self.current_module = module_path;
+    }
+
+    pub fn advance(&mut self) -> Option<&Token> {
+        if self.is_eof() {
+            return None;
+        }
+
+        self.previous = self.tokens.get(self.token_index).cloned();
+        self.token_index += 1;
+
+        self.tokens.get(self.token_index - 1)
+    }
+
+    pub fn peek_is(&self, expected: &str) -> bool {
+        self.peek().map_or(false, |t| t.lexeme == expected)
+    }
+
+    pub fn peek_nth(&self, n: usize) -> Option<&Token> {
+        if self.token_index + n < self.tokens.len() {
+            self.tokens.get(self.token_index + n)
+        } else {
+            None
+        }
+    }
+
+    pub fn advance_if(&mut self, kind: TokenKind) -> bool {
+        if self.match_token(kind) { true } else { false }
+    }
+
+    pub fn match_token(&mut self, kind: TokenKind) -> bool {
+        if let Some(tok) = self.peek() {
+            if tok.kind == kind {
+                self.advance();
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn previous_clone(&self) -> Option<Token> {
+        self.previous.clone()
+    }
+
+    pub fn parse_block(
+        &self,
+        tokens: Vec<Token>,
+        global_store: &mut GlobalStore
+    ) -> Vec<Statement> {
+        let mut inner_parser = Parser {
+            resolve_modules: self.resolve_modules,
+            tokens,
+            token_index: 0,
+            current_module: self.current_module.clone(),
+            previous: None,
+        };
+
+        inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
+    }
+
+    pub fn parse_tokens(
+        &mut self,
+        tokens: Vec<Token>,
+        global_store: &mut GlobalStore
+    ) -> Vec<Statement> {
+        self.tokens = tokens;
+        self.token_index = 0;
+
+        let mut statements = Vec::new();
+
+        while !self.is_eof() {
+            let token = match self.peek() {
+                Some(t) => t.clone(),
+                None => {
+                    break;
+                }
+            };
+
+            let statement = match &token.kind {
+                TokenKind::At => parse_at_token(self, global_store),
+                TokenKind::Identifier => {
+                    if let Some(next) = self.peek_nth(1).cloned() {
+                        if next.kind == TokenKind::Arrow {
+                            parse_arrow_call(self, global_store)
+                        } else {
+                            parse_identifier_token(self, global_store)
+                        }
+                    } else {
+                        parse_identifier_token(self, global_store)
+                    }
+                }
+                TokenKind::Dot => parse_dot_token(self, global_store),
+                TokenKind::Tempo => parse_tempo_token(self, global_store),
+                TokenKind::Bank => parse_bank_token(self, global_store),
+                TokenKind::Loop => parse_loop_token(self, global_store),
+                TokenKind::If => parse_condition_token(self, 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::Newline
+                | TokenKind::Dedent
+                | TokenKind::Indent => {
+                    self.advance();
+                    continue;
+                }
+
+                TokenKind::EOF => {
+                    break;
+                }
+
+                _ => {
+                    println!("Unhandled token: {:?}", token);
+                    self.advance();
+                    Statement::unknown()
+                }
+            };
+
+            statements.push(statement);
+        }
+
+        statements
+    }
+
+    pub fn check_token(&self, kind: TokenKind) -> bool {
+        self.peek().map_or(false, |t| t.kind == kind)
+    }
+
+    pub fn parse_map_value(&mut self) -> Option<Value> {
+        if !self.match_token(TokenKind::LBrace) {
+            return None;
+        }
+
+        let mut map = std::collections::HashMap::new();
+
+        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
+            let key = if let Some(token) = self.advance() {
+                token.lexeme.clone()
+            } else {
+                break;
+            };
+
+            if !self.match_token(TokenKind::Colon) {
+                println!("Expected ':' after map key '{}'", key);
+                break;
+            }
+
+            let value = if let Some(token) = self.peek_clone() {
+                match token.kind {
+                    TokenKind::String => {
+                        self.advance();
+                        Value::String(token.lexeme.clone())
+                    }
+                    TokenKind::Number => {
+                        self.advance();
+                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
+                    }
+                    TokenKind::Identifier => {
+                        self.advance();
+                        Value::Identifier(token.lexeme.clone())
+                    }
+                    _ => {
+                        println!("Unexpected token in map value: {:?}", token);
+                        Value::Null
+                    }
+                }
+            } else {
+                Value::Null
+            };
+
+            map.insert(key, value);
+        }
+
+        if !self.match_token(TokenKind::RBrace) {
+            println!("Expected '}}' at end of map");
+        }
+
+        Some(Value::Map(map))
+    }
+
+    pub fn peek(&self) -> Option<&Token> {
+        self.tokens.get(self.token_index)
+    }
+
+    pub fn peek_clone(&self) -> Option<Token> {
+        self.tokens.get(self.token_index).cloned()
+    }
+
+    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
+        let tok = self.advance().ok_or("Unexpected end of input")?;
+        if tok.kind == kind {
+            Ok(tok)
+        } else {
+            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
+        }
+    }
+
+    pub fn collect_block_tokens(&mut self, base_indent: usize) -> Vec<Token> {
+        let mut tokens = Vec::new();
+
+        while let Some(tok) = self.peek() {
+            if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
+                break;
+            }
+            tokens.push(self.advance().unwrap().clone());
+        }
+
+        tokens
+    }
+
+    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
+        let mut collected = Vec::new();
+        while let Some(token) = self.peek() {
+            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
+                self.advance(); // Skip newlines and indents
+                continue;
+            }
+            if token.kind == TokenKind::EOF {
+                break;
+            }
+            if condition(token) {
+                break;
+            }
+            collected.push(self.advance().unwrap().clone());
+        }
+        collected
+    }
+
+    pub fn is_eof(&self) -> bool {
+        self.token_index >= self.tokens.len()
+    }
+
+    pub fn parse_block_until_next_else(
+        &mut self,
+        base_indent: usize,
+        global_store: &mut GlobalStore
+    ) -> Vec<Statement> {
+        let mut block_tokens = Vec::new();
+
+        while let Some(tok) = self.peek() {
+            // Stop if we encounter an 'else' at same indent level
+            if tok.lexeme == "else" && tok.indent == base_indent {
+                break;
+            }
+            block_tokens.push(self.advance().unwrap().clone());
+        }
+
+        self.parse_block(block_tokens, global_store)
+    }
+
+    pub fn parse_condition_until_colon(&mut self) -> Option<Value> {
+        let tokens = self.collect_until(|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))
+    }
+
+    pub fn parse_block_until_else_or_dedent(
+        &mut self,
+        base_indent: usize,
+        global_store: &mut GlobalStore
+    ) -> Vec<Statement> {
+        let mut tokens = Vec::new();
+
+        while let Some(tok) = self.peek() {
+            if tok.lexeme == "else" && tok.indent == base_indent {
+                break;
+            }
+            if tok.indent < base_indent && tok.kind != TokenKind::Newline {
+                break;
+            }
+            tokens.push(self.advance().unwrap().clone());
+        }
+
+        self.parse_block(tokens, global_store)
+    }
+}

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

@@ -0,0 +1,126 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+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();
+    }
+
+    let Some(arrow_token) = parser.peek_nth(1).cloned() else {
+        parser.advance(); // consume arrow token
+        return Statement {
+            kind: StatementKind::Unknown,
+            value: Value::String(target_token.lexeme.clone()),
+            indent: target_token.indent,
+            line: target_token.line,
+            column: target_token.column,
+        };
+    };
+
+    if arrow_token.kind != TokenKind::Arrow {
+        parser.advance(); // consume method token
+        return Statement {
+            kind: StatementKind::Unknown,
+            value: Value::String(target_token.lexeme.clone()),
+            indent: target_token.indent,
+            line: target_token.line,
+            column: 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();
+    };
+
+    if method_token.kind != TokenKind::Identifier {
+        parser.advance();
+        return Statement::unknown();
+    }
+
+    // Consume the tokens for target, arrow, and method
+    parser.advance(); // target
+    parser.advance(); // ->
+    parser.advance(); // method
+
+    let mut args = Vec::new();
+
+    while let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
+            break;
+        }
+
+        parser.advance();
+
+        let value = match token.kind {
+            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
+            TokenKind::String => Value::String(token.lexeme.clone()),
+            TokenKind::Number => Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0)),
+            TokenKind::LBrace => {
+                // Handle map literal
+                let mut map = std::collections::HashMap::new();
+                while let Some(inner_token) = parser.peek_clone() {
+                    if inner_token.kind == TokenKind::RBrace {
+                        parser.advance(); // consume RBrace
+                        break;
+                    }
+                    if inner_token.kind == TokenKind::Newline || inner_token.kind == TokenKind::EOF {
+                        break;
+                    }
+                    parser.advance(); // consume key token
+                    let key = inner_token.lexeme.clone();
+
+                    if let Some(colon_token) = parser.peek_clone() {
+                        if colon_token.kind == TokenKind::Colon {
+                            parser.advance(); // consume colon
+                            if let Some(value_token) = parser.peek_clone() {
+                                parser.advance(); // consume value token
+                                let value = match value_token.kind {
+                                    TokenKind::Identifier =>
+                                        Value::Identifier(value_token.lexeme.clone()),
+                                    TokenKind::String => Value::String(value_token.lexeme.clone()),
+                                    TokenKind::Number =>
+                                        Value::Number(
+                                            value_token.lexeme.parse::<f32>().unwrap_or(0.0)
+                                        ),
+                                    TokenKind::Boolean =>
+                                        Value::Boolean(
+                                            value_token.lexeme.parse::<bool>().unwrap_or(false)
+                                        ),
+                                    _ => Value::Unknown,
+                                };
+                                map.insert(key, value);
+                            }
+                        }
+                    }
+                }
+                Value::Map(map)
+            }
+            _ => Value::Unknown,
+        };
+
+        args.push(value);
+    }
+
+    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,14 +1,10 @@
 use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        handler::identifier::parse_identifier_token,
-        statement::{ Statement, StatementKind },
-        Parser,
-    },
+    lexer::token::TokenKind,
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
     shared::value::Value,
     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 {

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

@@ -1,6 +1,6 @@
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, Parser },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
     shared::value::Value,
     store::global::GlobalStore,
 };
@@ -25,7 +25,10 @@ pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             _ => Value::Unknown,
         }
     } else {
-        return Statement::error(bank_token, "Expected identifier or number after 'bank'".to_string());
+        return Statement::error(
+            bank_token,
+            "Expected identifier or number after 'bank'".to_string()
+        );
     };
 
     Statement {

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

@@ -1,6 +1,6 @@
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, Parser },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
     shared::{ duration::Duration, value::Value },
     store::global::GlobalStore,
 };

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,
+    };
+}