As-late-as-possible qubit initialization

[perlinm]

I have a question regarding the initialization of qubits. Say, for example, that I have a guppy function that instantiates an ancilla qubit, as in

@guppy
def do_something(qubits: array[qubit, N]) -> ...:
    ancillas = array(qubit(), qubit(), qubit())
    ...  # operations on qubits + ancillas
    return measure_array(ancillas)

Am I guaranteed that this ancilla will be instantiated as late as possible to avoid the accumulation of memory errors? I ask because I have seen some code written by people at Quantinuum running experiments on Helios, which would always do things like

@guppy
def do_something(qubits: array[qubit, N]) -> ...:
    ancillas = array(qubit(), qubit(), qubit())
    barrier(qubits)
    for i in range(3):
        reset(ancillas[i])
    ...  # operations on qubits + ancillas
    return measure_array(ancillas)

When asked, I was told that this was done to enforce that ancillas are "fresh" when they are needed, since otherwise the compiler may decide to instantiate them much earlier than I might expect. It seems to me, though, that ensuring as-late-as-possible instantiation of ancilla qubits should be the job of the compiler. Does the compiler do this?

[ss2165]

Using barriers ensures that compiler behaviour, otherwise it is not guaranteed and other optimisation concerns might result in sub-optimal behaviour.

[matt-decross]

Please note that you would likely need barrier(qubits, ancillas) to enforce this behavior at the moment, not just barrier(qubits).

[perlinm]

Re: barrier(qubits, ancillas), noted!

Getting back to the compiler and populating fresh qubits, though, it seems to me like as-late-as-possible scheduling of qubit initialization should be the "natural" / default behavior. The benefits seem (to me) obvious and ubiquitous. Is this something that can be built into the compiler? Are there any particular roadblocks, or reasons to have different behavior?