Final review comments

Author: wilzbach

src/core/memory.d

@@ -920,7 +920,7 @@ extern (C) private pure @system @nogc nothrow
     pragma(mangle, "free") void fakePureFree(void* ptr);
 }
 
-extern(C) private @system nothrow
+extern(C) private @system nothrow @nogc
 {
     pragma(mangle, "_d_delinterface") void _d_delinterface(void**);
     pragma(mangle, "_d_delclass") void _d_delclass(Object*);
@@ -930,22 +930,17 @@ extern(C) private @system nothrow
 }
 
 /**
-The `delete` keyword allowed to free GC-allocated memory.
-As this is inherently not `@safe`, it has been deprecated.
-This function has been added to provide an easy transition from `delete`.
-It performs the same functionality as `delete`.
-
-Note: Users should prefer $(REF destroy, object)` to explicitly finalize objects,
-and only resort to $(REF __delete, core,memory) when $(REF destroy, object)
-would not be a feasible option.
+Destroys and then deallocates the object.
 
 In detail, `__delete(x)` returns with no effect if `x` is `null`. Otherwise, it
 performs the following actions in sequence:
 $(UL
     $(LI
-        Calls `.object.destroy(x)` (if `x` is a class or interface object) or
-        `(*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.
+        Calls the destructor `~this()` for the object referred to by `x`
+        (if `x` is a class or interface reference) or
+        for the object pointed to by `x` (if `x` is a pointer to a `struct`).
+        Arrays of structs call the destructor, if defined, for each element in the array.
+        If no destructor is defined, this step has no effect.
     )
     $(LI
         Frees the memory allocated for `x`. If `x` is a reference to a class
@@ -961,15 +956,26 @@ $(UL
     )
 )
 
+Note: Users should prefer $(REF destroy, object)` to explicitly finalize objects,
+and only resort to $(REF __delete, core,memory) when $(REF destroy, object)
+wouldn't be a feasible option.
+
 Params:
     x = aggregate object that should be destroyed
 
 See_Also: $(REF destroy, object), $(REF free, core,GC)
+
+History:
+
+The `delete` keyword allowed to free GC-allocated memory.
+As this is inherently not `@safe`, it has been deprecated.
+This function has been added to provide an easy transition from `delete`.
+It performs the same functionality as the former `delete` keyword.
 */
 void __delete(T)(ref T x) @system
 {
     static void _destructRecurse(S)(ref S s)
-        if (is(S == struct))
+    if (is(S == struct))
     {
         static if (__traits(hasMember, S, "__xdtor") &&
                    // Bugzilla 14746: Check that it's the exact member of S.