Generic and fundamental language design issue

[Tommi]

I have a fundamental language design talking point for you. It's 
not specific to D. I claim that, most of the time, a programmer 
cannot, and shouldn't have to, make the decision of whether to 
allocate on stack or heap. For example:

void func(T)()
{
     auto t = <allocate T from heap or stack?>
     ...
}

The question of whether variable t should lay in heap or stack, 
depends not only on the sizeof(T), but also on the context in 
which func is called at. If func is called at a context in which 
allocating T on stack would cause a stack overflow, then t should 
be allocated from the heap. On the other hand, if func is called 
at a context where T still fits nicely on the stack, it would 
probably be better and faster to allocate t on stack.

So, the question of whether to allocate that variable t on stack 
or heap is something that only the compiler (or runtime) can 
answer. Is there any language where you have the ability to say 
"allocate T from wherever it's best"?

I wonder if it would be possible in D to let the compiler 
allocate dynamic arrays on stack when it can statically guarantee 
that it's safe to do so (no dangling references, never increasing 
the size of the array, etc).