Function parse_struct

libs/@local/hashql/syntax-jexpr/src/parser/object/struct.rs:79–130

(
    state: &mut ParserState<'heap, '_, '_>,
)

}

fn parse_struct<'heap>(
    state: &mut ParserState<'heap, '_, '_>,
) -> Result<StructExpr<'heap>, ParserDiagnostic> {
    // We do not use expected here, to give the user a better error message
    let token = state
        .advance(Expected::hint(SyntaxKind::LBrace))
        .change_category(From::from)?;

    if token.kind.syntax() != SyntaxKind::LBrace {
        let span = state.insert_range(token.span);

        return Err(struct_expected_object(span, token.kind.syntax()))
            .change_category(From::from)?;
    }

    let mut entries = Vec::new();

    let span = visit_object(state, token, |state, key| {
        let key_span = state.insert_range(key.span);

        let ident = match parse_ident_from_string(state, key_span, &key.value) {
            Ok(ident) => ident,
            Err(error) => {
                let error = (error.offset(), error.into_inner());

                return Err(
                    struct_key_expected_identifier(state.spans(), key_span, error)
                        .map_category(From::from),
                );
            }
        };

        let value = parse_expr(state)?;
        let value_span = state.current_span();

        entries.push(StructEntry {
            id: NodeId::PLACEHOLDER,
            span: state.insert_range(key.span.cover(value_span)),
            key: ident,
            value: Box::new_in(value, state.heap()),
        });

        Ok(())
    })?;

    Ok(StructExpr {
        id: NodeId::PLACEHOLDER,
        span: state.insert_range(span),
        entries: entries.into_iter().collect_in(state.heap()),
        r#type: None,
    })
}

#[cfg(test)]
mod tests {