Stupid scope destruction question

[monarch_dodra]

On Thursday, 20 September 2012 at 09:31:45 UTC, Denis 
Shelomovskij wrote:
> 20.09.2012 13:27, Denis Shelomovskij пишет:
>> Is there any guaranties that `ScopeTemp` will not be destroyed 
>> before
>> `f` call because it isn't used?
>> ---
>> struct ScopeTemp
>> {
>>     ...
>>     // allocates value
>>     this(...) { ... }
>>
>>     @property void* value() { ... }
>>
>>     // destroys value
>>     ~this() { ... }
>> }
>>
>> void f(void* ptr) { ... }
>>
>> void main()
>> {
>>     f(ScopeTemp(...).value);
>> }
>> ---
>> According to http://dlang.org/struct.html#StructDestructor
>> "Destructors are called when an object goes out of scope."
>> So I understand it as "it will not be destroyed before scope 
>> exit even
>> if not used". Is it correct?
>>
>> So the question is if `ScopeTemp`'s scope is `main` scope, not 
>> some
>> possibly generated "temp scope" (don't now what documentation 
>> statements
>> prohibit compiler from doing so).
>>
>>
>> Working code:
>> ---
>> import std.exception;
>> import std.c.stdlib;
>>
>> struct ScopeTemp
>> {
>>     private int* p;
>>     // allocates value
>>     this(int i)
>>     in { assert(i); }
>>     body { *(p = cast(int*) enforce(malloc(int.sizeof))) = i; }
>>
>>     @disable this(this);
>>
>>     @property int* value() { return p; }
>>
>>     // destroys value
>>     ~this() { *p = 0; p = null; /*free(p);*/ }
>> }
>>
>> void f(int* ptr)
>> {
>>     assert(*ptr == 1);
>> }
>>
>> void main()
>> {
>>     f(ScopeTemp(1).value);
>> }
>> ---
>
> Wow, this `main` works fine too:
> ---
> // same ScopeTemp definition as above
>
> int* gptr;
>
> void f(int* ptr)
> {
>     assert(*ptr == 1);
>     gptr = ptr;
> }
>
> void g()
> {
>     assert(*gptr == 0);
> }
>
> void main()
> {
>     f(ScopeTemp(1).value);
>     // Here `ScopeTemp` value is already destroyed
>     g();
> }
> ---
>
> So `ScopeTemp`'s scope definitely isn't a `main` scope. So the 
> question: what do we know about this "temp scope"?

AFAIK, if the rules are the same in C++ (which they probably 
are), then:
"Any object constructed during argument passing will remain valid 
for the duration of the call. It will go out of scope once the 
function has finished returning, and after the return value has 
itself gone out of scope and been destroyed."

The two catches are:
*"The implementation is allowed to elide the copy for pass by 
value, even if it has visible side effects, and construct 
directly into the function's stack."
*"If the function is able to use "(Named) Return Value 
Optimization" "(N)RVA" (invented by Walter himself), the returned 
value's destruction will not be observable (as it won't happen)."

Try running this:

C++
----
#include <iostream>

struct S
{
   int i;
   S(int i) : i(i) {::std::cout << "C:" << i << ::std::endl;}
   S(const S&){::std::cout << "CC:" << i << ::std::endl;}
   ~S(){::std::cout << "D~:" << i << ::std::endl;}
};

S foo(S)
{
   ::std::cout << "foo(S)" << ::std::endl;
   return S(2);
}
S foo(int)
{
   ::std::cout << "foo(int)" << ::std::endl;
   return S(6);
}

int main()
{
   foo(S(1));
   foo(S(5).i);
}
----
C:1
foo(S)
C:2
D~:2
D~:1
C:5
foo(int)
C:6
D~:6
D~:5
----

D:
----
import std.stdio;

struct S
{
   int i;
   this(int j){i = j;writeln("C",i);}
   this(this){writeln("PB",i);}
   ~this(){writeln("D~",i);}
};

S foo(S)
{
   writeln("foo(S)");
   return S(2);
}
S foo(int)
{
   writeln("foo(int)");
   return S(6);
}

void main()
{
   S a = foo(S(1));
   S a = foo(S(5).i);
}
----
C1
foo(S)
C2
D~1
D~2
C5
foo(int)
C6
D~6
D~5
----

I haven't seen any difference between C++ and D, including the 
argument pass by value elision, as well as (N)RVA