Stage2: false dependency loop

[Vexu]

const S = struct {
    a: *[@sizeOf(S)]u8,
};
test {
    var s: S = undefined;
    _ = s;
}

a.zig:19:10: error: struct 'a.S' depends on itself
    a: *[@sizeOf(S)]u8,
         ^~~~~~~~~~

Should be fixed by implementing lazy pointer types, lazy array types, or both.

[michal-z]

This also fails:

pub const DeviceCallback = *const fn (*Device) void;
pub const Device = struct {
    callback: DeviceCallback,
};
test {
    _ = DeviceCallback;
}

error: dependency loop detected

@Vexu Do you think this is the same bug or should I open a new issue?

[Vexu]

It's the same bug.

[mlugg]

Slight variation on this issue, this example straight-up crashes the compiler:

const Foo = struct {
    ptr: *[1]Foo,
};

test {
    const x: Foo = undefined;
    _ = x;
}

Weirdly, _ = @as(Foo, undefined) works fine - this example seems specifically related to assignment.

[Vexu]

That is a separate bug in the LLVM backend's debug info creation, adding either --fno-LLVM or --strip avoids the crash.

[mlugg]

Ah okay, thank you. Is there an open issue for that bug (just so I can reference it in a comment)?

[Vexu]

Not that I know of.

[mitchellh]

Note as a workaround for this I'm just hand-modifying the cimport.zig to just replace the pointers with anyopaque pointers. I've only had this issue with C imports (probably due to the style of C this sort of reference is common -- I know you can get this in pure Zig too I just haven't seen or written code in practice that does). This works for now!

[somethingelseentirely]

The following also fails:

const std = @import("std");

const node_size = 16;

const Tag = enum(u8) {
    none,
    some
};

pub const Maybe = extern union {
    none: extern struct {
        tag: Tag = .none,
        padding: [node_size - @sizeOf(Tag)]u8 = undefined,
    },
    some: Some,
};

const Body = extern struct {
    maybe: Maybe = Maybe{.none = .{}},
};

const Some = extern struct {
    const padding_len = node_size - (@sizeOf(Tag) + @sizeOf(usize));

    tag: Tag = .some,
    padding: [padding_len]u8 = [_]u8{0} ** padding_len,
    body: *Body,
};


pub fn main() !void {
    std.debug.print("{any}\n", .{@sizeOf(Maybe)});
}

Interestingly when body: *Body, is replaced with body: *Maybe, it compiles fine.