// A bare struct literal `.{ ... }` against an optional target `?T` builds the
// inner `T` and wraps it once — in every caller context: var-decl, function
// argument, return value, a nested `?T` struct field, reassignment, and an
// array element. Previously this filled the optional's {payload, has_value}
// layout directly, corrupting the value (a multi-field payload's first field
// was clobbered by the has_value flag, or a `?T` arg silently read as null) or
// failing LLVM verification on a double wrap.
// Regression (issue 0160).
#import "modules/std.sx";

T :: struct { a: i64 = 0; b: i64 = 0; }
Outer :: struct { opt: ?T = null; tag: i64 = 0; }

take :: (o: ?T) -> i64 { if o != null { return o!.a * 10 + o!.b; } return -1; }
make :: () -> ?T { return .{ a = 5, b = 6 }; }

main :: () -> i64 {
    // var-decl
    v : ?T = .{ a = 3, b = 9 };
    if v != null { print("var: {} {}\n", v!.a, v!.b); }      // 3 9

    // function argument
    print("arg: {}\n", take(.{ a = 4, b = 7 }));             // 47

    // return value
    r := make();
    if r != null { print("ret: {} {}\n", r!.a, r!.b); }      // 5 6

    // nested ?T struct field
    o : Outer = .{ opt = .{ a = 1, b = 2 }, tag = 8 };
    if o.opt != null { print("nested: {} {} {}\n", o.opt!.a, o.opt!.b, o.tag); }  // 1 2 8

    // reassignment
    v = .{ a = 11, b = 12 };
    if v != null { print("reassign: {} {}\n", v!.a, v!.b); }  // 11 12

    // array element
    arr : [2]?T = .[ .{ a = 20 }, .{ a = 21 } ];
    if arr[0] != null { if arr[1] != null { print("arr: {} {}\n", arr[0]!.a, arr[1]!.a); } }  // 20 21

    // array value into an optional-of-slice `?[]T`: the array→slice promotion
    // must run on the child BEFORE wrapping, or `.len`/`.ptr` are corrupted.
    nums : [3]i64 = .[ 1, 2, 3 ];
    os : ?[]i64 = nums;
    if os != null { s := os!; print("optslice: {} {} {}\n", s.len, s[0], s[2]); }  // 3 1 3
    return 0;
}