I'm going to second Paul Chiusano here. I just got bitten by this problem, which turned out to be in a library I was using. Debugging issues like this are difficult in large-scale code because Java cuts off the bottom stack frames, so you can't even see which code triggered the call to foldRight.
I strongly believe we should either
(1) preferably, fix this issue as Paul C. proposed;
(2) deprecate the function and all other non-tail-recursive functions;
(3) issue a clear warning at compile time about stack overflow problems when the function is encountered;
(4) provide a "safeFoldRight" function that won't trigger stack overflows, and similarly for other dangerous functions.
At the very least, clearly document functions that aren't stack-safe, and indicate how to avoid the issue (e.g. through reverse.foldLeft).
In reality, although Martin may personally have a clear idea which functions are and aren't tail-recursively-safe, the average Scala programmer has little or no idea. As a simple example, I verified experimentally that appending to the end of a very large list does not cause a stack overflow – but how could I possibly know that? My intuition tells me that the most straightforward implementation will be recursive in a non tail-recursive way. In general, programmers should not have to be aware of implementation details like this, and on top of this, currently there's no documentation as to which functions are stack-safe and which ones aren't.
BTW, I see that others have run into this same issue: