pine_parser/

lib.rs

pub use pine_ast::{Argument, BinOp, Comment, Expr, Literal, Loc, Program, Stmt, UnOp, VarKind};
use pine_lexer::{Token, TokenType};
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ParserErrorKind {
    #[error("Unexpected token: {0:?}")]
    UnexpectedToken(TokenType),

    #[error("{expected} but found {found:?}")]
    ExpectedToken { expected: String, found: TokenType },

    #[error("Expected variable name")]
    ExpectedVariableName,

    #[error("Expected parameter name")]
    ExpectedParameterName,

    #[error("Can only call identifiers or member access")]
    InvalidCallTarget,

    #[error("Expected identifier after '.'")]
    ExpectedIdentifierAfterDot,

    #[error(transparent)]
    Lexer(pine_lexer::LexerError),
}

/// A parse error and the 1-based source position it points at.
#[derive(Debug)]
pub struct ParserError {
    pub loc: Loc,
    pub kind: ParserErrorKind,
}

impl ParserError {
    /// The 1-based `(line, column)` the error points at.
    pub fn location(&self) -> (u32, u32) {
        (self.loc.line, self.loc.column)
    }
}

impl std::fmt::Display for ParserError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            // Lexer errors already spell out their own line and column.
            ParserErrorKind::Lexer(e) => write!(f, "{e}"),
            kind => write!(f, "{kind} at line {}", self.loc.line),
        }
    }
}

impl std::error::Error for ParserError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.kind)
    }
}

impl From<pine_lexer::LexerError> for ParserError {
    fn from(e: pine_lexer::LexerError) -> Self {
        let (line, column) = e.location();
        ParserError {
            loc: Loc::new(line, column),
            kind: ParserErrorKind::Lexer(e),
        }
    }
}

impl From<ParserError> for String {
    fn from(err: ParserError) -> String {
        err.to_string()
    }
}

/// Helper trait to convert TokenType to operators
trait TokenTypeExt {
    fn to_binop(&self) -> Option<BinOp>;
}

impl TokenTypeExt for TokenType {
    /// Convert token type to binary operator, if applicable
    fn to_binop(&self) -> Option<BinOp> {
        match self {
            TokenType::Plus => Some(BinOp::Add),
            TokenType::Minus => Some(BinOp::Sub),
            TokenType::Star => Some(BinOp::Mul),
            TokenType::Slash => Some(BinOp::Div),
            TokenType::Percent => Some(BinOp::Mod),
            TokenType::Equal => Some(BinOp::Eq),
            TokenType::NotEqual => Some(BinOp::NotEq),
            TokenType::Less => Some(BinOp::Less),
            TokenType::Greater => Some(BinOp::Greater),
            TokenType::LessEqual => Some(BinOp::LessEq),
            TokenType::GreaterEqual => Some(BinOp::GreaterEq),
            TokenType::And => Some(BinOp::And),
            TokenType::Or => Some(BinOp::Or),
            TokenType::PlusAssign => Some(BinOp::Add),
            TokenType::MinusAssign => Some(BinOp::Sub),
            TokenType::StarAssign => Some(BinOp::Mul),
            TokenType::SlashAssign => Some(BinOp::Div),
            _ => None,
        }
    }
}

pub struct Parser {
    tokens: Vec<Token>,
    comments: Vec<Comment>,
    current: usize,
    next_call_id: u32,
}

impl Parser {
    pub fn new(tokens: Vec<Token>) -> Self {
        let mut comments = Vec::new();
        let tokens = tokens
            .into_iter()
            .filter(|t| {
                if let TokenType::Comment(text) = &t.typ {
                    comments.push(Comment {
                        line: t.line as u32,
                        text: text.clone(),
                    });
                }
                !matches!(t.typ, TokenType::Comment(_) | TokenType::BlankLine)
            })
            .collect();
        Self {
            tokens,
            comments,
            current: 0,
            next_call_id: 1,
        }
    }

    pub fn parse_program(mut self) -> Result<Program, ParserError> {
        let statements = self.parse()?;
        Ok(Program::new(statements).with_comments(self.comments))
    }

    /// Lex and parse `source` into a program in one step.
    pub fn parse_source(source: &str) -> Result<Program, ParserError> {
        let tokens = pine_lexer::Lexer::new(source).tokenize()?;
        Self::new(tokens).parse_program()
    }

    fn next_call_id(&mut self) -> u32 {
        let id = self.next_call_id;
        self.next_call_id += 1;
        id
    }

    fn peek(&self) -> &Token {
        &self.tokens[self.current]
    }

    fn is_at_end(&self) -> bool {
        matches!(self.peek().typ, TokenType::Eof)
    }

    fn advance(&mut self) -> &Token {
        if !self.is_at_end() {
            self.current += 1;
        }
        &self.tokens[self.current - 1]
    }

    fn check(&self, typ: &TokenType) -> bool {
        !self.is_at_end() && &self.peek().typ == typ
    }

    fn match_token(&mut self, types: &[TokenType]) -> bool {
        for typ in types {
            if self.check(typ) {
                self.advance();
                return true;
            }
        }
        false
    }

    /// Try to parse something speculatively. If parsing fails, restore position and return None.
    /// This is useful for lookahead/backtracking scenarios.
    fn try_parse<T, F>(&mut self, f: F) -> Option<T>
    where
        F: FnOnce(&mut Self) -> Result<T, ParserError>,
    {
        let saved_pos = self.current;
        match f(self) {
            Ok(val) => Some(val),
            Err(_) => {
                self.current = saved_pos;
                None
            }
        }
    }

    /// Try to parse type arguments: <type1, type2, ...>
    /// Returns None if this isn't actually type arguments (e.g., it's a comparison)
    fn try_parse_type_args(&mut self) -> Option<Vec<String>> {
        self.try_parse(|p| {
            p.consume(TokenType::Less, "Expected '<'")?;

            let mut type_args = vec![];

            loop {
                // Parse type name (identifier or type keyword like int/float)
                let type_name = match &p.peek().typ {
                    TokenType::Ident(name) => name.clone(),
                    TokenType::Int => "int".to_string(),
                    TokenType::Float => "float".to_string(),
                    _ => return Err(p.unexpected()),
                };
                p.advance();
                type_args.push(type_name);

                // Check for comma (more types) or end
                if p.match_token(&[TokenType::Comma]) {
                    continue;
                } else if p.match_token(&[TokenType::Greater]) {
                    break;
                } else {
                    return Err(p.unexpected());
                }
            }

            Ok(type_args)
        })
    }

    /// Skip any newline tokens
    fn skip_newlines(&mut self) {
        while self.match_token(&[TokenType::Newline]) {}
    }

    /// Skip newlines, indents, and dedents (whitespace tokens)
    fn skip_whitespace(&mut self) {
        while self.match_token(&[TokenType::Newline, TokenType::Indent, TokenType::Dedent]) {}
    }

    /// Parse an optional type suffix: an array `[]`, or — for a collection type
    /// (`array`/`matrix`/`map`) — a generic `<...>` argument list. Returns the
    /// type's textual form (e.g. `float[]`, `array<Point>`, `map<string, int>`).
    /// The generic form is limited to collection bases so a bare `x < y > z`
    /// comparison is never mistaken for a type.
    fn parse_type_suffix(&mut self, type_name: String) -> Result<String, ParserError> {
        if self.match_token(&[TokenType::LBracket]) {
            self.consume(TokenType::RBracket, "Expected ']' after '[' in array type")?;
            Ok(format!("{type_name}[]"))
        } else if matches!(type_name.as_str(), "array" | "matrix" | "map")
            && self.match_token(&[TokenType::Less])
        {
            let mut args = Vec::new();
            loop {
                args.push(self.parse_type()?);
                if !self.match_token(&[TokenType::Comma]) {
                    break;
                }
            }
            self.consume(
                TokenType::Greater,
                "Expected '>' after generic type arguments",
            )?;
            Ok(format!("{type_name}<{}>", args.join(", ")))
        } else {
            Ok(type_name)
        }
    }

    /// Parse a type name (`int`/`float`/identifier) with its optional suffix.
    fn parse_type(&mut self) -> Result<String, ParserError> {
        let base = match &self.peek().typ {
            TokenType::Int => "int".to_string(),
            TokenType::Float => "float".to_string(),
            TokenType::Ident(name) => name.clone(),
            _ => return Err(self.unexpected()),
        };
        self.advance();
        self.parse_type_suffix(base)
    }

    /// Parse an expression that may be on an indented continuation line.
    /// Handles: newlines + optional indent + expression + optional dedent
    fn parse_indented_expression(&mut self) -> Result<Expr, ParserError> {
        self.skip_newlines();

        // Check if expression is on an indented line
        let has_indent = self.match_token(&[TokenType::Indent]);

        let expr = self.expression()?;

        // Consume dedent if we had indent
        if has_indent {
            self.match_token(&[TokenType::Dedent]);
        }

        Ok(expr)
    }

    fn consume(&mut self, typ: TokenType, message: &str) -> Result<&Token, ParserError> {
        if self.check(&typ) {
            Ok(self.advance())
        } else {
            Err(self.error(ParserErrorKind::ExpectedToken {
                expected: message.to_string(),
                found: self.peek().typ.clone(),
            }))
        }
    }

    /// Helper to extract an identifier from the current token and advance
    fn expect_identifier(&mut self) -> Result<String, ParserError> {
        if let TokenType::Ident(name) = &self.peek().typ {
            let name = name.clone();
            self.advance();
            Ok(name)
        } else {
            Err(self.error(ParserErrorKind::ExpectedVariableName))
        }
    }

    /// Generic helper to parse indented field blocks
    fn parse_indented_fields<T, F>(&mut self, parse_field: F) -> Result<Vec<T>, ParserError>
    where
        F: Fn(&mut Self) -> Result<T, ParserError>,
    {
        let mut fields = Vec::new();

        loop {
            // Skip newlines between fields
            self.skip_newlines();

            // Check for dedent (end of field block)
            if self.check(&TokenType::Dedent) {
                self.advance();
                break;
            }

            // Check for end of file
            if self.is_at_end() {
                break;
            }

            // Parse a field using the provided parser
            fields.push(parse_field(self)?);
        }

        Ok(fields)
    }

    /// Helper to skip newlines and optionally match indent
    fn skip_newlines_and_indent(&mut self) {
        self.skip_newlines();
        self.match_token(&[TokenType::Indent]);
    }

    /// Helper to skip newlines and optionally match dedent
    fn skip_newlines_and_dedent(&mut self) {
        self.skip_newlines();
        self.match_token(&[TokenType::Dedent]);
    }

    /// Helper to speculatively consume indent only if followed by expected token
    fn try_consume_indent_if_followed_by(&mut self, expected: &TokenType) {
        if self.check(&TokenType::Indent) {
            self.try_parse(|p| {
                p.advance(); // consume indent
                if p.check(expected) {
                    Ok(())
                } else {
                    Err(p.unexpected())
                }
            });
        }
    }

    /// Helper to speculatively consume indent/dedent only if followed by one of the expected operators
    fn try_consume_layout_token_if_followed_by(&mut self, expected: &[TokenType]) {
        if self.check(&TokenType::Indent) || self.check(&TokenType::Dedent) {
            self.try_parse(|p| {
                p.advance(); // consume indent or dedent
                for typ in expected {
                    if p.check(typ) {
                        return Ok(());
                    }
                }
                Err(p.unexpected())
            });
        }
    }

    /// Helper to parse optional type qualifier (const, input, simple, series)
    fn parse_optional_type_qualifier(&mut self) -> Option<pine_ast::TypeQualifier> {
        use pine_ast::TypeQualifier;
        if self.match_token(&[TokenType::Const]) {
            Some(TypeQualifier::Const)
        } else if let TokenType::Ident(name) = &self.peek().typ {
            match name.as_str() {
                "input" => {
                    self.advance();
                    Some(TypeQualifier::Input)
                }
                "simple" => {
                    self.advance();
                    Some(TypeQualifier::Simple)
                }
                "series" => {
                    self.advance();
                    Some(TypeQualifier::Series)
                }
                _ => None,
            }
        } else {
            None
        }
    }

    /// Helper to parse optional type annotation with array suffix
    /// Returns None if no type annotation is found
    /// Supports: int, float, or custom identifier types with optional [] suffix
    fn parse_optional_type_annotation(&mut self) -> Option<String> {
        if self.match_token(&[TokenType::Int, TokenType::Float]) {
            let type_name = self.tokens[self.current - 1].lexeme.clone();
            // Check for array type: int[] or float[]
            self.parse_type_suffix(type_name).ok()
        } else if let TokenType::Ident(type_name) = &self.peek().typ {
            let type_name = type_name.clone();
            self.try_parse(|p| {
                p.advance(); // consume potential type name

                // Check for an array `[]` or generic `<...>` suffix.
                let final_type = p.parse_type_suffix(type_name.clone())?;

                // Must be followed by identifier to be a type annotation
                if !matches!(p.peek().typ, TokenType::Ident(_)) {
                    return Err(p.error(ParserErrorKind::ExpectedVariableName));
                }

                Ok(final_type)
            })
        } else {
            None
        }
    }

    /// Generic helper to parse comma-separated lists
    /// Handles newlines and optional indentation around commas
    fn parse_comma_separated<T, F>(
        &mut self,
        closing_delimiter: &TokenType,
        parse_item: F,
    ) -> Result<Vec<T>, ParserError>
    where
        F: Fn(&mut Self) -> Result<T, ParserError>,
    {
        let mut items = vec![];

        if !self.check(closing_delimiter) {
            loop {
                items.push(parse_item(self)?);

                // Skip newlines after each item
                self.skip_newlines();

                if !self.match_token(&[TokenType::Comma]) {
                    break;
                }

                // Skip newlines after comma
                self.skip_newlines_and_indent();
            }
        }

        Ok(items)
    }

    // Parse a program (top-level)
    pub fn parse(&mut self) -> Result<Vec<Stmt>, ParserError> {
        let mut statements = vec![];

        while !self.is_at_end() {
            // Skip any leading newlines and dedents (dedents at top level are from EOF)
            self.skip_whitespace();

            // Check if we reached EOF after skipping
            if self.is_at_end() {
                break;
            }

            statements.push(self.declaration()?);
        }

        Ok(statements)
    }

    // Declarations (var declarations, assignments, etc.)
    /// The position of the current token, for attaching to a declaration node.
    fn cur_loc(&self) -> Loc {
        let token = self.peek();
        Loc::new(token.line as u32, token.column as u32)
    }

    /// The position of the most recently consumed token.
    fn prev_loc(&self) -> Loc {
        let token = &self.tokens[self.current.saturating_sub(1)];
        Loc::new(token.line as u32, token.column as u32)
    }

    /// Build an error at the current token's position.
    fn error(&self, kind: ParserErrorKind) -> ParserError {
        ParserError {
            loc: self.cur_loc(),
            kind,
        }
    }

    /// The current token is not valid here.
    fn unexpected(&self) -> ParserError {
        self.error(ParserErrorKind::UnexpectedToken(self.peek().typ.clone()))
    }

    fn declaration(&mut self) -> Result<Stmt, ParserError> {
        // Check for type qualifier first (const, input, simple, series)
        let type_qualifier = self.parse_optional_type_qualifier();

        // Check for var or varip keyword (can be followed by type annotation)
        let var_kind = if self.match_token(&[TokenType::Varip]) {
            VarKind::Varip
        } else if self.match_token(&[TokenType::Var]) {
            VarKind::Var
        } else if type_qualifier.is_some() {
            // If we have a type qualifier but no var/varip, it's still a variable declaration
            // e.g., const int x = 5
            VarKind::Plain
        } else {
            // Not a var/varip declaration, continue to other statement types
            return self.check_type_annotated_declaration();
        };

        // Check if followed by type annotation: var int x = ..., var float y = ..., var label l = ...
        let type_annotation = self.parse_optional_type_annotation();
        self.typed_var_declaration_with_qualifier(type_qualifier, type_annotation, var_kind)
    }

    fn check_type_annotated_declaration(&mut self) -> Result<Stmt, ParserError> {
        // Check for type declaration: type TypeName
        if self.match_token(&[TokenType::Type]) {
            return self.type_declaration(false);
        }

        // Check for enum declaration: enum EnumName
        if self.match_token(&[TokenType::Enum]) {
            return self.enum_declaration(false);
        }

        // Check for method declaration: method methodName(params) =>
        if self.match_token(&[TokenType::Method]) {
            return self.method_declaration(false);
        }

        // Check for type-annotated declaration without var: int x = ..., float y = ..., int[] x = ...
        if self.match_token(&[TokenType::Int, TokenType::Float]) {
            let type_name = self.tokens[self.current - 1].lexeme.clone();
            // Check for array type: int[] or float[]
            let type_name = self.parse_type_suffix(type_name)?;
            return self.typed_var_declaration(Some(type_name), VarKind::Plain);
        }

        // Check for identifier type with optional []: string x = ..., string[] x = ...
        if let Some(type_annotation) = self.parse_optional_type_annotation() {
            return self.typed_var_declaration(Some(type_annotation), VarKind::Plain);
        }

        self.statement()
    }

    fn type_declaration(&mut self, export: bool) -> Result<Stmt, ParserError> {
        // Parse type name
        let loc = self.cur_loc();
        let type_name = self.expect_identifier()?;

        // Expect newline before fields
        self.consume(TokenType::Newline, "Expected newline after type name")?;

        // Expect indent to start field block
        self.consume(TokenType::Indent, "Expected indent for type fields")?;

        // Parse fields using generic helper
        let fields = self.parse_indented_fields(|p| {
            // Parse optional type qualifier (const, input, simple, series)
            let type_qualifier = p.parse_optional_type_qualifier();

            // Parse field: type_annotation field_name [= default_value]. The
            // type may be generic (`array<float>`, `map<string, int>`), so it
            // goes through the same parser as variable and parameter types.
            let field_type = p.parse_type()?;

            // Parse field name
            let field_loc = p.cur_loc();
            let field_name = p.expect_identifier()?;

            // Parse optional default value
            let default_value = if p.match_token(&[TokenType::Assign]) {
                Some(p.expression()?)
            } else {
                None
            };

            Ok(pine_ast::TypeField {
                name: field_name,
                type_qualifier,
                type_annotation: field_type,
                default_value,
                loc: field_loc,
            })
        })?;

        Ok(Stmt::TypeDecl {
            name: type_name,
            fields,
            export,
            loc,
        })
    }

    fn enum_declaration(&mut self, export: bool) -> Result<Stmt, ParserError> {
        // Parse enum name
        let loc = self.cur_loc();
        let enum_name = self.expect_identifier()?;

        // Expect newline before fields
        self.consume(TokenType::Newline, "Expected newline after enum name")?;

        // Expect indent to start field block
        self.consume(TokenType::Indent, "Expected indent for enum fields")?;

        // Parse fields using generic helper
        let fields = self.parse_indented_fields(|p| {
            // Parse field: field_name [= "title"]
            let field_loc = p.cur_loc();
            let field_name = p.expect_identifier()?;

            // Parse optional title
            let title = if p.match_token(&[TokenType::Assign]) {
                // Expect a string literal for the title
                if let TokenType::String(s) = &p.peek().typ {
                    let s = s.clone();
                    p.advance();
                    Some(s)
                } else {
                    return Err(p.unexpected());
                }
            } else {
                None
            };

            Ok(pine_ast::EnumField {
                name: field_name,
                title,
                loc: field_loc,
            })
        })?;

        Ok(Stmt::EnumDecl {
            name: enum_name,
            fields,
            export,
            loc,
        })
    }

    fn export_statement(&mut self) -> Result<Stmt, ParserError> {
        // export type typename - delegate to type_declaration
        if self.match_token(&[TokenType::Type]) {
            return self.type_declaration(true);
        }

        // export enum enumname - delegate to enum_declaration
        if self.match_token(&[TokenType::Enum]) {
            return self.enum_declaration(true);
        }

        // export [method] functionname(params) => body
        // Check if it's a method
        let is_method = self.match_token(&[TokenType::Method]);

        if is_method {
            return self.method_declaration(true);
        }

        // Parse function name
        let loc = self.cur_loc();
        let func_name = self.expect_identifier()?;

        // Check if this is a function declaration (followed by '(')
        if self.check(&TokenType::LParen) {
            // export functionname(params) => body
            self.advance(); // consume '('

            let params = self.function_params()?;
            self.consume(TokenType::RParen, "Expected ')' after function parameters")?;
            self.consume(TokenType::Arrow, "Expected '=>'")?;

            // Skip optional newline after =>
            self.match_token(&[TokenType::Newline]);

            // Parse function body (can be a block or single expression)
            let body = self.parse_block()?;

            Ok(Stmt::FunctionDecl {
                name: func_name,
                params,
                body,
                export: true,
                loc,
            })
        } else {
            // Just export functionname (old style - keeping for backward compatibility)
            Ok(Stmt::Export {
                item: pine_ast::ExportItem::Type(func_name),
            })
        }
    }

    fn import_statement(&mut self) -> Result<Stmt, ParserError> {
        // import userName/libraryName/version as alias
        let path = if let TokenType::Ident(p) = &self.peek().typ {
            let mut path_parts = vec![p.clone()];
            self.advance();

            // Parse path segments separated by /
            while self.match_token(&[TokenType::Slash]) {
                if let TokenType::Ident(part) = &self.peek().typ {
                    path_parts.push(part.clone());
                    self.advance();
                } else if let TokenType::IntLiteral(n) = &self.peek().typ {
                    // Version number (an integer path segment)
                    path_parts.push(n.to_string());
                    self.advance();
                } else {
                    return Err(self.unexpected());
                }
            }

            path_parts.join("/")
        } else {
            return Err(self.error(ParserErrorKind::ExpectedVariableName));
        };

        // Expect 'as' keyword - for now we'll check for an identifier "as"
        if let TokenType::Ident(kw) = &self.peek().typ {
            if kw != "as" {
                return Err(self.unexpected());
            }
            self.advance();
        } else {
            return Err(self.unexpected());
        }

        // Parse alias
        let loc = self.cur_loc();
        let alias = self.expect_identifier()?;

        Ok(Stmt::Import { path, alias, loc })
    }

    fn method_declaration(&mut self, export: bool) -> Result<Stmt, ParserError> {
        // Parse method name
        let loc = self.cur_loc();
        let method_name = self.expect_identifier()?;

        // Expect '('
        self.consume(TokenType::LParen, "Expected '(' after method name")?;

        // Parse parameters
        let mut params = Vec::new();

        if !self.check(&TokenType::RParen) {
            loop {
                // Parse optional type qualifier (const, input, simple, series)
                let type_qualifier = self.parse_optional_type_qualifier();

                // Parse optional type annotation
                let type_annotation = self.parse_optional_type_annotation();

                // Parse parameter name
                let param_loc = self.cur_loc();
                let param_name = self.expect_identifier()?;

                // Parse optional default value
                let default_value = if self.match_token(&[TokenType::Assign]) {
                    Some(self.expression()?)
                } else {
                    None
                };

                params.push(pine_ast::MethodParam {
                    type_qualifier,
                    type_annotation,
                    name: param_name,
                    default_value,
                    loc: param_loc,
                });

                if !self.match_token(&[TokenType::Comma]) {
                    break;
                }
            }
        }

        self.consume(TokenType::RParen, "Expected ')' after parameters")?;

        // Expect '=>'
        self.consume(TokenType::Arrow, "Expected '=>' after method parameters")?;

        // Skip optional newline after =>
        self.match_token(&[TokenType::Newline]);

        // Parse method body (can be a block or single expression)
        let body = self.parse_block()?;

        Ok(Stmt::MethodDecl {
            name: method_name,
            params,
            body,
            export,
            loc,
        })
    }

    fn typed_var_declaration(
        &mut self,
        type_annotation: Option<String>,
        var_kind: VarKind,
    ) -> Result<Stmt, ParserError> {
        self.typed_var_declaration_with_qualifier(None, type_annotation, var_kind)
    }

    fn typed_var_declaration_with_qualifier(
        &mut self,
        type_qualifier: Option<pine_ast::TypeQualifier>,
        type_annotation: Option<String>,
        var_kind: VarKind,
    ) -> Result<Stmt, ParserError> {
        let loc = self.cur_loc();
        let name = self.expect_identifier()?;

        let initializer = if self.match_token(&[TokenType::Assign]) {
            Some(self.parse_indented_expression()?)
        } else {
            None
        };

        Ok(Stmt::VarDecl {
            name,
            type_qualifier,
            type_annotation,
            initializer,
            var_kind,
            loc,
        })
    }

    fn statement(&mut self) -> Result<Stmt, ParserError> {
        // Check for export statement
        if self.match_token(&[TokenType::Export]) {
            return self.export_statement();
        }

        // Check for import statement
        if self.match_token(&[TokenType::Import]) {
            return self.import_statement();
        }

        // Check for if statement
        if self.match_token(&[TokenType::If]) {
            return self.if_statement();
        }

        // Check for for loop
        if self.match_token(&[TokenType::For]) {
            return self.for_statement();
        }

        // Check for while loop
        if self.match_token(&[TokenType::While]) {
            return self.while_statement();
        }

        // Check for break
        if self.match_token(&[TokenType::Break]) {
            return Ok(Stmt::Break {
                loc: self.prev_loc(),
            });
        }

        // Check for continue
        if self.match_token(&[TokenType::Continue]) {
            return Ok(Stmt::Continue {
                loc: self.prev_loc(),
            });
        }

        // Check for tuple destructuring: [a, b, c] = func()
        // But only if followed by = (otherwise it's an array literal)
        if self.check(&TokenType::LBracket) {
            let tuple_loc = self.cur_loc();
            if let Some((names, value)) = self.try_parse(|p| {
                p.advance(); // consume [

                let mut names = vec![];

                // Parse identifiers separated by commas
                if !p.check(&TokenType::RBracket) {
                    loop {
                        if let TokenType::Ident(name) = &p.peek().typ {
                            names.push(name.clone());
                            p.advance();
                        } else {
                            // Not all identifiers, not tuple destructuring
                            return Err(p.error(ParserErrorKind::ExpectedVariableName));
                        }

                        if !p.match_token(&[TokenType::Comma]) {
                            break;
                        }
                    }
                }

                p.consume(TokenType::RBracket, "Expected ']' in tuple destructuring")?;
                p.consume(TokenType::Assign, "Expected '=' after tuple pattern")?;

                // Skip newlines after =
                p.skip_newlines();

                let value = p.expression()?;

                Ok((names, value))
            }) {
                return Ok(Stmt::TupleAssignment {
                    names,
                    value,
                    loc: tuple_loc,
                });
            }
        }

        // Check for implicit variable declaration, reassignment, or function definition
        // name = expr (declaration)
        // name := expr (reassignment)
        // name(params) => body (function definition)
        if let TokenType::Ident(name) = &self.peek().typ {
            let name = name.clone();
            let name_loc = self.cur_loc();

            // Check for function definition: name(params) =>
            if let Some((param_structs, body)) = self.try_parse(|p| {
                p.advance(); // consume identifier
                p.consume(TokenType::LParen, "Expected '('")?;

                let params = p.function_params()?;
                p.consume(TokenType::RParen, "Expected ')' after function parameters")?;
                p.consume(TokenType::Arrow, "Expected '=>'")?;

                // Skip optional newline after =>
                p.match_token(&[TokenType::Newline]);

                // Parse function body (can be a block or single expression)
                let body = p.parse_block()?;

                Ok((params, body))
            }) {
                // Use the full FunctionParam structs for Expr::Function
                let initializer = Some(Expr::Function {
                    params: param_structs,
                    body,
                });
                return Ok(Stmt::VarDecl {
                    name,
                    type_qualifier: None,
                    type_annotation: None,
                    initializer,
                    var_kind: VarKind::Plain,
                    loc: name_loc,
                });
            }

            // Try to parse as assignment/declaration
            if let Some(stmt) = self.try_parse(|p| {
                p.advance(); // consume identifier

                if p.match_token(&[TokenType::Assign]) {
                    // This is an assignment with =, treat it as a var declaration
                    let initializer = Some(p.parse_indented_expression()?);

                    Ok(Stmt::VarDecl {
                        name: name.clone(),
                        type_qualifier: None,
                        type_annotation: None,
                        initializer,
                        var_kind: VarKind::Plain,
                        loc: name_loc,
                    })
                } else if p.match_token(&[TokenType::ColonAssign]) {
                    // This is a reassignment with :=
                    let value = p.parse_indented_expression()?;

                    Ok(Stmt::Assignment {
                        target: Expr::Variable {
                            name: name.clone(),
                            loc: name_loc,
                        },
                        value,
                    })
                } else if p.match_token(&[
                    TokenType::PlusAssign,
                    TokenType::MinusAssign,
                    TokenType::StarAssign,
                    TokenType::SlashAssign,
                ]) {
                    // Compound assignment: x += 5 is equivalent to x := x + 5
                    let op_tok = &p.tokens[p.current - 1];
                    let op_loc = Loc::new(op_tok.line as u32, op_tok.column as u32);
                    let op = op_tok
                        .typ
                        .to_binop()
                        .expect("compound assign token should convert to binop");

                    let right = p.parse_indented_expression()?;

                    let value = Expr::Binary {
                        left: Box::new(Expr::Variable {
                            name: name.clone(),
                            loc: name_loc,
                        }),
                        op,
                        right: Box::new(right),
                        loc: op_loc,
                    };
                    Ok(Stmt::Assignment {
                        target: Expr::Variable {
                            name: name.clone(),
                            loc: name_loc,
                        },
                        value,
                    })
                } else {
                    // Not an assignment operator, fail
                    Err(p.unexpected())
                }
            }) {
                return Ok(stmt);
            }
        }

        self.expression_statement()
    }

    fn function_params(&mut self) -> Result<Vec<pine_ast::FunctionParam>, ParserError> {
        self.parse_comma_separated(&TokenType::RParen, |p| {
            // Parse optional type qualifier (const, input, simple, series)
            let type_qualifier = p.parse_optional_type_qualifier();

            // Parse optional type annotation
            let type_annotation = p.parse_optional_type_annotation();

            let param_loc = p.cur_loc();
            let name = p.expect_identifier()?;

            // Check for default value: param = value
            let default_value = if p.match_token(&[TokenType::Assign]) {
                Some(p.expression()?)
            } else {
                None
            };

            Ok(pine_ast::FunctionParam {
                type_qualifier,
                type_annotation,
                name,
                default_value,
                loc: param_loc,
            })
        })
    }

    fn for_statement(&mut self) -> Result<Stmt, ParserError> {
        // Check if it's a tuple form: for [index, item] in collection
        if self.check(&TokenType::LBracket) {
            self.advance(); // consume [

            let loc = self.cur_loc();
            let index_var = self.expect_identifier()?;

            self.consume(TokenType::Comma, "Expected ',' in for...in tuple")?;

            let item_var = self.expect_identifier()?;

            self.consume(TokenType::RBracket, "Expected ']' after for...in tuple")?;
            self.consume(TokenType::In, "Expected 'in' in for...in loop")?;

            let collection = self.expression()?;

            // Skip optional newline
            self.match_token(&[TokenType::Newline]);

            let body = self.parse_block()?;

            return Ok(Stmt::ForIn {
                index_var: Some(index_var),
                item_var,
                collection,
                body,
                loc,
            });
        }

        // Parse variable name
        let loc = self.cur_loc();
        let var_name = self.expect_identifier()?;

        // Check if it's for...in (simple form) or for...to
        if self.check(&TokenType::In) {
            self.advance(); // consume 'in'

            let collection = self.expression()?;

            // Skip optional newline
            self.match_token(&[TokenType::Newline]);

            let body = self.parse_block()?;

            Ok(Stmt::ForIn {
                index_var: None,
                item_var: var_name,
                collection,
                body,
                loc,
            })
        } else {
            // Traditional for...to loop
            self.consume(TokenType::Assign, "Expected '=' in for loop")?;
            let from = self.expression()?;
            self.consume(TokenType::To, "Expected 'to' in for loop")?;
            let to = self.expression()?;

            // Optional `by <step>`. `by` is a contextual keyword (not lexed as
            // one), so match it as an identifier here.
            let step = if matches!(&self.peek().typ, TokenType::Ident(name) if name == "by") {
                self.advance(); // consume 'by'
                Some(self.expression()?)
            } else {
                None
            };

            // Skip optional newline after to/step
            self.match_token(&[TokenType::Newline]);

            // Parse the body - multiple statements
            let body = self.parse_block()?;

            Ok(Stmt::For {
                var_name,
                from,
                to,
                step,
                body,
                loc,
            })
        }
    }

    fn while_statement(&mut self) -> Result<Stmt, ParserError> {
        // Parse: while condition
        let condition = self.expression()?;

        // Skip optional newline after condition
        self.match_token(&[TokenType::Newline]);

        // Parse the body - multiple statements
        let body = self.parse_block()?;

        Ok(Stmt::While { condition, body })
    }

    fn if_statement(&mut self) -> Result<Stmt, ParserError> {
        // Parse the condition (no parentheses required in PineScript)
        let condition = self.expression()?;

        // Skip optional newline after condition
        self.match_token(&[TokenType::Newline]);

        // Parse the then branch - multiple statements until we hit 'else', dedent, or certain keywords
        let then_branch = self.parse_block()?;

        // Parse else if branches
        let mut else_if_branches = Vec::new();

        loop {
            // Skip any newlines before else
            self.skip_newlines();

            // Check if we have "else if"
            if self.check(&TokenType::Else) {
                if let Some((else_if_condition, else_if_body)) = self.try_parse(|p| {
                    p.advance(); // consume 'else'
                                 // Check if next token is 'if'
                    if p.match_token(&[TokenType::If]) {
                        // This is an else if
                        let else_if_condition = p.expression()?;
                        p.match_token(&[TokenType::Newline]);
                        let else_if_body = p.parse_block()?;
                        Ok((else_if_condition, else_if_body))
                    } else {
                        Err(p.unexpected())
                    }
                }) {
                    else_if_branches.push((else_if_condition, else_if_body));
                } else {
                    break;
                }
            } else {
                break;
            }
        }

        // Check for final else branch
        self.skip_newlines();

        let else_branch = if self.match_token(&[TokenType::Else]) {
            // Skip optional newline after else
            self.match_token(&[TokenType::Newline]);

            Some(self.parse_block()?)
        } else {
            None
        };

        Ok(Stmt::If {
            condition,
            then_branch,
            else_if_branches,
            else_branch,
        })
    }

    fn if_expression(&mut self) -> Result<Expr, ParserError> {
        // Consume 'if' token
        self.consume(TokenType::If, "Expected 'if'")?;

        // Parse the condition
        let condition = self.expression()?;

        // Skip optional newline after condition
        self.match_token(&[TokenType::Newline]);

        // Skip optional indent
        self.match_token(&[TokenType::Indent]);

        // Parse the then expression (single expression, not a block of statements)
        let then_expr = self.expression()?;

        // Skip newlines and dedent
        self.skip_newlines();
        self.match_token(&[TokenType::Dedent]);

        // Parse else if branches
        let mut else_if_branches = Vec::new();

        loop {
            // Skip any newlines before else
            self.skip_newlines();

            // Check if we have "else if"
            if self.check(&TokenType::Else) {
                if let Some((else_if_condition, else_if_expr)) = self.try_parse(|p| {
                    p.advance(); // consume 'else'
                                 // Check if next token is 'if'
                    if p.match_token(&[TokenType::If]) {
                        // This is an else if
                        let else_if_condition = p.expression()?;
                        p.match_token(&[TokenType::Newline]);
                        p.match_token(&[TokenType::Indent]);
                        let else_if_expr = p.expression()?;
                        p.skip_newlines();
                        p.match_token(&[TokenType::Dedent]);
                        Ok((else_if_condition, else_if_expr))
                    } else {
                        Err(p.unexpected())
                    }
                }) {
                    else_if_branches.push((else_if_condition, else_if_expr));
                } else {
                    break;
                }
            } else {
                break;
            }
        }

        // Parse final else branch (optional - if not present, returns na)
        self.skip_newlines();
        let else_expr = if self.match_token(&[TokenType::Else]) {
            // Skip optional newline after else
            self.match_token(&[TokenType::Newline]);

            // Skip optional indent
            self.match_token(&[TokenType::Indent]);

            // Parse else expression
            let expr = self.expression()?;

            // Skip newlines and optional dedent
            self.skip_newlines();
            self.match_token(&[TokenType::Dedent]);

            Some(Box::new(expr))
        } else {
            None // Will return na if no branch matches
        };

        Ok(Expr::IfExpr {
            condition: Box::new(condition),
            then_expr: Box::new(then_expr),
            else_if_branches,
            else_expr,
        })
    }

    fn parse_block(&mut self) -> Result<Vec<Stmt>, ParserError> {
        let mut stmts = vec![];

        // Expect an indent token to start the block
        if !self.match_token(&[TokenType::Indent]) {
            // No indent means single-line block or empty block
            // Try to parse a single statement on the same line
            if !self.check(&TokenType::Newline)
                && !self.check(&TokenType::Else)
                && !self.is_at_end()
            {
                stmts.push(self.declaration()?);
            }
            return Ok(stmts);
        }

        // Parse statements until we hit a dedent
        loop {
            // Skip leading newlines
            self.skip_newlines();

            // Check for else (which ends the then branch)
            if self.check(&TokenType::Else) {
                break;
            }

            // Check for end of block
            if self.check(&TokenType::Dedent) {
                self.advance(); // consume the dedent

                // Check if else follows the dedent
                self.skip_newlines();
                if self.check(&TokenType::Else) {
                    break;
                }

                // If not else, we're truly done
                break;
            }

            // Stop at EOF
            if self.is_at_end() {
                break;
            }

            // Parse a statement
            stmts.push(self.declaration()?);
        }

        Ok(stmts)
    }

    fn expression_statement(&mut self) -> Result<Stmt, ParserError> {
        let expr = self.expression()?;

        // Check if this is an assignment statement (e.g., obj.field := value)
        if self.match_token(&[TokenType::ColonAssign]) {
            let value = self.parse_indented_expression()?;
            return Ok(Stmt::Assignment {
                target: expr,
                value,
            });
        }

        Ok(Stmt::Expression(expr))
    }

    // Expression parsing with precedence
    fn expression(&mut self) -> Result<Expr, ParserError> {
        self.ternary()
    }

    /// Generic binary operator parser using left-associativity
    fn binary_left_assoc(
        &mut self,
        operators: &[TokenType],
        next_precedence: fn(&mut Self) -> Result<Expr, ParserError>,
    ) -> Result<Expr, ParserError> {
        let mut expr = next_precedence(self)?;

        loop {
            // Skip newlines before operators (for leading operators on continuation lines)
            self.skip_newlines();

            if !self.match_token(operators) {
                break;
            }

            let op_tok = &self.tokens[self.current - 1];
            let op_loc = Loc::new(op_tok.line as u32, op_tok.column as u32);
            let op = op_tok
                .typ
                .to_binop()
                .expect("matched operator token should convert to binop");

            // Skip newlines after binary operators (for multi-line expressions)
            self.skip_newlines_and_indent();

            let right = next_precedence(self)?;
            expr = Expr::Binary {
                left: Box::new(expr),
                op,
                right: Box::new(right),
                loc: op_loc,
            };
        }

        Ok(expr)
    }

    fn ternary(&mut self) -> Result<Expr, ParserError> {
        // Check for if expression first
        if self.check(&TokenType::If) {
            return self.if_expression();
        }

        let mut expr = self.logical_or()?;

        // Skip newlines before '?' for multi-line ternaries
        self.skip_newlines();

        // Skip indent if followed by '?' (for multiline ternaries)
        self.try_consume_indent_if_followed_by(&TokenType::Question);

        if self.match_token(&[TokenType::Question]) {
            // Skip newlines after '?'
            self.skip_newlines_and_indent();

            let then_expr = self.expression()?;

            // Skip newlines before ':'
            self.skip_newlines();

            // Skip indent if followed by ':' (for multiline ternaries)
            self.try_consume_indent_if_followed_by(&TokenType::Colon);

            self.consume(TokenType::Colon, "Expected ':' in ternary expression")?;

            // Skip newlines after ':'
            self.skip_newlines_and_indent();

            let else_expr = self.expression()?;
            expr = Expr::Ternary {
                condition: Box::new(expr),
                then_expr: Box::new(then_expr),
                else_expr: Box::new(else_expr),
            };
        }

        Ok(expr)
    }

    fn logical_or(&mut self) -> Result<Expr, ParserError> {
        self.binary_left_assoc(&[TokenType::Or], Self::logical_and)
    }

    fn logical_and(&mut self) -> Result<Expr, ParserError> {
        self.binary_left_assoc(&[TokenType::And], Self::equality)
    }

    fn equality(&mut self) -> Result<Expr, ParserError> {
        self.binary_left_assoc(&[TokenType::Equal, TokenType::NotEqual], Self::comparison)
    }

    fn comparison(&mut self) -> Result<Expr, ParserError> {
        self.binary_left_assoc(
            &[
                TokenType::Greater,
                TokenType::Less,
                TokenType::GreaterEqual,
                TokenType::LessEqual,
            ],
            Self::term,
        )
    }

    fn term(&mut self) -> Result<Expr, ParserError> {
        let mut expr = self.factor()?;

        loop {
            // Skip newlines before operators (for leading operators on continuation lines)
            self.skip_newlines();

            // Skip indent/dedent if followed by an operator (for leading operators on continuation lines)
            self.try_consume_layout_token_if_followed_by(&[TokenType::Plus, TokenType::Minus]);

            if !self.match_token(&[TokenType::Plus, TokenType::Minus]) {
                break;
            }

            let op_tok = &self.tokens[self.current - 1];
            let op_loc = Loc::new(op_tok.line as u32, op_tok.column as u32);
            let op = op_tok
                .typ
                .to_binop()
                .expect("term token should convert to binop");
            // Skip newlines after binary operators (for multi-line expressions)
            self.skip_newlines_and_indent();
            let right = self.factor()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                op,
                right: Box::new(right),
                loc: op_loc,
            };
        }

        Ok(expr)
    }

    fn factor(&mut self) -> Result<Expr, ParserError> {
        self.binary_left_assoc(
            &[TokenType::Star, TokenType::Slash, TokenType::Percent],
            Self::unary,
        )
    }

    fn unary(&mut self) -> Result<Expr, ParserError> {
        if self.match_token(&[TokenType::Minus]) {
            let expr = self.unary()?;
            return Ok(Expr::Unary {
                op: UnOp::Neg,
                expr: Box::new(expr),
            });
        }

        if self.match_token(&[TokenType::Not]) {
            let expr = self.unary()?;
            return Ok(Expr::Unary {
                op: UnOp::Not,
                expr: Box::new(expr),
            });
        }

        self.postfix()
    }

    fn postfix(&mut self) -> Result<Expr, ParserError> {
        let mut expr = self.primary()?;

        // A `switch`/`if` block expression spans lines and terminates the
        // expression. A following `[`/`.`/`(` begins a new statement, not a
        // postfix operator on the block's result (its trailing NEWLINE/DEDENT
        // has already been consumed, so the loop below can't see the boundary).
        if matches!(expr, Expr::Switch { .. } | Expr::IfExpr { .. }) {
            return Ok(expr);
        }

        loop {
            if self.match_token(&[TokenType::Dot]) {
                // Member access: expr.member
                // Allow keywords as member names (e.g., input.int, color.new)
                let member = match &self.peek().typ {
                    TokenType::Ident(name) => {
                        let name = name.clone();
                        self.advance();
                        name
                    }
                    TokenType::Int => {
                        self.advance();
                        "int".to_string()
                    }
                    TokenType::Float => {
                        self.advance();
                        "float".to_string()
                    }
                    _ => {
                        // Try to use the lexeme if it's a keyword
                        let lexeme = self.peek().lexeme.clone();
                        if !lexeme.is_empty() {
                            self.advance();
                            lexeme
                        } else {
                            return Err(self.error(ParserErrorKind::ExpectedIdentifierAfterDot));
                        }
                    }
                };
                let member_loc = self.prev_loc();
                expr = Expr::MemberAccess {
                    object: Box::new(expr),
                    member,
                    member_loc,
                };
            } else if self.match_token(&[TokenType::LBracket]) {
                // Historical reference: expr[index]
                let index = self.expression()?;
                self.consume(TokenType::RBracket, "Expected ']'")?;
                expr = Expr::Index {
                    expr: Box::new(expr),
                    index: Box::new(index),
                    id: self.next_call_id(),
                };
            } else if self.check(&TokenType::Less) {
                // Try to parse type arguments: <type>
                // This is tricky because < can also be a comparison operator
                // We use try_parse to backtrack if it's not actually type args
                let type_args = self.try_parse_type_args().unwrap_or_default();

                // After type args, we must have a function call
                if self.match_token(&[TokenType::LParen]) {
                    let lparen = &self.tokens[self.current - 1];
                    let call_loc = Loc::new(lparen.line as u32, lparen.column as u32);
                    let id = self.next_call_id();
                    let args = self.arguments()?;
                    self.consume(TokenType::RParen, "Expected ')'")?;
                    expr = Expr::Call {
                        callee: Box::new(expr),
                        type_args,
                        args,
                        id,
                        loc: call_loc,
                    };
                } else {
                    // Not a function call, just break
                    break;
                }
            } else if self.match_token(&[TokenType::LParen]) {
                // Function call without type arguments
                let lparen = &self.tokens[self.current - 1];
                let call_loc = Loc::new(lparen.line as u32, lparen.column as u32);
                let id = self.next_call_id();
                let args = self.arguments()?;
                self.consume(TokenType::RParen, "Expected ')'")?;
                expr = Expr::Call {
                    callee: Box::new(expr),
                    type_args: vec![],
                    args,
                    id,
                    loc: call_loc,
                };
            } else {
                break;
            }
        }

        Ok(expr)
    }

    fn arguments(&mut self) -> Result<Vec<Argument>, ParserError> {
        let mut args = vec![];

        if !self.check(&TokenType::RParen) {
            loop {
                // Check for named argument: name=value
                // In PineScript, function calls can have named arguments like plot(x, title="foo", color=red)
                // `type` is a keyword (v5 UDTs) but is also v3/v4's `input(..., type=...)`
                // parameter name, so accept it as a key too.
                let key_name = match &self.peek().typ {
                    TokenType::Ident(name) => Some(name.clone()),
                    TokenType::Type => Some("type".to_string()),
                    _ => None,
                };
                if let Some(name) = key_name {
                    if let Some((name, value)) = self.try_parse(|p| {
                        p.advance(); // consume identifier
                        if p.check(&TokenType::Assign) {
                            // This is a named argument
                            p.advance(); // consume =
                            let value = p.expression()?;
                            Ok((name.clone(), value))
                        } else {
                            Err(p.unexpected())
                        }
                    }) {
                        args.push(Argument::Named { name, value });
                    } else {
                        // Not a named argument, parse as expression
                        let expr = self.expression()?;
                        args.push(Argument::Positional(expr));
                    }
                } else {
                    let expr = self.expression()?;
                    args.push(Argument::Positional(expr));
                }

                if !self.match_token(&[TokenType::Comma]) {
                    break;
                }
            }
        }

        Ok(args)
    }

    fn primary(&mut self) -> Result<Expr, ParserError> {
        if let TokenType::IntLiteral(n) = self.peek().typ {
            self.advance();
            return Ok(Expr::Literal(Literal::Int(n)));
        }

        if let TokenType::Number(n) = self.peek().typ {
            self.advance();
            return Ok(Expr::Literal(Literal::Number(n)));
        }

        if let TokenType::String(ref s) = self.peek().typ {
            let s = s.clone();
            self.advance();
            return Ok(Expr::Literal(Literal::String(s)));
        }

        if let TokenType::Bool(b) = self.peek().typ {
            self.advance();
            return Ok(Expr::Literal(Literal::Bool(b)));
        }

        if let TokenType::HexColor(ref hex) = self.peek().typ {
            let hex = hex.clone();
            self.advance();
            return Ok(Expr::Literal(Literal::HexColor(hex)));
        }

        // Handle na as a literal
        if self.match_token(&[TokenType::Na]) {
            return Ok(Expr::Literal(Literal::Na));
        }

        // Handle keywords that can be used as identifiers (int, float)
        // These can be function names (e.g., int(), float())
        if self.match_token(&[TokenType::Int, TokenType::Float]) {
            let name = self.tokens[self.current - 1].lexeme.clone();
            return Ok(Expr::Variable {
                name,
                loc: self.prev_loc(),
            });
        }

        if let TokenType::Ident(ref name) = self.peek().typ {
            let name = name.clone();
            let loc = self.cur_loc();
            self.advance();
            return Ok(Expr::Variable { name, loc });
        }

        if self.match_token(&[TokenType::LParen]) {
            // Skip newlines and indents after opening parenthesis for multiline expressions
            self.skip_newlines();
            let had_indent = self.match_token(&[TokenType::Indent]);

            let expr = self.expression()?;

            // Skip newlines and consume dedent if we had indent
            self.skip_newlines();
            if had_indent {
                self.match_token(&[TokenType::Dedent]);
            }

            self.consume(TokenType::RParen, "Expected ')'")?;
            return Ok(expr);
        }

        // Switch expression: switch value \n case => result
        if self.match_token(&[TokenType::Switch]) {
            // The subjectless form (`switch` with boolean arms) has no expression
            // after the keyword — just a newline. Treat it as `switch true`, so an
            // arm matches when its condition evaluates to `true`.
            let value = if self.check(&TokenType::Newline) {
                Box::new(Expr::Literal(Literal::Bool(true)))
            } else {
                Box::new(self.expression()?)
            };

            // Skip newline after switch value
            self.match_token(&[TokenType::Newline]);

            // Skip indent for switch block
            let has_indent = self.match_token(&[TokenType::Indent]);

            let mut cases = vec![];

            // Parse cases until we can't parse any more
            loop {
                // Skip leading newlines
                self.skip_newlines();

                // Check for dedent (end of switch block)
                if self.check(&TokenType::Dedent) {
                    if has_indent {
                        self.advance(); // consume dedent
                    }
                    break;
                }

                // Check if we're done (end of block or EOF)
                if self.is_at_end() {
                    break;
                }

                // Check for default case: => result (no pattern)
                if self.match_token(&[TokenType::Arrow]) {
                    // Skip newlines after =>
                    self.skip_newlines();

                    // Parse the result expression
                    let result = self.expression()?;

                    // Use a special "default" literal as the pattern
                    let default_pattern = Expr::Literal(Literal::Bool(true));
                    cases.push((default_pattern, result));
                    continue;
                }

                // Try to parse a case
                if let Some((pattern, result)) = self.try_parse(|p| {
                    // Parse the pattern (could be a string, number, identifier, etc.)
                    let pattern = p.expression()?;

                    // Expect =>
                    if !p.match_token(&[TokenType::Arrow]) {
                        return Err(p.unexpected());
                    }

                    // Skip newlines after =>
                    p.skip_newlines();

                    // Parse the result expression
                    let result = p.expression()?;
                    Ok((pattern, result))
                }) {
                    cases.push((pattern, result));
                } else {
                    break;
                }
            }

            return Ok(Expr::Switch { value, cases });
        }

        // Array literal: [1, 2, 3]
        if self.match_token(&[TokenType::LBracket]) {
            // Skip leading newlines
            self.skip_newlines_and_indent();

            let elements = self.parse_comma_separated(&TokenType::RBracket, |p| p.expression())?;

            // Skip trailing newlines and dedent
            self.skip_newlines_and_dedent();

            self.consume(TokenType::RBracket, "Expected ']'")?;
            return Ok(Expr::Array(elements));
        }

        Err(self.unexpected())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pine_lexer::Lexer;

    fn parse_expr(input: &str) -> eyre::Result<Expr> {
        let mut lexer = Lexer::new(input);
        let tokens = lexer.tokenize()?;
        let mut parser = Parser::new(tokens);
        let stmts = parser.parse()?;

        if let Some(Stmt::Expression(expr)) = stmts.first() {
            Ok(expr.clone())
        } else {
            Err(eyre::eyre!("Expected expression statement".to_string()))
        }
    }

    #[test]
    fn test_literals() {
        // Numbers
        let expr = parse_expr("42").unwrap();
        assert_eq!(expr, Expr::Literal(Literal::Int(42)));

        // Strings
        let expr = parse_expr(r#""hello""#).unwrap();
        assert_eq!(expr, Expr::Literal(Literal::String("hello".to_string())));

        // Booleans
        let expr = parse_expr("true").unwrap();
        assert_eq!(expr, Expr::Literal(Literal::Bool(true)));
    }

    #[test]
    fn test_variables() {
        let expr = parse_expr("close").unwrap();
        assert_eq!(expr, Expr::var("close"));

        let expr = parse_expr("my_var").unwrap();
        assert_eq!(expr, Expr::var("my_var"));
    }

    #[test]
    fn test_historical_references() {
        // close[1] - previous close
        let expr = parse_expr("close[1]").unwrap();
        assert!(matches!(expr, Expr::Index { .. }));
        if let Expr::Index {
            expr: base, index, ..
        } = expr
        {
            assert_eq!(*base, Expr::var("close"));
            assert_eq!(*index, Expr::Literal(Literal::Int(1)));
        }

        // high[5] - 5 bars ago
        let expr = parse_expr("high[5]").unwrap();
        if let Expr::Index {
            expr: base, index, ..
        } = expr
        {
            assert_eq!(*base, Expr::var("high"));
            assert_eq!(*index, Expr::Literal(Literal::Int(5)));
        }
    }

    #[test]
    fn test_function_calls() {
        // Simple function call
        let expr = parse_expr("sma(close, 14)").unwrap();
        if let Expr::Call {
            callee,
            type_args,
            args,
            ..
        } = expr
        {
            assert_eq!(*callee, Expr::var("sma"));
            assert_eq!(type_args.len(), 0);
            assert_eq!(args.len(), 2);
            assert_eq!(args[0], Argument::Positional(Expr::var("close")));
            assert_eq!(
                args[1],
                Argument::Positional(Expr::Literal(Literal::Int(14)))
            );
        } else {
            panic!("Expected function call");
        }

        // No arguments
        let expr = parse_expr("foo()").unwrap();
        if let Expr::Call {
            callee,
            type_args,
            args,
            ..
        } = expr
        {
            assert_eq!(*callee, Expr::var("foo"));
            assert_eq!(type_args.len(), 0);
            assert_eq!(args.len(), 0);
        }
    }

    #[test]
    fn test_arithmetic_expressions() {
        // Addition
        let expr = parse_expr("2 + 3").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::Literal(Literal::Int(2)));
            assert_eq!(op, BinOp::Add);
            assert_eq!(*right, Expr::Literal(Literal::Int(3)));
        }

        // Multiplication has higher precedence: 2 + 3 * 4 = 2 + (3 * 4)
        let expr = parse_expr("2 + 3 * 4").unwrap();
        if let Expr::Binary {
            left,
            op: op1,
            right,
            ..
        } = expr
        {
            assert_eq!(*left, Expr::Literal(Literal::Int(2)));
            assert_eq!(op1, BinOp::Add);
            if let Expr::Binary {
                left: l2,
                op: op2,
                right: r2,
                ..
            } = *right
            {
                assert_eq!(*l2, Expr::Literal(Literal::Int(3)));
                assert_eq!(op2, BinOp::Mul);
                assert_eq!(*r2, Expr::Literal(Literal::Int(4)));
            }
        }

        // Division
        let expr = parse_expr("10 / 2").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::Literal(Literal::Int(10)));
            assert_eq!(op, BinOp::Div);
            assert_eq!(*right, Expr::Literal(Literal::Int(2)));
        }

        // Subtraction
        let expr = parse_expr("5 - 3").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::Literal(Literal::Int(5)));
            assert_eq!(op, BinOp::Sub);
            assert_eq!(*right, Expr::Literal(Literal::Int(3)));
        }
    }

    #[test]
    fn test_comparison_expressions() {
        // Greater than
        let expr = parse_expr("close > open").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::var("close"));
            assert_eq!(op, BinOp::Greater);
            assert_eq!(*right, Expr::var("open"));
        }

        // Less than
        let expr = parse_expr("rsi < 30").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::var("rsi"));
            assert_eq!(op, BinOp::Less);
            assert_eq!(*right, Expr::Literal(Literal::Int(30)));
        }

        // Equality
        let expr = parse_expr("x == 5").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(*left, Expr::var("x"));
            assert_eq!(op, BinOp::Eq);
            assert_eq!(*right, Expr::Literal(Literal::Int(5)));
        }
    }

    #[test]
    fn test_unary_expressions() {
        // Negation
        let expr = parse_expr("-5").unwrap();
        if let Expr::Unary { op, expr } = expr {
            assert_eq!(op, UnOp::Neg);
            assert_eq!(*expr, Expr::Literal(Literal::Int(5)));
        }

        // Double negation
        let expr = parse_expr("--10").unwrap();
        if let Expr::Unary { op: op1, expr: e1 } = expr {
            assert_eq!(op1, UnOp::Neg);
            if let Expr::Unary { op: op2, expr: e2 } = *e1 {
                assert_eq!(op2, UnOp::Neg);
                assert_eq!(*e2, Expr::Literal(Literal::Int(10)));
            }
        }
    }

    #[test]
    fn test_var_declarations() {
        let mut lexer = Lexer::new("var x = 10");
        let tokens = lexer.tokenize().unwrap();
        let mut parser = Parser::new(tokens);
        let stmts = parser.parse().unwrap();

        assert_eq!(stmts.len(), 1);
        if let Stmt::VarDecl {
            name,
            type_qualifier,
            type_annotation,
            initializer,
            var_kind,
            ..
        } = &stmts[0]
        {
            assert_eq!(name, "x");
            assert_eq!(*type_qualifier, None);
            assert_eq!(*type_annotation, None);
            assert_eq!(*var_kind, VarKind::Var, "var x = 10 must be Var");
            assert_eq!(
                initializer.as_ref().unwrap(),
                &Expr::Literal(Literal::Int(10))
            );
        } else {
            panic!("Expected VarDecl");
        }

        // Var without initializer
        let mut lexer = Lexer::new("var y");
        let tokens = lexer.tokenize().unwrap();
        let mut parser = Parser::new(tokens);
        let stmts = parser.parse().unwrap();

        if let Stmt::VarDecl {
            name, initializer, ..
        } = &stmts[0]
        {
            assert_eq!(name, "y");
            assert!(initializer.is_none());
        }
    }

    #[test]
    fn test_pinescript_examples() {
        // PineScript: close[1] > close[2]
        let expr = parse_expr("close[1] > close[2]").unwrap();
        assert!(matches!(
            expr,
            Expr::Binary {
                op: BinOp::Greater,
                ..
            }
        ));

        // PineScript: sma(close, 14) > sma(close, 28)
        let expr = parse_expr("sma(close, 14) > sma(close, 28)").unwrap();
        if let Expr::Binary {
            left, op, right, ..
        } = expr
        {
            assert_eq!(op, BinOp::Greater);
            assert!(matches!(*left, Expr::Call { .. }));
            assert!(matches!(*right, Expr::Call { .. }));
        }

        // PineScript: (high + low) / 2
        let expr = parse_expr("(high + low) / 2").unwrap();
        if let Expr::Binary {
            left,
            op: div_op,
            right,
            ..
        } = expr
        {
            assert_eq!(div_op, BinOp::Div);
            assert!(matches!(*left, Expr::Binary { op: BinOp::Add, .. }));
            assert_eq!(*right, Expr::Literal(Literal::Int(2)));
        }
    }

    /// Helper function to recursively collect all .pine files in a directory
    fn collect_pine_files_recursive(dir: &std::path::Path) -> Vec<std::path::PathBuf> {
        walkdir::WalkDir::new(dir)
            .into_iter()
            .filter_map(|e| e.ok())
            .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("pine"))
            .map(|e| e.path().to_path_buf())
            .collect()
    }

    #[test]
    fn test_parse_testdata_files() -> eyre::Result<()> {
        use std::fs;
        use std::path::Path;

        let testdata_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata");

        let filter = std::env::var("TEST_FILE").ok();
        let debug = std::env::var("DEBUG").is_ok();
        let generate_ast = std::env::var("GENERATE_AST").is_ok();

        let pine_files = collect_pine_files_recursive(&testdata_dir);

        let process_file = |path: &std::path::PathBuf| -> eyre::Result<()> {
            let content = fs::read_to_string(path)?;

            let mut lexer = Lexer::new(&content);
            let tokens = lexer.tokenize()?;

            if debug {
                println!("Tokens: {:#?}", tokens);
            }

            let mut parser = Parser::new(tokens);
            let ast = parser.parse()?;

            if debug {
                let ast_json = serde_json::to_string(&ast)?;
                println!("AST JSON: {:?}", ast_json);
            }

            // Check for corresponding _ast.json file
            let json_path = path.with_file_name(format!(
                "{}_ast.json",
                path.file_stem().unwrap().to_str().unwrap()
            ));

            if generate_ast {
                // Generate/overwrite AST JSON file
                let json = serde_json::to_string_pretty(&ast)?;
                fs::write(&json_path, &json)?;
            } else if json_path.exists() {
                // Compare with expected AST
                let expected_json = fs::read_to_string(&json_path)?;
                let expected_ast: Vec<Stmt> = serde_json::from_str(&expected_json)?;

                if ast != expected_ast {
                    return Err(eyre::eyre!(
                        "AST mismatch, expected AST from {:?}",
                        json_path
                    ));
                }
            }

            Ok(())
        };

        for path in pine_files {
            let filename = path.file_name().unwrap().to_str().unwrap();

            // Skip if filter is set and doesn't match
            if let Some(ref filter_name) = filter {
                if filename != filter_name {
                    continue;
                }
            }

            if let Err(e) = process_file(&path) {
                return Err(eyre::eyre!("Failed to process {}: {}", filename, e));
            }
        }

        Ok(())
    }

    #[test]
    #[ignore]
    fn test_parse_external_pinescript_indicators() -> eyre::Result<()> {
        use std::fs;
        use std::path::Path;

        let testdata_dir =
            Path::new(env!("CARGO_MANIFEST_DIR")).join("tradingview-pinescript-indicators");

        let filter = std::env::var("TEST_FILE").ok();
        let debug = std::env::var("DEBUG").is_ok();

        let pine_files = collect_pine_files_recursive(&testdata_dir);

        let process_file = |path: &std::path::PathBuf| -> eyre::Result<()> {
            let content = fs::read_to_string(path)?;

            let mut lexer = Lexer::new(&content);
            let tokens = lexer.tokenize()?;

            if debug {
                println!("Tokens: {:#?}", tokens);
            }

            let mut parser = Parser::new(tokens);
            let ast = parser.parse()?;

            let ast_json = serde_json::to_string(&ast)?;

            if debug {
                println!("AST JSON: {:?}", ast_json);
            }

            Ok(())
        };

        for path in pine_files {
            let filename = path.file_name().unwrap().to_str().unwrap();

            // Skip if filter is set and doesn't match
            if let Some(ref filter_name) = filter {
                if filename != filter_name {
                    continue;
                }
            }

            if let Err(e) = process_file(&path) {
                return Err(eyre::eyre!("Failed to process {}: {}", filename, e));
            }
        }

        Ok(())
    }
}