Function path_constructor

graphlite/src/ast/parser.rs:1995–2042

Parse PATH constructor: PATH[expr1, expr2, ...] or PATH + vector

(tokens: &[Token])

/// Parse PATH constructor: PATH[expr1, expr2, ...] or PATH + vector
fn path_constructor(tokens: &[Token]) -> IResult<&[Token], PathConstructor> {
    let (tokens, _) = expect_token(Token::Path)(tokens)?;

    // Handle case where lexer parsed brackets with numbers as a vector literal
    if let Some(Token::Vector(values)) = tokens.first() {
        let (tokens, _) = expect_token_variant(&|t| matches!(t, Token::Vector(_)))(tokens)?;

        // Convert vector values to literal expressions
        let elements = values
            .iter()
            .map(|&v| Expression::Literal(crate::ast::Literal::Float(v)))
            .collect();

        return Ok((
            tokens,
            PathConstructor {
                elements,
                location: Location::default(),
            },
        ));
    }

    let (tokens, _) = expect_token(Token::LeftBracket)(tokens)?;

    // Check for empty PATH[]
    if matches!(tokens.first(), Some(Token::RightBracket)) {
        let (tokens, _) = expect_token(Token::RightBracket)(tokens)?;
        return Ok((
            tokens,
            PathConstructor {
                elements: vec![],
                location: Location::default(),
            },
        ));
    }

    // Parse expressions
    let (tokens, elements) = expression_list(tokens)?;
    let (tokens, _) = expect_token(Token::RightBracket)(tokens)?;

    Ok((
        tokens,
        PathConstructor {
            elements,
            location: Location::default(),
        },
    ))
}

/// Parse postfix expressions: primary_expr[index] | primary_expr
fn postfix_expression(tokens: &[Token]) -> IResult<&[Token], Expression> {