Stage 1 ir_analyze_container_member_access_inner panic

[AnneKitsune]

Reproduction:

const Dispatcher = struct {
    systems: anytype,
    fn doSomething(comptime this: *const @This()) void {
        for (this.systems) |sys| {
        }
    }
};

pub fn main() anyerror!void {
    // init separately, because if we do it inside of the struct
    // init it will show an unclear error (#9141)
    const systems = .{5, 6};
    const dispatcher = Dispatcher {
        .systems = systems,
    };
    dispatcher.doSomething();
}

Error:

zig run src/main.zig
Assertion failed at /home/jojolepro/.cache/yay/zig-git/src/zig/src/stage1/ir.cpp:14690 in ir_analyze_container_member_access_inner. This is a bug in the Zig compiler.thread 48199 panic:
Unable to dump stack trace: debug info stripped
zsh: abort (core dumped)  zig run src/main.zig

I get the same output using zig run -O Debug src/main.zig.

Expected: Probably an error, but I'm not sure what the exact behavior should be here.

Version:
0.9.0-dev.187+bfe3558ef

[AnneKitsune]

I learned a bit more of the language and I think the issue is that anytype is allowed in the struct fields when it shouldn't be. Is this correct @Vexu ?

[Vexu]

I don't see any reason for the anytype field not to be allowed here, the stage1 implementation is just buggy.

[UgiNyaa]

A reason for not allowing anytype in structs could be because of its ambiguity. Take the following example:

const std = @import("std");

const Dispatcher = struct {
    systems: anytype,
    fn doSomething(comptime this: *const @This()) void {
        for (this.systems) |sys| {
        }
    }
};

test {
    const systems1 = .{5, 6};
    const dispatcher1 = Dispatcher {
        .systems = systems1,
    };
    const systems2 = 5;
    const dispatcher2 = Dispatcher {
        .systems = systems2,
    };

    try std.testing.expect(@TypeOf(dispatcher1) != @TypeOf(dispatcher2));
}

Would you expect this to fail or to succeed? I would expect this to succeed and that the types of dispatcher1 and dispatcher2 are not equal, since they would have different sizes. In the current implementation (version 0.8.0), this test fails.

Another example:

test {
    const systems1 = .{5, 6};
    const dispatcher1 = Dispatcher {
        .systems = systems1,
    };
    const systems2 = 5;
    const dispatcher2 = Dispatcher {
        .systems = systems2,
    };

    try std.testing.expect(@TypeOf(dispatcher1) != Dispatcher);
    try std.testing.expect(@TypeOf(dispatcher2) != Dispatcher);
}

Would you expect this to fail or to succeed? This question is a lot more though, since dispatcher1 and dispatcher2 were created with the same Dispatcher type, but they have different sizes. I am unsure but I think I would expect this test to succeed (partially because I expected the last test to succeed, and transitivity is a defining feature for equality). In the current implementation (version 0.8.0), this test fails.

Alternative

I think the right way to do something like this is to use generics:

fn Dispatcher(comptime T: type) type {
    return struct {
        systems: T,
        fn doSomething(comptime this: *const @This()) void {
            inline for (this.systems) |sys| {
            }
        }
    };
}

test {
    const systems = .{5, 6};
    const dispatcher = Dispatcher(@TypeOf(systems)) {
        .systems = systems,
    };

    dispatcher.doSomething();
}

NOTE: I added inline before the for loop, because it is dealing with a tuple. See https://ziglang.org/documentation/0.8.0/#Anonymous-Struct-Literals

This removes the problem of the Dispatcher being a type with an unknown size. Rather, its a function returning a type with a known size.

[saltzm]

I ran into this as well. In my case I had a function with an anytype parameter and some other parameters that I wanted to refactor to group into a struct.

Link to the crashing case in godbolt

Link with some workarounds using a function returning a type

[AnneKitsune]

Zig master returns a proper error:

/tmp/hen/src/main.zig:7:58: error: expected type expression, found 'anytype'
fn fooWithStructArgs(comptime request: struct { printer: anytype, i: u32, j: u32}) void {

Closing the issue :)

[nektro]

yeah anytype fields were removed from Zig in #10766