function call with pointer to in-scope comptime var causes a miscompilation

[EEVV]

This code:

const Foo = struct {
    modify_me_i_dare_you: usize,

    pub fn exit(self: *Foo) void {
        self.modify_me_i_dare_you += 1;
    }
};

pub fn main() void {
    comptime var arb = Foo {
        .modify_me_i_dare_you = 0
    };

    arb.exit();
}

results in Segmentation fault.
However this code:

pub fn main() void {
    comptime var modify_me_i_dare_you = 0;
    modify_me_i_dare_you += 1;
}

doesn't result in a Segmentation fault.

$ zig version

0.4.0+24ee7653

[andrewrk]

Thanks for the report. This is a duplicate of #1487

[andrewrk]

Oops, that's not right. Sorry about that. I think your original example should actually compile correctly and not segfault.

[nektro]

this affects stage2 on 0.10.0-dev.4369+1087e6776 as well

changing exit() to be an inline fn makes the code run fine, but the source code as-is still segfaults on the += 1

[andrewrk]

One of two things needs to happen:

• Passing a pointer to an active (in-scope) comptime variable needs to cause the call to become inline.
• The function call, which is happening at runtime, needs to cause the comptime variable to become out of scope and thus turn the pointer into a const pointer (see pointers to "comptime mutable" data should be const pointers outside the comptime scope #1487)

[mlugg]

This fails correctly now thanks to our new comptime var pointer rules (which already have good test coverage):

foo.zig:12:8: error: runtime value contains reference to comptime var
    arb.exit();
    ~~~^~~~~
foo.zig:12:8: note: comptime var pointers are not available at runtime
foo.zig:10:27: note: 'runtime_value' points to comptime var declared here
    comptime var arb = Foo{ .modify_me_i_dare_you = 0 };
                       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~