Tail calls with indirect operands are untested

[oli-obk]

In #144232 (comment) the code path for indirect arguments to tail called functions is

• untested
• ICEing if actually hit

So we first need to find a test actually exercising this code path, but then fixing it will either be hard, or we need to reject types that would hit it earlier in the compiler, restricting what types you can use in tail call arguments.

Orthogonal: We need to generally increase our test coverage of runtime tail calls (const eval covers them well enough for const-eval purposes already, but more don't hurt, and with const fn being callable in const eval and in runtime code, that should be easy to write as tests that share code).

[tnuha]

ICEing if actually hit

I haven't seen an example of this in #144232 and simply changing some preexisting tests (e.g. tests/ui/explicit-tail-calls/recursion-tce.rs) to something like count(curr: &u64, top: &u64) -> u64 is already stopped by the borrow checker, and the much less interesting count(curr: u64, top: &u64) -> u64 compiles just fine.

I may be missing some implementation of the former set of arguments. In the case that I'm not, I don't currently see any realistic situation where this may be encountered.

For reference:

#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]

use std::hint::black_box;

pub fn count(curr: &u64, top: &u64) -> u64 {
   if black_box(curr) >= top {
        *curr
   } else {
        become count(&(curr + 1), top)
   }
}

fn main() {
    println!("{}", count(&0, black_box(&1000000)));
}

and variants is always blocked by the borrow checker's lifetime guarantees ime

[oli-obk]

references are still immediates. You can write code with references:

#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]

use std::hint::black_box;

pub fn count(curr: u64, top: &u64) -> u64 {
   if black_box(curr) >= *top {
        curr
   } else {
        become count(curr + 1, top)
   }
}

fn main() {
    println!("{}", count(0, black_box(&1000000)));
}

(note that the playground and nightly don't have explicit tail calls yet, as the PR isn't merged yet)

[tnuha]

Right, unfortunately the compiler I've built from #144232 still does not encounter any issues (or, more precisely, does not crash) with that code.

Also have attempted e.g. raw pointers etc and still have been stopped by the borrow checker. It seems to me that any sort of encoding of mutation between recursive calls has this be the case.

Top of git log:

commit 4028c674a97883e40618bb1be073ace7311ee090 (HEAD -> become_indirect_operands, xacrimon/explicit-tail-call)
Author: Joel Wejdenstål <joel.wejdenstal@gmail.com>
Date:   Mon Jul 21 20:30:27 2025 +0200

    use span_bug instead of bug

-> built as stage1

Thu Jul 24 07:54 AM ash - tmp.QfP31LXhcg => cat t.rs
#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]

use std::hint::black_box;

pub fn count(curr: u64, top: &u64) -> u64 {
   if black_box(curr) >= *top {
        curr
   } else {
        become count(curr + 1, top)
   }
}

fn main() {
    println!("{}", count(0, black_box(&1000000)));
}
Thu Jul 24 07:55 AM ash - tmp.QfP31LXhcg => rustc +stage1 t.rs
Thu Jul 24 07:55 AM ash - tmp.QfP31LXhcg => ls
t  t.rs
Thu Jul 24 07:55 AM ash - tmp.QfP31LXhcg => ./t
1000000

Compiles and runs as expected.

Is there some other erroneous behavior we're expecting beyond a compiler cash?

[oli-obk]

Ah. "indirect operands" is a term from inside the codegen backend. It does not mean pointers/references, as those are represented as a scalar pointer. It also doesn't mean wide pointers or two element tuples of scalars. But everything else is too large to be passed in registers, so what most ABIs do is they pass a pointer to the value that lives on the caller's stack. So a struct/tuple with enough fields to turn it into an "indirect operand" could work

[tnuha]

Alright cool, I've got the following case panicking:

#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]

use std::hint::black_box;

struct U64Wrapper {
    pub x: u64,
    pub arbitrary: String,
}

fn count(curr: U64Wrapper, top: U64Wrapper) -> U64Wrapper {
    if black_box(curr.x) >= top.x {
        curr
    } else {
        become count(
            U64Wrapper {
                x: curr.x + 1,
                arbitrary: curr.arbitrary,
            },
            top,
        )
    }
}

fn main() {
    println!(
        "{}",
        count(
            U64Wrapper {
                x: 0,
                arbitrary: "hello!".into()
            },
            black_box(U64Wrapper {
                x: 1000000,
                arbitrary: "goodbye!".into()
            })
        )
        .x
    );
}

log here:

rustc-ice-2025-07-24T17_05_59-5419.txt

Currently in the process of a move, so I won't be claiming this yet, but I believe the log gives a good amount of information to go off of, accompanied by the history in #144232. If I'm back in a place where I can dedicate more time to this before someone else snatches this I'll follow up. Thank you!