Alright, so I wrote a little test case:

```D
struct S
{
    int i = 5;
    this() @disable;
    this(this){writefln("postblit %s", this.i);}
    void opAssign(S other){writefln("opAssign: %s => %s", other.i, this.i);}
    ~this(){writeln("destructor");}
}

mixin template constructor(T)
{
    this(TypeTuple!(T, T, T) values)
    {
        writefln("begin %s construction", typeof(this).stringof);
        foreach(i, ref value; values)
            data[i] = value;
            //emplace(&data[i], value);
        writefln("end %s construction", typeof(this).stringof);
    }
}

struct S1
{
  TypeTuple!(S, S, S) data = void;
  mixin constructor!S;
}
struct S2
{
  S[3] data = void;
  mixin constructor!S;
}
struct CS1
{
  const TypeTuple!(int, int, int) data/+ = void+/;
  mixin constructor!int;
}
struct CS2
{
  const int[3] data/+ = void+/;
  //mixin constructor!int; //Error: multiple field data initialization
}

void main()
{
    S1  s1  = S1 (S(), S(), S());
    S2  s2  = S2 (S(), S(), S());
    CS1 cs1 = CS1(1, 2, 3);
    //CS2 cs2 = CS2(1, 2, 3);
}
```
Produces:
```
begin S1 construction
postblit 5
postblit 5
postblit 5
end S1 construction
destructor
destructor
destructor
begin S2 construction
postblit 5
postblit 5
opAssign: 5 => 0
destructor
postblit 5
opAssign: 5 => 0
destructor
end S2 construction

...
```

Observations for S1 and S2:
- S1 is correctly initialized with 3 calls to postblit (yay!).
- S2 makes *2* (wtf?) calls to opAssign, and 3 calls to postblits. The calls to postblit are correct, but we can see the opAssigns are called *on* "0", which means calls on "not yet initialized" :/ So those calls are definitely wrong. I *think* the compiler considers the *first* assignement as an "initialization" of the entire array, and postblits, but makes actual opAssign calls for the subsequent assignements (see bellow).

More observations: Using `emplace` is correct in both cases. Regardless of what we do, the fact that `S` has a disabled `this()` is not a problem

Observations for CS1 and CS2: As expected, CS2 does not work: Indeed, the compiler complains that you are writing the same field more than once. This explains the *2* calls to opAssign above. CS1 is fine though: Interesting facts though:
- emplace works for neither CS1 or CS2: This is a *deliberate* limitation of emplace.
- if we make the fields void, then the compiler will *refuse* to assign to them at all, as it feels they are actually already initialized :/

--------

Conclusion: Static arrays suck. Sorry I asked you to use them. Given you actually *wrote* RepeatType, you might as well just use one of those.

Also, I need to file that const void initialization issue.