D manual destruction may violate memory security

Destructor The purpose of this paper is to describe object Life span end Cleaning during . allow @safe The code manually calls... Before this point Destructor , Then continue to use Analytic object Will destroy RAII memory management :

module app;

import core.stdc.stdlib : malloc, free;

struct UniqueInt {
    
    private int* target;
    this(const(bool) doCreate) scope @trusted nothrow @nogc {
    
        target = cast(int*) malloc(int.sizeof);
        *target = 5;
    }
    @disable this(this);
    @disable this(ref typeof(this));
    @disable ref typeof(this) opAssign(ref typeof(this));

    void withBorrow(void delegate(scope int*) @safe action) @safe {
    
        action(target); }

    ~this() scope @trusted nothrow @nogc {
    
        if(target !is null) {
    
            free(target);
            target = null;
        }
    }
}
//
UniqueInt unique;
shared static this() {
    
    unique = true; }

void main() @safe {
    
    import std.stdio: writeln;

    unique.withBorrow((scope int* borrowed) @safe {
    
        writeln(*borrowed);
        destroy(unique);
        writeln(*borrowed); //  Use after release 
    });
}

I think the reasonable solution is : No matter ~this() What are the properties , Make call __dtor,__xdtor or Manual deconstruction by @system operation .

---

In order to be in Security Function is automatically created T Type object ,T The destructor must be Safe or trusted Of .
At present, the destructor is composed of __dtor Member functions embody , namely Destructor declaration The properties of are the same as the generated __dtor The properties of member functions are the same .
There are some type Need to define Destructor To do something unsafe , Mainly Release In object Carefully limit Of memory .
This creates the following difficulties :
1. If type Make the destructor @trusted, It means Security The code is also free to manually call __dtor(). Subsequent use of such objects will Breach of safety .
2. If type Choose to use @system Destructor , Then the security code cannot be created Such objects .
At first glance , You need a way to tell the compiler " Only when implicitly calling Destructor when , It's trustworthy ".