core.internal.array.construction

@trusted Tarr _d_arrayctor(Tarr : T[], T)(return scope Tarr to, scope Tarr from, char* makeWeaklyPure = null);

Does array initialization (not assignment) from another array of the same element type.

Parameters:

Tarr to	what array to initialize
Tarr from	what data the array should be initialized with
char* makeWeaklyPure	unused; its purpose is to prevent the function from becoming strongly pure and risk being optimised out

Returns:

The created and initialized array to

Bugs:

This function template was ported from a much older runtime hook that bypassed safety, purity, and throwabilty checks. To prevent breaking existing code, this function template is temporarily declared @trusted until the implementation can be brought up to modern D expectations.

The third parameter is never used, but is necessary in order for the function be treated as weakly pure, instead of strongly pure. This is needed because constructions such as the one below can be ignored by the compiler if _d_arrayctor is believed to be pure, because purity would mean the call to _d_arrayctor has no effects (no side effects and the return value is ignored), despite it actually modifying the contents of a. const S[2] b; const S[2] a = b; // this would get lowered to d_arrayctor(a, b)

@trusted void _d_arraysetctor(Tarr : T[], T)(scope Tarr p, ref scope T value);

Do construction of an array. ti[count] p = value;

Parameters:

Tarr p	what array to initialize
T value	what data to construct the array with

Bugs:

This function template was ported from a much older runtime hook that bypassed safety, purity, and throwabilty checks. To prevent breaking existing code, this function template is temporarily declared @trusted until the implementation can be brought up to modern D expectations.

pure nothrow @trusted T[] _d_newarrayUPureNothrow(T)(size_t length, bool isShared = false);

@trusted T[] _d_newarrayT(T)(size_t length, bool isShared = false);

Allocate an array with the garbage collector. Also initalize elements if their type has an initializer. Otherwise, not zero-initialize the array.

Has three variants: _d_newarrayU leaves elements uninitialized _d_newarrayT initializes to 0 or based on initializer

Parameters:

size_t length

.length of resulting array

Returns:

newly allocated array

@trusted Tarr _d_newarraymTX(Tarr : U[], T, U)(size_t[] dims, bool isShared = false);

Create a new multi-dimensional array. Also initalize elements if their type has an initializer. Otherwise, not zero-initialize the array.

void main()
{
    S[][] s = new S[][](2, 3)

    // lowering:
    S[] s = _d_newarraymTX!(S[][], S)([2, 3]);
}

Parameters:

size_t[] dims	array length values for each dimension
bool isShared	whether the array should be shared

Returns:

newly allocated array