"error: Global variable contains reference to comptime var" when it shouldn't

[mattnite]

Zig Version

0.12.0-dev.3475+71d878ba5

Steps to Reproduce and Observed Behavior

1. Clone https://github.com/ZigEmbeddedGroup/microzig.git
2. Check out zig-master branch
3. Build with zig build -Doptimize=ReleaseSmall

Expected Behavior

I expected it to compile without error. Here is one of the failing examples, each is a use of rp2040.pio.assemble():

const squarewave_program = blk: {
    @setEvalBranchQuota(2000);
    break :blk rp2040.pio.assemble(
        \\;
        \\; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
        \\;
        \\; SPDX-License-Identifier: BSD-3-Clause
        \\;
        \\.program squarewave
        \\    set pindirs, 1   ; Set pin to output
        \\again:
        \\    set pins, 1 [1]  ; Drive pin high and then delay for one cycle
        \\    set pins, 0      ; Drive pin low
        \\    jmp again        ; Set PC to label `again`
    , .{}).get_program_by_name("squarewave");
};

This uses a comptime assembler that has been correctly working for about a year, including the embedded Zig workshop I ran in the Vancouver SYCL conf (Fun fact, this comptime assembler was part of getting the sound to work for the synthesizers). Despite it sounding insane, it's implemented sanely. There are two uses of comptime var under rp2040.pio.assemble() and removing them produces the same error message so AFAICT this is a compiler bug.

[mlugg]

I'm 99% sure there isn't a compiler bug here -- looking at that MicroZig code, you're constructing a big aggregate at comptime, and you'll have to make sure to copy everything to immutable memory. I'll take a look tomorrow and try to get the examples working.

[Avokadoen]

I am also hitting this issue on code that has been working for +2 years now

[Avokadoen]

So for me the issue seems to be that I am using local comptime vars to loop over some reflection info. From there I store the comptime vars in a comptime const struct. I think the error is wrong as the comptime var is only local to the initialization function. The resulting values should be stored in the struct afterwards which never mutates.

/// perform compile-time reflection on systems to extrapolate information about registered systems
pub fn createSystemInfo(comptime system_count: comptime_int, comptime systems: anytype) SystemInfo(system_count) {
    const SystemsType = @TypeOf(systems);
    const systems_type_info = @typeInfo(SystemsType);
    const fields_info = systems_type_info.Struct.fields;

    comptime var depend_on_indices_used: usize = 0;
    comptime var depend_on_index_pool: [system_count * system_count]u32 = undefined;
    comptime var metadata: [system_count]SystemMetadata = undefined;
    comptime var function_types: [system_count]type = undefined;
    comptime var functions: [system_count]*const anyopaque = undefined;
    {
        comptime var i: usize = 0;
        inline for (fields_info, 0..) |field_info, j| {
            switch (@typeInfo(field_info.type)) {
               /// lots of spaghetti 
            }
        }
    }
    return SystemInfo(system_count){
        .depend_on_indices_used = depend_on_indices_used,
        .depend_on_index_pool = depend_on_index_pool,
        .metadata = metadata,
        .function_types = function_types,
        .functions = functions,
    };
}

Then anytime the function gets called in a comptime scope I get a compiler error:

src\meta.zig:409:50: error: global variable contains reference to comptime var
        pub const systems_info = comptime createSystemInfo(system_count, systems);
                                 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~

[Vexu]

The issue is using mutable slices:

diff --git a/bsp/raspberrypi/rp2040/src/hal/pio/assembler.zig b/bsp/raspberrypi/rp2040/src/hal/pio/assembler.zig
index 6c6be6f..2caff67 100644
--- a/bsp/raspberrypi/rp2040/src/hal/pio/assembler.zig
+++ b/bsp/raspberrypi/rp2040/src/hal/pio/assembler.zig
@@ -86,9 +86,9 @@ pub fn assemble_impl(comptime source: []const u8, diags: *?Diagnostics, options:
                     .name = define.name,
                     .value = define.value,
                 }) catch unreachable;
-            break :blk tmp.slice();
+            break :blk tmp.sliceConst();
         },
-        .programs = programs.slice(),
+        .programs = programs.sliceConst(),
     };
 }
 
diff --git a/bsp/raspberrypi/rp2040/src/hal/pio/assembler/encoder.zig b/bsp/raspberrypi/rp2040/src/hal/pio/assembler/encoder.zig
index cc994cd..eaa8b54 100644
--- a/bsp/raspberrypi/rp2040/src/hal/pio/assembler/encoder.zig
+++ b/bsp/raspberrypi/rp2040/src/hal/pio/assembler/encoder.zig
@@ -78,22 +78,24 @@ pub fn Encoder(comptime options: Options) type {
             pub fn to_exported_program(comptime bounded: BoundedProgram) assembler.Program {
                 comptime var program_name: [bounded.name.len]u8 = undefined;
                 std.mem.copyForwards(u8, &program_name, bounded.name);
+                const name_const = program_name;
                 return assembler.Program{
-                    .name = &program_name,
+                    .name = &name_const,
                     .defines = blk: {
                         var tmp = std.BoundedArray(assembler.Define, options.max_defines).init(0) catch unreachable;
                         for (bounded.defines.slice()) |define| {
                             comptime var define_name: [define.name.len]u8 = undefined;
                             std.mem.copyForwards(u8, &define_name, define.name);
+                            const const_def_name = define_name;
                             tmp.append(.{
-                                .name = &define_name,
+                                .name = &const_def_name,
                                 .value = @as(i64, @intCast(define.value)),
                             }) catch unreachable;
                         }
 
-                        break :blk tmp.slice();
+                        break :blk tmp.sliceConst();
                     },
-                    .instructions = @as([]const u16, @ptrCast(bounded.instructions.slice())),
+                    .instructions = @as([]const u16, @ptrCast(bounded.instructions.sliceConst())),
                     .origin = bounded.origin,
                     .side_set = bounded.side_set,
                     .wrap_target = bounded.wrap_target,

[mattnite]

@Vexu the issue persists after applying that fix and fixing the function names

[mlugg]

The sliceConst values (as in, the arrays they reference) will have to be copied into local consts and those consts referenced to get a truly constant slice.

@Vexu, sliceConst is just returning a []const T corresponding to the same memory -- that doesn't impact this error message. To avoid this error, the backing memory has to be immutable. The reasons are a little subtle, but my Ziggit post on the changes summarises it fairly well.

[Vexu]

Ah, I didn't notice I was editing the std lib. Here's the diff for sliceConst as well:

diff --git a/lib/std/bounded_array.zig b/lib/std/bounded_array.zig
index d41857013c..6ee8633c61 100644
--- a/lib/std/bounded_array.zig
+++ b/lib/std/bounded_array.zig
@@ -60,6 +60,17 @@ pub fn BoundedArrayAligned(
             return self.buffer[0..self.len];
         }
 
+        pub fn sliceConst(self: anytype) switch (@TypeOf(&self.buffer)) {
+            *align(alignment) [buffer_capacity]T => []align(alignment) const T,
+            *align(alignment) const [buffer_capacity]T => []align(alignment) const T,
+            else => unreachable,
+        } {
+            var foo: [self.len]T = undefined;
+            @memcpy(&foo, self.buffer[0..self.len]);
+            const bar = foo;
+            return &bar;
+        }
+
         /// View the internal array as a constant slice whose size was previously set.
         pub fn constSlice(self: *const Self) []align(alignment) const T {
             return self.slice();

Note that it's not constSlice which I also didn't notice.

[mlugg]

You don't need the var in there, just:

const final = self.buffer[0..self.len].*;
return &final;

[Vexu]

For some types it complains about the struct not having defined memory layout. That's why the@memcpy is there as well.

[mlugg]

Ah, that's #19452.