Last Postblit Optimization and r-value ref

[IgorStepanov via Digitalmars-d]

I've created issue about last postblit call optimization (LPO):
https://issues.dlang.org/show_bug.cgi?id=13492
As I wrote in issue description, this optimization can solve 90% 
r-value reference issue.
Let's talk about remaining 10%.
There are remain two issue:
1. value argument causes full copying it to stack (can be 
important for a large structs and static arrays)
2. When r-value passed to auto-ref function (or simply: to any 
function by value) then this value becomes a l-value and can be 
passed to the next call as l-value ref:
void first(Foo f)
{
    second(f);
}

void second(Foo f)
{
   writeln("by value");
   globalFoo = f; //perform LPO
}

void second(ref Foo f)
{
   writeln("by ref");
   globalFoo = f; //can't perform LPO
}

first(Foo(42)); //passed to first by value, to second by ref and 
prints "by ref"

I suggest a small ABI change which can solve this issues without 
major language changes.

1. Let's pass all structs and static arrays by ref (Keeping a 
value semantic).
2. Let's forward value args (include passed by auto ref) to a 
value args of a next call

See, how it will works with this changes and LPO:

void second(ref Foo); [1]
void second(Foo);     [2]

void first(Foo f)
{
    second(f);
    second(f);
}

Translates to:

void first(Foo f)
{
    Foo __tmp1 = f; //postblit is called
    second(&__tmp1); //[2] is called, f passed by ref

    second(f); //[2] is called, f passed by ref, postblit isn't 
called because LPO
}

If second() writes f to any storage (e. g. struct field), f will 
be saved to this storage without postblit and dtor calls and 
struct copying (for the second call of "second()")

This changes allow us simulate r-value refs without major 
language changes.

Destroy!