Start to use object.destroy + GC.addrOf

Author: wilzbach

src/core/memory.d

@@ -944,8 +944,8 @@ performs the following actions in sequence:
 $(UL
     $(LI
         Calls `.object.destroy(x)` (if `x` is a class or interface object) or
-        `typeid(*x).destroy(x)` (if `x` is pointer to a struct) to destroy the referred entity.
-        Arrays of structs call `typeid(*x).destroy(x)` for each element.
+        `(*x).__xdtor()` (if `x` is pointer to a struct and a custom destructor exists) to destroy the referred entity.
+        Arrays of structs with a custom destructor call `x.__xdtor()` for each element in the array.
     )
     $(LI
         Frees the memory allocated for `x`. If `x` is a reference to a class
@@ -968,34 +968,48 @@ See_Also: $(REF destroy, object), $(REF free, core,GC)
 */
 void __delete(T)(ref T x) @system
 {
+    static void _destructRecurse(S)(ref S s)
+        if (is(S == struct))
+    {
+        static if (__traits(hasMember, S, "__xdtor") &&
+                   // Bugzilla 14746: Check that it's the exact member of S.
+                   __traits(isSame, S, __traits(parent, s.__xdtor)))
+            s.__xdtor();
+    }
+
     // See also: https://github.com/dlang/dmd/blob/v2.078.0/src/dmd/e2ir.d#L3886
     static if (is(T == interface))
     {
-        (cast(Object) x).destroy;
+        .object.destroy(x);
     }
     else static if (is(T == class))
     {
-        (cast(Object) x).destroy;
+        .object.destroy(x);
     }
     else static if (is(T == U*, U))
     {
         static if (is(U == struct))
-            typeid(U).destroy(x);
+            _destructRecurse(*x);
     }
     else static if (is(T : E[], E))
     {
         static if (is(E == struct))
         {
             foreach (ref e; x)
-                typeid(E).destroy(&e);
+                _destructRecurse(e);
         }
     }
     else
     {
         static assert(0, "It is not possible to delete: `" ~ T.stringof ~ "`");
     }
 
-    static if (is(T == interface) || is(T == class) || is(T == U2*, U2) || is(T : E2[], E2))
+    static if (is(T == interface) || is(T == class))
+    {
+        GC.free(cast(void*) x);
+        x = null;
+    }
+    else static if (is(T == U2*, U2) || is(T : E2[], E2))
     {
         GC.free(&x);
         x = null;
@@ -1018,11 +1032,14 @@ unittest
     B a = b;
     b.test = 10;
 
+    assert(GC.addrOf(cast(void*) b) != null);
     __delete(b);
     assert(b is null);
     assert(dtorCalled);
+    assert(GC.addrOf(cast(void*) b) == null);
     // but be careful, a still points to it
     assert(a !is null);
+    assert(GC.addrOf(cast(void*) a) !is null);
 }
 
 /// Deleting interfaces
@@ -1049,9 +1066,11 @@ unittest
     A a = new B();
     a.quack();
 
+    assert(GC.addrOf(cast(void*) a) != null);
     __delete(a);
     assert(a is null);
     assert(dtorCalled);
+    assert(GC.addrOf(cast(void*) a) == null);
 }
 
 /// Deleting structs
@@ -1067,39 +1086,27 @@ unittest
         }
     }
     auto a = new A("foo");
-    __delete(a);
 
+    assert(GC.addrOf(cast(void*) a) != null);
+    __delete(a);
     assert(a is null);
     assert(dtorCalled);
+    assert(GC.addrOf(cast(void*) a) == null);
 }
 
 /// Deleting arrays
 unittest
 {
     int[] a = [1, 2, 3];
     auto b = a;
-    __delete(b);
-    assert(b is null);
-}
 
-/// Deleting pointers
-unittest
-{
-    bool dtorCalled;
-    class A
-    {
-        string test;
-        ~this()
-        {
-            dtorCalled = true;
-        }
-    }
-    A a = new A();
-    a.test = "exists";
-    auto b = &a;
+    assert(GC.addrOf(b.ptr) != null);
     __delete(b);
     assert(b is null);
-    assert(!dtorCalled);
+    assert(GC.addrOf(b.ptr) == null);
+    // but be careful, a still points to it
+    assert(a !is null);
+    assert(GC.addrOf(a.ptr) !is null);
 }
 
 /// Deleting arrays of structs
@@ -1115,17 +1122,22 @@ unittest
         }
     }
     auto arr = [A(1), A(2), A(3)];
+
+    assert(GC.addrOf(arr.ptr) != null);
     __delete(arr);
     assert(dtorCalled == 3);
+    assert(GC.addrOf(arr.ptr) == null);
 }
 
 // Deleting raw memory
 unittest
 {
     import core.memory : GC;
     auto a = GC.malloc(5);
+    assert(GC.addrOf(cast(void*) a) != null);
     __delete(a);
     assert(a is null);
+    assert(GC.addrOf(cast(void*) a) == null);
 }
 
 // __delete returns with no effect if x is null