//! Type-related parsing - minimal version with only used functions

use super::{ParserState, *};

pub fn parse_struct_literal(

    state: &mut ParserState,

    name: String,

    start_span: Span,

) -> Result<Expr> {

    state.tokens.expect(&Token::LeftBrace)
?0
;

    let mut fields = Vec::new();

    while !matches!(state.tokens.peek(), Some((Token::RightBrace, _))) {

        // Parse field name

        let field_name = if let Some((Token::Identifier(name), _)) = state.tokens.peek() {

            let name = name.clone();

            state.tokens.advance();

            name

        } else {

            bail!("Expected field name");

        };

        // Parse colon and value

        state.tokens.expect(&Token::Colon)
?0
;

        let value = super::parse_expr_recursive(state)
?0
;

        fields.push((field_name, value));

        // Handle comma or end of struct literal

        if 
matches!1
(state.tokens.peek(), Some((Token::Comma, _))) {

            state.tokens.advance();

        } else {

            break;

        }

    }

    state.tokens.expect(&Token::RightBrace)
?0
;

    Ok(Expr::new(

        ExprKind::StructLiteral { name, fields },

        start_span,

    ))

}