Bug in RefCounted?

[Maxim Fomin]

On Monday, 28 October 2013 at 16:53:11 UTC, monarch_dodra wrote:
> On Monday, 28 October 2013 at 10:07:15 UTC, Rene Zwanenburg 
> wrote:
>> Yeah, I'd like to know this as well. I do remember structs 
>> allocated on the heap don't have their destructors called at 
>> all due to the GC not being precise, I think.
>>
>> But one object allowed to be destructed multiple times? That 
>> sounds really bad.. If that's true a lot of my code is 
>> probably incorrect.
>
> Hum... I seem to remember having replied earlier, but I guess I
> forgot to hit send.
>
> In any case, I could be mistaken, but I simply know that under
> certain circumstances, it can happen.

OK

> I don't know if that's a
> bug though. I'll try to find the cases where it happens.
>

So do you *know* cases or suspect that they may exists? Or 
remember some bug issue?

Here is my attempt:

import std.stdio;

struct S
{
    int i;
    this(int i)   { writefln("ctor, %X", i); this.i = i; }
    this(this)  { writefln("postblit, %X, %X", &this, i); }
    ~this()     { writefln("dtor, %X, %X", &this, i); }
}

auto foo()
{
    S s = S(1);
    return { s = S(2); } ;
}

void main()
{
    foo()();
}

ctor, 1
dtor, 7FFFF7ED8FF8, 1
ctor, 2
dtor, 7FFFFFFFDB30, 1

Inside foo() function object 's' is destroyed twice: first time 
as a regular struct at the end of block scope, second time before 
assigning S(2).

There are other tools: union bug, control flow tricks, __traits, 
__dtor but they are move obvious.