Make _d_arrayctor weakly pure

[teodutu]

This PR changes _d_arrayctor from a pure function to a weakly pure function.
This change is required because the removal of the _d_arrayctor hook implemented in this PR: dlang/dmd#13116, lowers constructions such as the one below to calls to _d_arrayctor:

struct S {};
const S[2] b;
const S[2] a = b;

The above code is lowered to _d_arrayctor(a, b). For const and immutable arguments, the function is strongly pure, and since its return value is ignored, the compiler might choose to remove the call altogether.

In order to avoid this behaviour, _d_arrayctor has to be made weakly pure, which is what the added 3rd parameter does.

[dlang-bot]

Thanks for your pull request and interest in making D better, @teodutu! We are looking forward to reviewing it, and you should be hearing from a maintainer soon.
Please verify that your PR follows this checklist:

• My PR is fully covered with tests (you can see the coverage diff by visiting the details link of the codecov check)
• My PR is as minimal as possible (smaller, focused PRs are easier to review than big ones)
• I have provided a detailed rationale explaining my changes
• New or modified functions have Ddoc comments (with Params: and Returns:)

Please see CONTRIBUTING.md for more information.

---

If you have addressed all reviews or aren't sure how to proceed, don't hesitate to ping us with a simple comment.

Bugzilla references

Your PR doesn't reference any Bugzilla issue.

If your PR contains non-trivial changes, please reference a Bugzilla issue or create a manual changelog.

Testing this PR locally

If you don't have a local development environment setup, you can use Digger to test this PR:

dub run digger -- build "master + druntime#3587"

[PetarKirov]

@teodutu @RazvanN7 have you considered casting away const/immutable of the argument to inside the frontend, before this function is called?

void _d_arrayctor(T)(return scope T[] to, scope const(T)[] from);

struct S {};
const S[2] b;

const S[2] a = b; // gets lowered to:

const S[2] a = void;
_d_arrayctor!S(cast(S[]) a, b);

Essentially, T should only be instantiated with mutable types.

Also, why does _d_arrayctor need to return anything but unit (void), given that the result written to to?

[teodutu]

@teodutu @RazvanN7 have you considered casting away const/immutable of the argument to inside the frontend, before this function is called?

Not yet, but this might work. Thanks!

Also, why does _d_arrayctor need to return anything but unit (void), given that the result written to to?

This is necessary for constructors where you might do something like this:

struct S
{
    int[3] a, b;
    this (ref int[3] c)
    {
        a = b = c;
        // this would be lowered to: _d_arrayctor(a, _d_arrayctor(b, c))
    }
}

[RazvanN7]

@PetarKirov But isn't that going to make the call to _d_arrayCtor not possible in @safe code?

[RazvanN7]

@PetarKirov see also: https://forum.dlang.org/post/hglpwuvihkfxqcgbwmjb@forum.dlang.org

[RazvanN7]

Please follow-up on deleting the @trusted on the function.