Changing cls.__bases__ must ensure proper metaclass inheritance

[abusalimov]

BPO	21919
Nosy	@gvanrossum, @rhettinger, @tirkarthi

^{Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.}

Show more details

GitHub fields:

assignee = 'https://github.com/gvanrossum'
closed_at = None
created_at = <Date 2014-07-04.20:45:25.320>
labels = ['interpreter-core', 'type-bug', '3.8']
title = 'Changing cls.__bases__ must ensure proper metaclass inheritance'
updated_at = <Date 2018-09-28.18:34:40.580>
user = 'https://bugs.python.org/abusalimov'

bugs.python.org fields:

activity = <Date 2018-09-28.18:34:40.580>
actor = 'gvanrossum'
assignee = 'gvanrossum'
closed = False
closed_date = None
closer = None
components = ['Interpreter Core']
creation = <Date 2014-07-04.20:45:25.320>
creator = 'abusalimov'
dependencies = []
files = []
hgrepos = []
issue_num = 21919
keywords = []
message_count = 6.0
messages = ['222312', '236753', '237072', '326532', '326650', '326651']
nosy_count = 4.0
nosy_names = ['gvanrossum', 'rhettinger', 'abusalimov', 'xtreak']
pr_nums = []
priority = 'normal'
resolution = None
stage = None
status = 'open'
superseder = None
type = 'behavior'
url = 'https://bugs.python.org/issue21919'
versions = ['Python 3.8']

[abusalimov]

When a new class is constructed Python checks for possible metaclass conflicts within bases and an explicitly specified one, if any, choosing the best available (the most specialized) one. That is the following implication is expected:

issubclass(B, A) => issubclass(type(B), type(A))

However, changing __bases__ attribute can break this invariant silently without an error.

>>> class O(object):
...     pass
... 
>>> class M(type):
...     pass
... 
>>> class N(type):
...     pass
... 
>>> class A(O, metaclass=M):
...     pass
... 
>>> class B(O, metaclass=N):
...     pass
... 
>>> B.__bases__ = (A,)
>>> B.__mro__
(<class '__main__.B'>, <class '__main__.A'>, <class '__main__.O'>, <class 'object'>)
>>> type(B)
<class '__main__.N'>
>>> type(A)
<class '__main__.M'>
>>> issubclass(B, A)
True
>>> issubclass(type(B), type(A))
False

Trying to derive from B now makes things look pretty weird:

>>> class C(A, metaclass=N):
...     pass
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
>>> class D(B, A): pass
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
>>> class E(B, metaclass=N):
...     pass
... 
>>> type(E)
<class '__main__.N'>

That is one can extend a class but not its base (and not a class along its base). This effectively allows to bypass metaclass checks (by introducing a dummy class with the default metaclass, deriving it from a desired class with an inappropriate metaclass by changing __bases__ and using it instead of the desired class).

This behavior is observed in 2.7, 3.2 and 3.4.

I would expect the same check for metaclass conflicts when changing __bases__ as upon creating a new class:

>>> # EXPECTED:
... 
>>> B.__bases__ = (A,)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

[BreamoreBoy]

@eldar sorry that this issue slipped our net.

[abusalimov]

@mark, that OK, for the issue without a patch. :)

I could make a patch, but I'm not sure whether the proposed behavior is right. It could be considered arguable, I guess...

[tirkarthi]

Thanks for the report and patience. This behavior is still reproducible on master as of f55c64c . I am adding Raymond as part of triaging who might have a better explanation about this. Raymond, feel free to remove yourself if this is not relevant.

A slightly cleaned up version of the program with repl statements removed for reference :

class O(object):
     pass

class M(type):
     pass

class N(type):
     pass

class A(O, metaclass=M):
     pass

class B(O, metaclass=N):
     pass

print(B.__bases__)
print(B.__mro__)

print(type(B))
print(type(A))
print(issubclass(type(B), type(A)))

class C(A, metaclass=N):
     pass

class D(B, A):
     pass

class E(B, metaclass=N):
     pass

[rhettinger]

I am adding Raymond as part of triaging who might have a better explanation about this.

Guido, is this something we care about? There is value in checking for metaclass conflicts when a class is created (to catch plausible mistakes and to assure that the right __new__() and __init__() methods run). But post-creation, it's unclear whether there is value in rerunning checks and whether its even possible to know how other base classes might have affected the class creation.

Do this go in the "consenting adults" category (in the same way that we allow the __class__ attribute to be changed on instances without trying to verify whether it makes sense)?

[gvanrossum]

As long as you can't crash CPython with this, this is the responsibility of the code that assigns to __bases__. If they don't take care, the program's behavior is undefined.