My (clearly limited) understanding was that track_caller caused panics arising in the function to be attributed to the caller. But in this case neither of these functions can directly panic (though functions they call, recursively, can, I think?). What's the expected behavior here?

f can be #[track_caller] and panic. If with_gil is not #[track_caller], then with_gil(f) will report a panic location inside of with_gil.

To make sure I have this, the only case this changes behavior is if f is also #[track_caller].

For f which is not #[track_caller] this is the same before/after -- the panic is attributed to f.

For f which is #[track_caller], without this PR if f panics then the panic is attributed to with_gil. With this PR, the panic is properly attributed to with_gil's caller?

Correct!

This makes sense to me as an improvement.

Does this imply that basically any function which accepts an impl Fn should be #[track_caller] for the same reason?

Maybe. Probably. Applying #[track_caller] to a closure is currently an unstable Rust feature, so it's somewhat unlikely people will run into this, unless they're using nightly features or if they're passing a function name rather than a closure.

Ah, so this is 99% preventative. (I mean, you can just pass a regular fn, but I suspect very few people do.)

Thanks for the comprehensive answers.