Prevent self-comparison without taking the address

[Jonathan M Davis]

On Thursday, July 25, 2024 4:50:04 AM MDT Dom DiSc via Digitalmars-d-learn 
wrote:
> I have copied some source from C++, where the following pattern
> is common (operator== already renamed):
>
> ```d
> @safe:
> struct S
> {
>     bool opEquals(const ref S x) const
>     {
>        if(&x==&this) return true;
>        ...
>     }
> }
> ```
>
> Can I replace this pattern with ```(x is this)``` or are there
> some special cases where this doen't work?

If you want to do that, that's basically what you would need to do. However,
I've never seen anyone do that with structs in D. They're usually put on the
stack and passed around by value. They are of course sometimes passed by
reference, but that's usually going to be to a variable on the stack, making
comparing addresses kind of pointless, since you'd usually need to be doing
something like x == x to end up comparing the same object against itself.

Pretty much the only time that something like this might make sense is when
you're dealing with pointers to structs, which of course is done sometimes,
but it's much less common than it would be in C++, since D separates classes
and structs. And classes already do that check with ==, since it's lowered
to a free function, opEquals, before calling the class' opEquals, and it
does stuff like compare the address of the class reference and compare
against null.

Either way, the fact that the this member for structs is a reference rather
than a pointer means that if you want to compare addresses, you'll need to
take the addresses - which won't be @safe without DIP 1000, because taking
the address of a local variable is not @safe without the tracking that DIP
1000 adds via scope (since without the extra checks, you could easily take
that address and pass it around, letting it escape the lifetime of the
reference).

- Jonathan M Davis