Improved error message for metaclass incompatibility

[AsgerJon]

Summary

This PR adds context to the metaclass conflict error message along with clear terminology.

Motivation

Class inheritance in OOP has well-established terminology conventions across languages, none of which should be used to describe the custom metaclass introduced by Python. This PR proposes to distinguish between them by the following convention:

• A class is derived from its metaclass
• A class is based on its base classes

This convention is then reflected in the proposed error message raised by metaclass conflicts.

Example

In the example below, MetaFoo and MetaBar are both subclasses of type and neither is a (non-strict) subclass of the other. Foo is a class derived from MetaFoo, and Bar attempts to be derived from MetaBar while also based on Foo, revealing the incompatibility between MetaFoo and MetaBar:

class MetaFoo(type):  pass

class MetaBar(type): pass

class Foo(metaclass=MetaFoo):  pass

class Bar(Foo, metaclass=MetaBar):  pass  # raises

Behaviour Before

Previously, the resulting TypeError would show:

TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

Behaviour After

This pull request attempts to improve with:

Metaclass conflict while defining class: 'Foo'
- Declared metaclass: 'MetaFoo'
- Incompatible base class: 'Bar'
- That base is derived from metaclass: 'MetaBar'
All base classes must be based on classes derived from the same metaclass or a subclass thereof.

Conclusion

This PR hopes to contribute to the ongoing effort towards better error messages, whilst reinforcing clear and consistent terminology.

[python-cla-bot]

All commit authors signed the Contributor License Agreement.

[ZeroIntensity]

We don't need this file, you can go ahead and delete it.

[ZeroIntensity]

Thanks for contributing :)

High level, I'm not sure I like this change. We typically try to keep error messages on the shorter side, and putting newlines in them hurts some use-cases (e.g., when people are writing error messages to log files). Would you mind creating an issue explaining some of the rationale here?

Also, please don't force push. We squash merge at the end, and it ends up just making the bot louder.

[ZeroIntensity]

Suggested change

	bases,name);
	bases, name);

[ZeroIntensity]

PyObject_GetAttrString sets an exception when it fails, so we might try and invoke the eval loop in the subsequent calls, which isn't safe. It needs to be in a pattern like this:

PyObject *first_attr = PyObject_GetAttrString(whatever, "first_attr");
if (first_attr == NULL) {
    return NULL;
}
PyObject *second_attr = PyObject_GetAttrString(whatever, "second_attr");
if (second_attr == NULL) {
    Py_DECREF(first_attr);
    return NULL;
}

/* ... */

Py_DECREF(first_attr);
Py_DECREF(second_attr);

[ZeroIntensity]

You can use PyErr_Format instead of manually creating the string.

[ZeroIntensity]

I don't think we have to manually convert this to a string. PyUnicode_FromFormat (or PyErr_Format) accept C strings with the %s format specifier.

[AsgerJon]

It occurs to me that not including the intended name of the class allows for a much simpler implementation of the improved error message. I will close this pull request, open an issue and then submit a new pull request not including the name of the class in the error message.