On Sunday, 7 November 2021 at 14:38:14 UTC, Alexandru Ermicioi wrote:

Actually I had in mind the simple fact to read array properties.

Good news, it turns out that this point is not valid, in both cases optimizers (must be the common subexpression optim) only read the property once (according to this).

I mean it must use the AST of the new templatized struct.

Because versions are not part of the mangle, so when you link you don't know if what's been generated in a *.o has bound checks activated or not.

On Sunday, 7 November 2021 at 16:07:19 UTC, Teodor Dutu wrote:

void-initialize your to-be-returned array in _d_arrayctor? Which BTW should also bring your attention to the fact that such a function can never be @trusted, and can only be as @safe as the actual ctor calls it would defer to.

On Sunday, 7 November 2021 at 17:01:20 UTC, Stanislav Blinov wrote:

Won't this be the same as doing this:

T[] to;  // to be returned
to.length = length;

The problem with this approach is that to isn't NRVO'd because the lowering to _d_arrayctor is only done for static arrays.

I used @trusted because some unittests that used this lowering were @safe. It was a compile-time workaround.

On Sunday, 7 November 2021 at 17:47:45 UTC, Teodor Dutu wrote:

T[] to;  // to be returned
to.length = length;

??? No, it will not. The problem in your

Tarr1 _d_arrayctor(Tarr1 : T1[], Tarr2 : T2[], T1, T2)(scope Tarr2 from)
{
    Tarr1 to;
    // ...
    return to;
}

is the default initialization. S from the unittest is a nested struct, and can't be instantiated outside of scope of its parent. But this should work:

// Obviously concrete implementation would be generic here, and copy/blit accordingly. This one explicitly calls copy ctor for illustration purposes only.
Tarr1 _d_arrayctor(Tarr1 : T1[], Tarr2 : T2[], T1, T2)(scope Tarr2 from)
{
    // Infer @safe-ty from an actual ctor.
    // Note that is is a nuclear option. Ideally you'd check a trait,
    // something like isSafeCopyable!(T1, T2), which would need to be defined,
    // so that no code gets emitted here regardless of build options
    if (false) { T1* a; T2* b; (*a).__ctor(*b); }
    return () @trusted
    {
        Tarr1 to = void;
        foreach (i, ref it; to)
            it.__ctor(from[i]);
        return to;
    } ();
}

void main() @safe
{
    int counter;
    struct Nested
    {
        this(return ref scope typeof(this) n) { /* ... */ }
        ~this() { ++counter; }
    }

    Nested[3] arr1;
    Nested[3] arr2 = _d_arrayctor!(typeof(arr1))(arr1);
}

? It should pass unittests without lying to the compiler, by correctly inferring @safe-ty.

On Sunday, 7 November 2021 at 18:15:53 UTC, Stanislav Blinov wrote:

Tarr1 _d_arrayctor(Tarr1 : T1[], Tarr2 : T2[], T1, T2)(scope Tarr2 from)
{
    Tarr1 to;
    // ...
    return to;
}

[...]
Tarr1 to = void;
[...]

Thanks a lot! It worked.

Yes, you're right. @trusted was more of a stop-gap solution in order to get the code to work in the first place. Now that it does, I should look into a nicer way of having @safe-ty inferred. I'll probably follow your advice here, too. Thanks again!