There is no way to determine the list of classes for which issubclass(C,
x) is true. The MRO of the class is fine for normal inheritance, but for
ABCs it is possible to register classes which don't inherit from the
ABC, so that you have a situation where issubclass (C, MyABC) can be
true without MyABC being in C.__mro__:

>>> import abc
>>> class MyABC(object):
...     __metaclass__ = abc.ABCMeta
...
>>> class C(object):
...     pass
...
>>> MyABC.register(C)
>>> issubclass(C, MyABC)
True
>>> C.__mro__
(<class '__main__.C'>, <type 'object'>)
>>>

This means that ABCs do not play well with the type of introspection
required to implement such features as generic functions - namely
enumeration of the (logical) superclasses of a class.

I don't think this can be solved.  Not only do registered classes not
show up (which could be fixed by providing something like
inspect.getfakemro) but ABCs can also perform duck-type checks.

For example a class with an __iter__ method is an instance of
collections.Iterable or how it's called thanks to the __subclasscheck__
magic method.

Good point! So a documentation patch, to the effect that there is no way
of determining which ABCs a given class is an instance of, would be an
appropriate resolution, I guess.

I suppose it would be a good idea to fix part of that problem in Sphinx
(and probably also in pydoc) by adding something like ":implements:
MutableMapping" in the docstring.

So that this is explicitly added to the docstring and conforming tools
can use this documentation hints.

Similar things are currently implemented in Sphinx for ":param:"
":return:" etc.

While a complete solution isn't possible, at least supporting querying
of explicit registrations would be an improvement over the status quo
(since an implicit registration can always be turned into an explicit
one, but a registration can't always be turned into inheritance).

For this to work in practice, I believe a PEP would be needed to add a
"subscribe" method to ABCMeta instances - this method would accept two
callbacks, one that was called whenever register() was invoked, and a
second when unregister() was invoked. Generic functions which add ABCs
registered could then subscribe to them and update their type caches
appropriately.

This topic came up again on python-ideas:
http://mail.python.org/pipermail/python-ideas/2011-May/010293.html