Enhancements can enable memory-safe reference counting

[tsbockman]

On Thursday, 27 May 2021 at 20:47:44 UTC, vitoroak wrote:
> I saw you mentioning breaking things in @safe code. This 
> example let you access an invalid pointer without no @trusted 
> code and heap allocation, only @safe code.
>
> ```d
> struct IntRef {
> 	int* ptr = void;
> ```

`void` initializing `IntRef.ptr` does not create a gap in 
`IntRef.init`. `IntRef.init.ptr` is effectively still `null`.

> ```d
>     this(return scope int* p) @safe {
>     	ptr = p;
>     }
>
>     int* borrow() return scope @safe {
> 		return ptr;
>     }
> }
>
> void main() @safe {
>     import std.stdio: writeln;
>
>     auto x = 1;
>     auto r = IntRef(&x);
>
>     writeln(*r.borrow);
>
> 	destroy!true(r);
> ```

`destroy!true` sets `r` to `IntRef.init`, which sets `r.ptr` to 
`null`.

> ```d
>     writeln(*r.borrow);
> }
> ```

As Paul Backus said earlier, dereferencing a `null` pointer is 
formally considered to be memory-safe in D. This is because it 
will (with some rare exceptions) crash the program immediately, 
rather than corrupting memory and continuing execution with 
undefined behavior.