devalang_wasm/language/syntax/parser/driver/

mod.rs

pub mod directive;
pub mod duration;
pub mod effects;
pub mod helpers;
pub mod preprocessing;
pub mod routing;
pub mod statements;
pub mod trigger;
// Re-export statement-level parsers so they are available at driver root
use crate::language::syntax::ast::nodes::{Statement, StatementKind, Value};
use anyhow::{Result, anyhow};
pub use statements::*;
use std::path::{Path, PathBuf};

/// Entry point: parse source into a list of Statements
pub fn parse(source: &str, path: PathBuf) -> Result<Vec<Statement>> {
    // Pre-process: merge ALL multiline statements with braces
    let braces_pre = preprocessing::preprocess_multiline_braces(source);

    // Then merge multiline arrow calls (without braces)
    let preprocessed = preprocessing::preprocess_multiline_arrow_calls(&braces_pre);

    let lines: Vec<_> = preprocessed.lines().collect();
    parse_lines(&lines, 0, lines.len(), 0, &path)
}

/// Parse a range of lines into statements, handling indentation for blocks.
fn parse_lines(
    lines: &Vec<&str>,
    start: usize,
    end: usize,
    indent: usize,
    path: &Path,
) -> Result<Vec<Statement>> {
    use crate::language::syntax::ast::nodes::StatementKind;

    let mut i = start;
    let mut statements: Vec<Statement> = Vec::new();

    while i < end {
        let raw = lines[i];
        let trimmed = raw.trim();

        if trimmed.is_empty() || trimmed.starts_with('#') {
            i += 1;
            continue;
        }

        let current_indent = raw.len() - raw.trim_start().len();
        if current_indent < indent {
            break;
        }

        // parse header line
        let mut statement = parse_line(trimmed, i + 1, path)?;
        statement.indent = current_indent;
        statement.line = i + 1;

        // determine body range for block statements
        let body_start = i + 1;
        let mut body_end = body_start;
        while body_end < end {
            let l = lines[body_end];
            if l.trim().is_empty() || l.trim().starts_with('#') {
                body_end += 1;
                continue;
            }
            let indent_l = l.len() - l.trim_start().len();
            if indent_l <= current_indent {
                break;
            }
            body_end += 1;
        }

        // If we found a body, parse it and attach appropriately based on kind
        if body_end > body_start {
            let body = parse_lines(lines, body_start, body_end, current_indent + 1, path)?;

            // To avoid borrowing `statement.kind` and then assigning to it
            // (which the borrow checker forbids), take ownership of the kind
            // temporarily and then replace it with the updated version.
            let orig_kind = std::mem::replace(&mut statement.kind, StatementKind::Unknown);
            match orig_kind {
                StatementKind::If { condition, .. } => {
                    // Keep If simple here; attach else/else-if later in post-processing
                    statement.kind = StatementKind::If {
                        condition,
                        body: body.clone(),
                        else_body: None,
                    };
                }
                StatementKind::For {
                    variable, iterable, ..
                } => {
                    statement.kind = StatementKind::For {
                        variable,
                        iterable,
                        body: body.clone(),
                    };
                }
                StatementKind::Loop { count, .. } => {
                    statement.kind = StatementKind::Loop {
                        count,
                        body: body.clone(),
                    };
                }
                StatementKind::On { event, args, .. } => {
                    statement.kind = StatementKind::On {
                        event,
                        args,
                        body: body.clone(),
                    };
                }
                StatementKind::Automate { target } => {
                    statement.kind = StatementKind::Automate { target };
                    // store raw body as value map if needed elsewhere
                    let raw_lines: Vec<String> = lines[body_start..body_end]
                        .iter()
                        .map(|s| s.to_string())
                        .collect();
                    let raw_body = raw_lines.join("\n");
                    let mut map = std::collections::HashMap::new();
                    map.insert("body".to_string(), Value::String(raw_body));
                    statement.value = Value::Map(map);
                }
                StatementKind::Function {
                    name, parameters, ..
                } => {
                    statement.kind = StatementKind::Function {
                        name: name.clone(),
                        parameters,
                        body: body.clone(),
                    };
                    statement.value = Value::Identifier(name.clone());
                }
                StatementKind::Group { .. } => {
                    // attach body for groups, keep name in value if present
                    let group_name = match &statement.value {
                        Value::Identifier(s) => s.clone(),
                        _ => "".to_string(),
                    };
                    statement.kind = StatementKind::Group {
                        name: group_name,
                        body: body.clone(),
                    };
                }
                other => {
                    // keep original kind for other statements
                    statement.kind = other;
                }
            }

            // If this statement was a plain 'else' marker (Comment with value "else"),
            // the parsed body was not attached to the marker (we intentionally
            // keep the marker lightweight). We must append the parsed body
            // statements into the parent statements vector so the post-process
            // pass can collect them and attach to the previous If.
            i = body_end;
            statements.push(statement);

            if let StatementKind::Comment = &statements.last().unwrap().kind {
                if let Value::String(s) = &statements.last().unwrap().value {
                    if s == "else" {
                        // append the body statements after the marker
                        for stmt in body.into_iter() {
                            statements.push(stmt);
                        }
                    }
                }
            }
            continue;
        }

        // No body found
        statements.push(statement);
        i += 1;
    }

    // Post-process to attach else/else-if blocks
    fn attach_else_blocks(statements: &mut Vec<Statement>) {
        use crate::language::syntax::ast::StatementKind;

        // Helper: attach a new else-body (Vec<Statement>) to an existing If Statement.
        // If the If already has a nested else-if chain (encoded as a single If in
        // its else_body vector), descend into that chain and attach to the deepest
        // nested If instead of overwriting the entire else_body.
        fn attach_else_to_if_statement(target: Statement, new_else: Vec<Statement>) -> Statement {
            use crate::language::syntax::ast::StatementKind;

            match target.kind {
                StatementKind::If {
                    condition,
                    body,
                    else_body,
                } => {
                    match else_body {
                        None => Statement::new(
                            StatementKind::If {
                                condition,
                                body,
                                else_body: Some(new_else),
                            },
                            target.value,
                            target.indent,
                            target.line,
                            target.column,
                        ),
                        Some(mut eb) => {
                            if eb.len() == 1 {
                                let inner = eb.remove(0);
                                // If inner is an If, recurse into it
                                if let StatementKind::If { .. } = inner.kind {
                                    let updated_inner =
                                        attach_else_to_if_statement(inner, new_else);
                                    Statement::new(
                                        StatementKind::If {
                                            condition,
                                            body,
                                            else_body: Some(vec![updated_inner]),
                                        },
                                        target.value,
                                        target.indent,
                                        target.line,
                                        target.column,
                                    )
                                } else {
                                    // Not an If inside else_body; overwrite
                                    Statement::new(
                                        StatementKind::If {
                                            condition,
                                            body,
                                            else_body: Some(new_else),
                                        },
                                        target.value,
                                        target.indent,
                                        target.line,
                                        target.column,
                                    )
                                }
                            } else {
                                // Multiple statements in existing else_body; overwrite for now
                                Statement::new(
                                    StatementKind::If {
                                        condition,
                                        body,
                                        else_body: Some(new_else),
                                    },
                                    target.value,
                                    target.indent,
                                    target.line,
                                    target.column,
                                )
                            }
                        }
                    }
                }
                _ => target,
            }
        }

        let mut idx = 0;
        while idx < statements.len() {
            // Handle plain 'else' marker: Comment with value "else"
            if let StatementKind::Comment = &statements[idx].kind {
                if let Value::String(s) = &statements[idx].value {
                    if s == "else" {
                        let else_indent = statements[idx].indent;

                        // Collect following statements that are part of the else body
                        let mut body: Vec<Statement> = Vec::new();
                        let j = idx + 1;
                        while j < statements.len() && statements[j].indent > else_indent {
                            body.push(statements.remove(j));
                        }

                        // Remove the 'else' marker itself
                        statements.remove(idx);

                        // Find previous If to attach to (search backwards) and attach
                        // the parsed else body to the deepest nested If in the chain.
                        let mut k = idx as isize - 1;
                        while k >= 0 {
                            if let StatementKind::If { .. } = &statements[k as usize].kind {
                                // Take ownership of the previous If statement, attach into it,
                                // then put back the updated statement.
                                let prev = std::mem::replace(
                                    &mut statements[k as usize],
                                    Statement::new(StatementKind::Unknown, Value::Null, 0, 0, 1),
                                );
                                let updated = attach_else_to_if_statement(prev, body);
                                statements[k as usize] = updated;
                                break;
                            }
                            k -= 1;
                        }

                        continue;
                    }
                }
            }

            // Handle 'else if' which was parsed as an If with value == "else-if"
            if let StatementKind::If { .. } = &statements[idx].kind {
                if let Value::String(s) = &statements[idx].value {
                    if s == "else-if" {
                        // Remove this else-if statement and attach it as the
                        // else_body (single-statement vector) of the previous If.
                        let else_if_stmt = statements.remove(idx);

                        // find previous If and attach this else-if into its nested chain
                        let mut k = idx as isize - 1;
                        while k >= 0 {
                            if let StatementKind::If { .. } = &statements[k as usize].kind {
                                let prev = std::mem::replace(
                                    &mut statements[k as usize],
                                    Statement::new(StatementKind::Unknown, Value::Null, 0, 0, 1),
                                );
                                let updated = attach_else_to_if_statement(prev, vec![else_if_stmt]);
                                statements[k as usize] = updated;
                                break;
                            }
                            k -= 1;
                        }

                        continue;
                    }
                }
            }

            idx += 1;
        }
    }

    attach_else_blocks(&mut statements);

    Ok(statements)
}

fn parse_line(line: &str, line_number: usize, path: &Path) -> Result<Statement> {
    use crate::language::syntax::parser::driver::statements::*;

    if line.starts_with('@') {
        return directive::parse_directive(line, line_number, path);
    }

    if line.starts_with('.') {
        return trigger::parse_trigger_line(line, line_number);
    }

    let mut parts = line.split_whitespace();
    // Extract first token as keyword and strip a trailing ':' if present
    let first_token = parts
        .next()
        .ok_or_else(|| anyhow!("empty line"))?
        .to_string();
    let keyword = first_token.trim_end_matches(':').to_lowercase();

    // Check if this is a property assignment first: target.property = value
    if line.contains('=') && keyword.contains('.') {
        return parse_assign(line, line_number);
    }

    // Check if this looks like a trigger (contains a dot like "drums.kick")
    if keyword.contains('.') && !keyword.contains('(') {
        // Reconstruct the line and parse as trigger
        return trigger::parse_trigger_line(line, line_number);
    }

    // Check if this is a bind statement first (before arrow call)
    if keyword == "bind" && line.contains("->") {
        return parse_bind(line, line_number);
    }

    // If this line contains an arrow call, parse it as an ArrowCall, UNLESS the
    // statement starts with a reserved keyword that must be handled (let/var/const/etc.).
    // This ensures constructs like `let name = .bank.kick -> reverse(...)` are
    // parsed by `parse_let` rather than being mis-parsed as an ArrowCall.
    let reserved_keywords = [
        "bpm", "tempo", "print", "sleep", "pattern", "bank", "let", "var", "const", "for", "loop",
        "if", "else", "group", "automate", "call", "spawn", "on", "emit", "routing", "return",
        "break",
    ];
    if line.contains("->") && !reserved_keywords.contains(&keyword.as_str()) {
        return statements::parse_arrow_call(line, line_number);
    }

    return match keyword.as_str() {
        "bpm" | "tempo" => statements::core::parse_tempo(parts, line_number),
        "print" => statements::core::parse_print(line, line_number),
        "sleep" => statements::core::parse_sleep(parts, line_number),
        "trigger" => Err(anyhow!(
            "keyword 'trigger' is deprecated; use dot notation like '.alias' instead"
        )),
        "pattern" => parse_pattern(parts, line_number),
        "bank" => parse_bank(parts, line_number),
        "let" => parse_let(line, parts, line_number),
        "var" => parse_var(line, parts, line_number),
        "const" => parse_const(line, parts, line_number),
        "for" => parse_for(parts, line_number),
        "loop" => parse_loop(parts, line_number),
        "if" => statements::structure::parse_if(parts, line_number),
        "else" => statements::structure::parse_else(line, line_number),
        "group" => statements::structure::parse_group(parts, line_number),
        "automate" => {
            crate::language::syntax::parser::driver::statements::structure::parse_automate(
                parts,
                line_number,
            )
        }
        "call" => parse_call(line, parts, line_number),
        "break" => statements::structure::parse_break(parts, line_number),
        "function" => statements::structure::parse_function(line, line_number),
        "spawn" => parse_spawn(parts, line_number),
        "on" => parse_on(parts, line_number),
        "emit" => parse_emit(line, parts, line_number),
        "return" => statements::core::parse_return(line, line_number),
        "routing" => crate::language::syntax::parser::driver::routing::parse_routing_command(
            parts,
            line_number,
        ),
        _ => {
            // Check if this looks like a potential trigger identifier (single word, no special chars except dots)
            // This handles cases like variable references: let kick = drums.kick; kick
            if keyword
                .chars()
                .all(|c| c.is_alphanumeric() || c == '_' || c == '.')
            {
                // Parse as trigger
                return trigger::parse_trigger_line(line, line_number);
            }

            let error_msg = format!(
                "Unknown statement '{}' at {}:{}",
                keyword,
                path.display(),
                line_number
            );

            // Push structured error to WASM registry if available
            #[cfg(feature = "wasm")]
            {
                use crate::web::registry::debug;
                if debug::is_debug_errors_enabled() {
                    // wasm registry expects: message, line, column, error_type
                    debug::push_parse_error_from_parts(
                        format!("Unknown statement '{}'", keyword),
                        line_number,
                        1,
                        "UnknownStatement".to_string(),
                    );
                }
            }

            return Ok(Statement::new(
                StatementKind::Unknown,
                Value::String(error_msg),
                0,
                line_number,
                1,
            ));
        }
    };
}

/// Re-export helper parsing functions from helpers.rs so other modules can call them
pub use helpers::{
    parse_array_value, parse_condition, parse_function_args, parse_map_value, parse_single_arg,
    parse_synth_definition,
};

/// SimpleParser is a small wrapper used by other modules/tests in the crate.
/// It forwards to the top-level parse implementation above.
pub struct SimpleParser;

impl SimpleParser {
    pub fn parse(source: &str, path: PathBuf) -> Result<Vec<Statement>> {
        crate::language::syntax::parser::driver::parse(source, path)
    }

    pub fn parse_file<P: AsRef<Path>>(path: P) -> Result<Vec<Statement>> {
        let buf = std::path::PathBuf::from(path.as_ref());
        let s = std::fs::read_to_string(&buf)?;
        Self::parse(&s, buf)
    }
}