Built-in array opSliceAssign

[Eduard Staniloiu]

Hello, everyone!

I have a question regarding the expected behaviour of the 
built-in array's opSliceAssign.

Given the following code:

```
import std.stdio;

struct A
{
     int x;

     ref A opAssign(A rhs)
     {
         writefln("slice_bug.opAssign: begin");

         return this;
     }
}

void main(string[] args)
{
     A[] a = [A(1), A(2), A(3)];
     A[] b = [A(2), A(3), A(4)];

     // Expecting opAssign to be called for every element in a
     a[] = b[];

     // In other words, I was under the impression that the above
     // is sintactic-sugar for
     for (size_t i = 0; i < a.lenght; ++i)
     {
         a[i] = b[i]; // This calls opAssign, as expected
     }
}
```

As I wrote in the comments above, I was expecting `a[] = b[]` to 
iterate the slices and assign the elements of b into a.

What really happens is a memcpy: as you can see from godblot [0], 
this gets lowered to a call to `_d_arraycopy`, in druntime.

I'm not sure if this is the intended behaviour, though.
I'm saying this as I've got bitten by this, because I'm doing 
reference counting inside opAssign.

IMHO, this is a bug. The code should lower to calls to opAssing 
for types that define opAssign.

I've also pasted the code on https://run.dlang.io/is/vneELO

[0] - https://godbolt.org/z/_IXCAV