>>> class Foo: pass
... 
>>> super(Foo) == super(Foo)
False

Will submit a patch later

Why would you need this?   

Also, would it interfere with super's ability to use the __eq__ method for a parent class?

    class A:
        def __eq__(self, other):
            return True

    class B(A):
        def __eq__(self, other):
            return super(B, self).__eq__(other)

    print(B() == B())

This came up as part of a static analysis script that compares sets of method calls, including calls to methods on super(). The check was giving incorrect results because identical super() objects were comparing as different.

super() is documented (https://docs.python.org/3/library/functions.html#super) as only delegating lookups for explicit attribute lookups, not for implicit lookups like that done by the == operator, so I think it would be safe to override tp_richcompare in C on super objects. In writing my patch, I'll be sure to test that the code you gave still works correctly though.

I don't think this should be done.

> I don't think this should be done.

I agree, and I think this issue should be closed.

Though not beautiful, we already have a way to fulfill this rare use case:

    >>> class Foo():
            pass

    >>> s = super(Foo)
    >>> t = super(Foo)
    >>> (s.__self_class__, s.__self__) == (t.__self_class__, t.__self__)
    >>> True

Though awkward to write, it is completely explicit.  That makes it better than giving "s == t" a profoundly different meaning than "s.__eq__(t)".  IMO that would be an API mistake, making it tricky to do code review and requiring special knowledge of a rare corner case.