support two structs with recursive optional references

[CurtisFenner]

The following causes zig test to exit unsuccessfully without printing any output on Windows 10 x64, zig 0.4.0+fcc0728:

const Alpha = struct {
    beta: Beta,
};

const Beta = struct {
    Alpha: *?Alpha,
};

test "crashes" {
    const a = Alpha;
}

The crash also happens if the second field declaration is instead Alpha: ?Alpha (without the pointer indirection), which is a slightly smaller test case. But I also wanted to demonstrate the crash on what I believe is a correct program

[CurtisFenner]

For reference, here's a slightly-less reduced piece of the code I was trying to write when I hit this:

pub const Block = struct {
    statements: []const Statement,
};

pub const Statement = union(enum) {
    DoSt: *const DoSt,
    IfSt: *const IfSt,
};

pub const DoSt = struct {
    expression: Expression,
};

pub const IfSt = struct {
    condition: Expression,
    then_body: Block,
    else_clause: ?ElseClause,
};

pub const ElseClause = struct {
    body: Block,
};

pub const Expression = struct {};

test "use a block" {
    var block = Block.foo;
}

This doesn't do anything dubious like a pointer to an optional.

[daurnimator]

Related to #1735

[andrewrk]

After #2174, this is now a compile error instead of a crash:

/home/andy/dev/zig/build/test.zig:1:15: error: struct 'Alpha' depends on itself
const Alpha = struct {
              ^
/home/andy/dev/zig/build/test.zig:6:13: note: referenced here
    Alpha: *?Alpha,
            ^
/home/andy/dev/zig/build/test.zig:6:5: note: referenced here
    Alpha: *?Alpha,
    ^

So this issue is now to improve lazy values a bit more so that this case is handled.

[CurtisFenner]

I'm a bit confused by the current state of this.

This works fine:

const Bin = struct {
    value: usize,
    left: ?*Bin,
    right: ?*Bin,
};

but this doesn't:

const Bin = struct {
    value: usize,
    left: ?*Bin,
    right: [1]?*Bin,
};

Is this an oversight, or is there actually something different between these two versions?

[courtc]

There seems to be a remaining issue related to arrays of self referencing pointers, optional or not.
Seems directly related, and likely the issue @CurtisFenner is referring to.

const Node = struct {
    links: [2]?*@This(),
};

.../test/sr.zig:2:18: error: struct 'Node' depends on itself
    const Node = struct {
                 ^
.../test/sr.zig:3:19: note: referenced here
        links: [2]?*@This(),
               ^

[zackpete]

I ran into a similar issue that causes a segfault on v0.9.1

  _ = struct {
      const n = 1;

      const Node = struct {
          children: *[n]Node,
      };

      root: *Node,
  };

I get a compiler error when I make children optional

[nektro]

issue snippet passes on master now