Dynamic arrays, emplace and GC

[Claude via Digitalmars-d-learn]

Hello,

I've been working on some kind of allocator using a dynamic array 
as a memory pool. I used emplace to allocate class instances 
within that array, and I was surprised to see I had to use 
GC.addRange() to avoid the GC to destroy stuff referenced in that 
array.

Here's a chunk of code[1]:

struct Pool(T)
{
public:
    T alloc(Args...)(Args args)
    {
        mData.length++;
        import core.memory : GC;
        //GC.addRange(mData[$ - 1].data.ptr, mData[$ - 
1].data.length);
        import std.conv : emplace;
        auto t = emplace!T(mData[$ - 1].data, args);
        return t;
    }

private:
    struct Storage
    {
        ubyte[__traits(classInstanceSize, T)] data;
    }

    Storage[] mData;
}

class Foo
{
    this(int a)
    {
        aa = a;
    }
    ~this()
    {
        import std.stdio; writefln("DTOR");
        aa = 0;
    }
    int aa;
}

class Blob
{
    this(int b)
    {
        foo = new Foo(b);
    }

    Foo foo;
}

void main()
{
    Pool!Blob pool;

    Blob blob;
    foreach(a; 0 .. 10000)
    {
        blob = pool.alloc(6);
    }
    while(true){}
    import std.stdio; writefln("END");
}

Basically Blob instances are allocated in the array using 
emplace. And Blob creates references to Foo. If I comment out 
GC.addRange(), I see that Foo destructor is called by the GC[2]. 
If I leave it uncommented, the GC leaves the array alone.

So here's my question: Is it normal???
I thought that allocating memory in a dynamic array using 
"mData.length++;" was GC-compliant (unlike 
core.stdc.stdlib.malloc()), and I did not have to explictly use 
GC.addRange().


[1] I left out alignment management code. It's not the issue here.
[2] I used the helpful destructor tracker function of p0nce 
there: https://p0nce.github.io/d-idioms/#GC-proof-resource-class