-aot: a goto past a var declaration emits a C++ goto that bypasses variable initialization (clang++ refuses); a constant-true condition drops the declaration #18

-aot writes a das goto that jumps past a var declaration as a C++ goto past an initialized local, and clang++ refuses the generated file:

error: cannot jump from this goto statement to its label
note: jump bypasses variable initialization

A local with no initializer fails the same way, since the AOT output writes = 0 for it. The interpreter runs the program (it prints 3); the C standard and das both allow the jump (the skipped variable is simply indeterminate until its next store).

Minimal repro, goto_decl.das:

options gen2

var k = 3

def skip_init(n : int) : int {
    if (n > 1) {
        goto label 1
    }
    var g = n * 2
    label 1:
    g = n
    return g
}

[export]
def main : int {
    print("{skip_init(k)}\n")
    return 0
}

daslang goto_decl.das            # prints 3
daslang -aot goto_decl.das       # emits goto_decl.das.cpp; clang++ fails on it with the error above

A second variant: with a constant-true condition in place of n > 1 (so the goto always runs) the AOT optimizer drops the declaration of g but keeps its uses, and the C++ fails with use of undeclared identifier 'g'.

Context: this is the shape C's switch and goto lowerings produce (a jump into a block past a declaration), so the AOT lane of such programs cannot be built; the interpreter, -jit and -exe lanes run them. A workable AOT form is to declare every local the function's labels can bypass at the top of the function (C++ allows jumping past a declaration without an initializer of a trivial type), or to wrap the initialization in a block the goto does not enter.