• via Digitalmars-d-bugs (102/102) Feb 27 2015 https://issues.dlang.org/show_bug.cgi?id=14229

via Digitalmars-d-bugs <digitalmars-d-bugs puremagic.com> writes:

https://issues.dlang.org/show_bug.cgi?id=14229

          Issue ID: 14229
           Summary: RAII ordering is wrong
           Product: D
           Version: D2
          Hardware: x86_64
                OS: Windows
            Status: NEW
          Severity: enhancement
          Priority: P1
         Component: DMD
          Assignee: nobody puremagic.com
          Reporter: etcimon gmail.com

I'm having issues with the ordering of copy constructors / destructors, and
this causes my reference counting utilities to break down.

Here's the relevant code:

```
import std.stdio;

struct A {
        this(B!"A->" i) {
                b = i;
                writeln("A.__ctor");
        }
        ~this() { writeln("A.__dtor"); }
        this(this) { writeln("A.__copy"); }
        B!"A->" b;
}

struct B(string ident) {
        this(C!"B1->" i, C!"B2->" j, C!"B3->" k) {
                c = i;
                c2 = j;
                c3 = k;
                writeln(ident ~ "B.__ctor");
        }
        ~this() { writeln(ident ~ "B.__dtor"); }
        this(this) { writeln(ident ~ "B.__copy"); }
        C!"B1->" c;
        C!"B2->" c2;
        C!"B3->" c3;
}

struct C(string ident) {
        this(int i, int j, int k) {
               a = i;
               b = j;
               c = k;
               writeln(ident ~ "C.__ctor");
        }

        ~this() { writeln(ident ~ "C.__dtor"); }
        this(this) { writeln(ident ~ "C.__copy"); }
        int a;
        int b;
        int c;
}

C!"B1->" getC(A a) {
        C!"B1->" c = a.b.c;
        writeln("Returning B1->C");
        return c;
}



void main() {
        A a;
        C!"B1->" c1 = C!"B1->"(1,2,3);
        C!"B2->" c2 = C!"B2->"(4,5,6);
        C!"B3->" c3 = C!"B3->"(7,8,9);
        B!"A->" b = B!"A->"(c1, c2, c3);
        a.b = b;

        writeln("Getting C");

        C!"B1->" c;
        c = getC(a);
        writeln("Got C");
}
```

The relevant output is:

----

Getting C
B1->C.__copy
B2->C.__copy
B3->C.__copy
A->B.__copy
A.__copy
B1->C.__copy
Returning B1->C
A.__dtor
A->B.__dtor
B3->C.__dtor
B2->C.__dtor
B1->C.__dtor
B1->C.__dtor
Got C

----

There's a mistake here.

The copy pattern under "Getting C" is fine. From the top down. To be equally
fine, destruction pattern should reverse it! It should propagate the
destruction tree from the bottom up. ie. you should be seeing:

B3->C.__dtor
B2->C.__dtor
B1->C.__dtor
A->B.__dtor
A.__dtor

Unfortunately, this might end up in the early destruction of an object
(segfault), and an absolute nightmare for the poor programmer debugging this
while expecting a bottom up destruction pattern.

--