(In reply to Vladimir Panteleev from comment #1)
> Reduced:
>
> //////// test.d ////////
> struct NullableRef(T)
> {
> inout(T) get() inout
> {
> assert(false);
> }
>
> alias get this;
> }
>
> struct Node
> {
> NullableRef!Node n;
> }
> ////////////////////////
An infinite recursive analysis happens in the implicitly generated member function:
bool Node.__xopEquals(ref const Node p, ref const Node q)
{
return p == q;
}
The equality test p == q is expanded to p.tupleof == q.tupleof, and it's equivalent with p.n == q.n.
Because of the alias-this definition in NuallbeRef!Node, the comparison is delegated to the return of get member function, then it's rewritten to p.n.get() == q.n.get(). Finally, we'll go into an endless circle.
Now I have a local patch to detect the circle. But I'm yet not sure how compiler should work for the following code.
void main()
{
Node node;
assert(node == node); // ?
}
I think the Node equality should be either:
1. make an error
2. implicitly fallback to bitwise comparison