@disable assignment of [] literal?

[Meta via Digitalmars-d-learn]

Consider the following code:

struct ArrayWrapper(T)
{
    T t;
        
    this(T t)
    {
        assert(t !is null);
    }
    @disable this(typeof(null));
        
    typeof(this) opAssign(T val)
    {
        assert(t !is null);
        this.t = val;

        return this;
    }
        
    @disable typeof(this) opAssign(typeof(null));
    @disable typeof(this) opAssign(typeof([]));
}

void main()
{
    //This is caught at compile time
    ArrayWrapper!(int[]) a = null;

    //This throwns a runtime error
    ArrayWrapper!(int[]) b = [];
}

That's fine, though, we can just add `@disable this(typeof([]))`. 
But wait, that doesn't work. The @disable'd constructor is 
ignored and it takes the this(T t) constructor instead. I have no 
idea why, as this(typeof(void[])) should be more specialized than 
this(int[]) when called with `[]`, but okay.

This isn't the only case that this doesn't work, either:

ArrayWrapper!(int[]) b;
//Caught at compile time, as expected
b = null;
//Throws a runtime error
b = [];

So in both cases, the compiler ignores the @disable'd constructor 
and opAssign when called with `[]`. I tried changing them both to 
be templated, which made the "normal" constructor and opAssign 
less specialized than the @disable'd ones. Fortunately, this 
strategy worked... sort of:

struct ArrayWrapper(T)
{
    T t;
        
    this(U)(U u)
    {
        assert(u !is null);
    }

    @disable this(typeof(null));
    @disable this(typeof([]));
        
    typeof(this) opAssign(U)(u val)
    {
        assert(u !is null);
        this.t = val;

        return this;
    }
        
    @disable typeof(this) opAssign(typeof(null));
    @disable typeof(this) opAssign(typeof([]));
}

void main()
{
    //This is caught at compile time
    ArrayWrapper!(int[]) a = null;

    //This is caught at compile time too now. Awesome!
    ArrayWrapper!(int[]) b = [];



    ArrayWrapper!(int[]) a;
    //Caught at compile time
    a = null;

    ArrayWrapper!(int[]) b;
    //Now also caught at compile time
    b = [];
}

My hopes were instantly dashed when I tried the following:

//Compile error. Okay...
ArrayWrapper!(void[]) c = [];

//This is also a compile error
c = cast(void[])[1, 2, 3];



And the same for opAssign:

ArrayWrapper!(void[]) c;
//Compile error
c = [];

//Also a compile error
c = cast(void[])[1, 2, 3];


So as you can see, it's more or less impossible to completely 
catch the assignment of [] to an array at compile time, even 
though it should be perfectly feasible. Is there any way I can 
accomplish this without making ArrayWrapper unusable for void[], 
or is a runtime check the best I can do?