The "no gc" crowd

[Adam D. Ruppe]

On Tuesday, 8 October 2013 at 16:24:05 UTC, Dicebot wrote:
> Runtime check is almost useless for this.

They're how I do most the allocation checks now and could also be 
put in unit tests.

But I agree the ideal would be a compile time check. The way I 
want it to work is to define a new thing in the language, maybe 
via __traits, that can recursively check the call graph of a 
function for the presence of any UDA.

Then we attach @gc to the druntime functions that use them, 
starting at gc_malloc and right up into aaDup, d_newclass, 
whatever concat is called.

Ensure that the compiler considers these implicit function calls 
the same as any others and propagates the druntime UDA through 
the recursive trait.

Then we define @nogc to just be static assert(!hasAttribute!(gc, 
__traits(getAttributesRecursively, FUNCTION)). Maybe do a 
compiler or druntime change to @something can be expanded to a 
template instantation too so this doesn't even have to be a 
specific builtin. (Though I've actually been able to do this by 
hacking druntime before.) But whatever that specific impl doesn't 
matter.



Bottom line: @nogc works after just marking the core functions in 
druntime that may allocate, and the very same functionality can 
be used for other things too, like @noheap. Mark malloc with a 
uda, then define noheap as static assert(!gc && !malloc)

Then we have compile time checking, at least on the function 
level.