CTFE Allocators / @nogc

For a contrived example:

import std.stdio;
import std.experimental.allocator;

int test(int c) {
    
    int[] numbers;
    
    if (__ctfe) {
        numbers = new int[c * 4];
    } else {
        numbers = processAllocator().makeArray!int(c * 4);
    }
    
    foreach (i, ref number ; numbers) {
        number = cast(int) i * 2;
    }
    
    return numbers[c];
}

void main()
{
    enum int test1 = test(15);
    auto test2 = test(25);
    writefln("Hello D %d %d\n", test1, test2);
}

In CTFE you cannot use allocators (static / runtime data access) nor can you use malloc (casting rules void * -> int[] not allowed). So I have to use the GC via the new call. This works just fine and all is good, I don't have to write twice the code so I can have a CTFE version... until you add @nogc. That __ctfe check is not static, it's a runtime check that gets optimized out by the compiler. But because it's not static, it doesn't count as conditional compilation and using the GC violates the nogc-ness of the code even though it will never be used at runtime! You can't make it static either, because __ctfe itself cannot be read at compile time.

D allows me to invalidate the @nogc invariant at compile time otherwise, though, as long as it's done in CTFE it has never complained before (and it rightfully shouldn't).

So if I want to use test as both a CTFE and a runtime function, I have to write two functions that are almost entirely identical except one uses the allocator (which may even be the gcAllocator, which still doesn't work in CTFE) and one that uses new.

So I was wondering if there was something I was missing, if there are any plans to allow __ctfe to be used for real conditional compilation, or if there are CTFE-compatible allocators? That way I could avoid code duplication.