Function func_call

prqlc/prqlc-parser/src/parser/expr.rs:414–483

(expr: E)

}

fn func_call<'a, I, E>(expr: E) -> impl Parser<'a, I, Expr, ParserError<'a>> + Clone + 'a
where
    I: Input<'a, Token = lr::Token, Span = Span> + BorrowInput<'a>,
    E: Parser<'a, I, Expr, ParserError<'a>> + Clone + 'a,
{
    let func_name = expr.clone();

    let named_arg = ident_part()
        .map(Some)
        .then_ignore(ctrl(':'))
        .then(expr.clone());

    // TODO: I think this possibly should be restructured. Currently in the case
    // of `derive x = 5`, the `x` is an alias of a single positional argument.
    // That then means we incorrectly allow something like `derive x = 5 y = 6`,
    // since there are two positional arguments each with an alias. This then
    // leads to quite confusing error messages.
    //
    // Instead, we could only allow a single alias per function call as the
    // first positional argument? (I worry that not simple though...).
    // Alternatively we could change the language to enforce tuples, so `derive
    // {x = 5}` were required. But we still need to account for the `join`
    // example below, which doesn't work so well in a tuple; so I'm not sure
    // this helps much.
    //
    // As a reminder, we need to account for `derive x = 5` and `join a=artists
    // (id==album_id)`.
    let positional_arg = maybe_aliased(expr.clone()).map(|e| (None, e));

    func_name
        .then(named_arg.or(positional_arg).repeated().collect::<Vec<_>>())
        .validate(
            |(name, args): (Expr, Vec<(Option<String>, Expr)>), extra, emit| {
                let span = extra.span();
                if args.is_empty() {
                    return name.kind;
                }

                let mut named_args = HashMap::new();
                let mut positional = Vec::new();

                for (name, arg) in args {
                    if let Some(name) = name {
                        match named_args.entry(name) {
                            Entry::Occupied(entry) => {
                                emit.emit(Rich::custom(
                                    span,
                                    format!("argument '{}' is used multiple times", entry.key()),
                                ));
                            }
                            Entry::Vacant(entry) => {
                                entry.insert(arg);
                            }
                        }
                    } else {
                        positional.push(arg);
                    }
                }