Why is dtor called for lazy parameter?

[Simen Kjærås]

On Friday, 18 September 2020 at 14:14:31 UTC, Andrey Zherikov 
wrote:
> It seems that dtor is called at exit from lazy delegate, not at 
> exit form create():
> ======
>     create()
>     .do_something()
>     .do_lazy()
>     .do_something();
> ======
> Output:
> ======
> -> void test.main()
> -> test.do_lazy(lazy S s)
> -> test.create()
> 1 S test.S.this(int n)
> <- test.create()
> -> 1 test.do_something(S s)
> <- 1 test.do_something(S s)
> 1 void test.S.~this()
> ===-1
> <- test.do_lazy(lazy S s)
> -> 1703096 test.do_something(S s)
> <- 1703096 test.do_something(S s)
> <- void test.main()
> ======
>
> This doesn't even allow me to copy the value of 's' in 
> do_lazy().

You're right, I missed a step: do_lazy() takes a S, not a 
scoped!S, so the conversion from scoped!S to S happens after 
create() has returned and before the value is used in do_lazy. 
This explains my confusion earlier.

D's lazy is essentially the same as a delegate or function, so 
you could* rewrite to this (writelns omitted for clarity):

S do_lazy(S function() s) {
     return s();
}

void main() {
     (() => cast(S)create()) // Here
     .do_lazy()
     .do_something();
}

On the marked line, the cast from scoped!S to S happens, the 
scoped!S goes out of scope and the destructor is called.

*There may be differences, but for this discussion these are not 
important.

--
   Simen