What should happen here?

[Steven Schveighoffer]

On 9/24/21 12:21 PM, H. S. Teoh wrote:

> I still prefer GC.addRoot.
> 
> For one thing, that's the "official" way to inform the GC that a certain
> object is still needed and therefore should not be collected.

The "official" docs [also 
say](https://dlang.org/spec/interfaceToC.html#storage_allocation), put a 
pointer on the stack if you want it to not be collected.

Note that `GC.addRoot` performs a different function. It keeps the 
memory alive until you use `GC.removeRoot`. Putting a pointer on the 
stack keeps the thing alive until the end of the stack frame. They are 
not the same thing.

> 
> Secondly, it self-documents the intent of the code, instead of some
> arcane workaround like struct Pin (that may or may not work in the
> future depending on how smart optimizers become).

This is pretty self documenting:

```d
obj.keepAlive;
```

Or perhaps:

```d
GC.keepAlive(obj);
```

which means, keep this object alive until this line at least. The name 
`Pin` was something I just quickly thought of. But I think `keepAlive` 
is much more descriptive (and has precedence).

> Third, if the overhead of calling GC.addRoot becomes an actual problem,
> it can always be turned into an intrinsic that the compiler can, based
> on certain conditions, replace it with an equivalent internal flag that
> ensures the value stays on the stack until the end of the scope.
1. `GC.addRoot` cannot mean "put on the stack". Because it has to be 
paired with a `GC.removeRoot` at a later point in the same frame to have 
the same effect. Sure, an intrinsic is possible for this situation, but 
it's way more complex, and I feel not as easily deciphered.
2. If `keepAlive` is poorly performing, it too can be replaced with an 
intrinsic (as it is in C# and Go).

-Steve