Segmentation fault compiling field access of comptime struct at comptime

[amp-59]

Zig Version

0.11.0-dev.4059+17255bed4

Steps to Reproduce and Observed Behavior

Compile example program with zig build-obj comptime_state_error.zig
comptime_state_error.zig:

const Features = struct {
    f0: bool = false,
};
const features: *Features = blk: {
    var val: Features = .{};
    break :blk &val;
};
export fn useFeature0() void {
    comptime {
        features.f0 = true;
    }
}

Workaround:

const features_alt = struct {
    const f0: *bool = blk: {
        var val: bool = false;
        break :blk &val;
    };
};
export fn useFeature0Alt() void {
    comptime {
        features_alt.f0.* = true;
    }
}

Expected Behavior

[rohlem]

From what I can tell neither of those examples are supposed to work:

• comptime memory is supposed to become const once it goes out of scope - see make closure over comptime var a compile error; comptime vars become immutable when they go out of scope #7396 .
  In this case, because expressions initializing declarations are evaluated in a comptime context, blk is a comptime block in both cases, therefore var val should become immutable.
  This should in the future trigger a compile error for both examples, mentioning that these variables can only be referred to via pointers-to-const after the scope ends (types *const Features and *const bool in this examples).
• The value a declaration is initialized with in Zig can not be overwritten by a different comptime block.
  However, you can assign to var declarations at runtime.

If you want your example to work as intended by the language, the location that the pointer points to needs to be its own var declaration, and the modification needs to happen at runtime (outside of comptime blocks):

// first example
const Features = struct {
    f0: bool = false,
};
var features_storage: Features = .{};
const features: *Features = &features_storage;
export fn useFeature0() void {
    features.f0 = true;
}

// second example
const features_alt = struct {
    var f0_storage: bool = false;
    const f0: *bool = &f0_storage;
};
export fn useFeature0Alt() void {
    features_alt.f0.* = true;
}

(Note that the pointers are not necessary here; you could remove them and directly assign values to features_storage and features_alt.f0_storage instead.)

[amp-59]

The significance of the source code posted above is that it will crash the compiler.

[Pyrolistical]

This found something similar:

const S = struct {
    fn f(_: @This(), comptime comptime_value: u8) void {
        _ = comptime_value;
    }
};
fn g(comptime comptime_value: u8) void {
    _ = comptime_value;
}

pub fn main() void {
    var runtime_value: u8 = 0;

    const s = S{};
    s.f(runtime_value);

    // this errors correctly
    // g(runtime_value);
}

When running zig build-exe that file, it is expected to error: runtime-known argument passed to comptime parameter, but it segfaults instead.