Runtime segfault in .{ SomeStruct { .field = not_comptime_known } }

[ghost]

tldr This crashes:

    var yes = true;
    var crashes_at_runtime = .{
        SomeStruct { .is_happy = yes },
    };

But not if yes is a const.

---

I have an anonymous list/tuple which contains structs. If I try to initialize a field in one of the structs to something that isn't comptime known (e.g. variable, function call), I get a runtime segfault.

const SomeStruct = struct {
    is_happy: bool,
};

fn getTrue() bool {
    return true;
}

pub fn main() void {
    var works0 = [_]SomeStruct {
        SomeStruct { .is_happy = getTrue() },
    };

    var works1 = struct { _0: SomeStruct } {
        ._0 = SomeStruct { .is_happy = getTrue() },
    };

    var works2 = .{
        SomeStruct { .is_happy = true },
    };

    var crashes_at_runtime = .{
        SomeStruct { .is_happy = getTrue() },
    };
}

Segmentation fault at address 0x204371
/home/dbandstra/host/asdf.zig:23:41: 0x22fff1 in main (run)
        SomeStruct { .is_happy = getTrue() },
                                        ^
/home/dbandstra/zig/build/lib/zig/std/special/start.zig:256:22: 0x22ef8b in std.special.posixCallMainAndExit (run)
            root.main();
                     ^
/home/dbandstra/zig/build/lib/zig/std/special/start.zig:130:5: 0x22ee6f in std.special._start (run)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
Aborted (core dumped)

[ghost]

related but I think not the same: #4597

[devjobe]

The following produces a segmentation fault with 0.7.1 and zig-linux-x86_64-0.8.0-dev.1431+c760532be

    var x : i32 = 1;
    var y = .{ .{ x } };

Looks similar but I've only used zig for a couple of hours.

[MichaelBelousov]

The following code seems to have the same segfault but only when the runtime value is heap allocated

const E  = union(enum) { e: []const u8 };
const W = union(enum) { w: E };
test "bad" {
    const e = try std.testing.allocator.create(E);
    e.* = E{.e="test"};
    const w = .{ W{ .w=e.* }, }; // SIGSEGV here
    _ = w;
}

if you instead point e to some stack allocated E, it will not segfault at runtime