Make __enter__ and __exit__ slots work with "with" statements

The problem was that the "with" statement doesn't use the conventional __getattr__ access, but directly accesses the tp_dict of the type, which usually is empty in PythonQt, so we had to put the __enter__ and __exit__ methods there, too.
And for binding the methods to the instance, tp_descr_get was used in this case, so we had to implement that for slots, too.

Discussed with and reviewed by Florian Link

Author: usiems

src/PythonQt.cpp

@@ -1924,6 +1924,32 @@ void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentT
   if (shell) {
     info->setShellSetInstanceWrapperCB(shell);
   }
+  if (info->typeSlots() & PythonQt::Type_EnterExit) {
+    // context handlers must be handled specially, because optimized accesses
+    // cause that the __enter__ and __exit__ methods will not be found by
+    // conventional means:
+    PyObject* classObj = (PyObject*)info->pythonQtClassWrapper();
+    PyTypeObject* typeObj = (PyTypeObject*)classObj;
+    // __enter__ and _exit__ must be inserted directly into the tp_dict,
+    // otherwise they are not found by "with":
+    PyObject* tp_dict = typeObj->tp_dict;
+    PyObject* enterMethod = PyObject_GetAttrString(classObj, "__enter__");
+    if (enterMethod) {
+      PyDict_SetItemString(tp_dict, "__enter__", enterMethod);
+      Py_DECREF(enterMethod);
+    }
+    PyErr_Clear();
+    PyObject* exitMethod = PyObject_GetAttrString(classObj, "__exit__");
+    if (exitMethod) {
+      PyDict_SetItemString(tp_dict, "__exit__", exitMethod);
+      Py_DECREF(exitMethod);
+    }
+    PyErr_Clear();
+    // invalidate attribute cache for this type:
+    // (as the search for the class methods otherwise cached methods as "not existing", and
+    // we don't want to rely on the wrong empty entries being evicted from the cache by chance):
+    typeObj->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
+  }
 }
 
 PyObject* PythonQtPrivate::packageByName(const char* name)

src/PythonQt.h

@@ -208,6 +208,8 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
     Type_MappingSetItem = 1 << 21,
     Type_MappingGetItem = 1 << 22,
 
+    Type_EnterExit = 1 << 23,
+
     Type_Invert = 1 << 29,
     Type_RichCompare = 1 << 30,
     Type_NonZero     = 1 << 31,

src/PythonQtSlot.cpp

@@ -790,6 +790,20 @@ meth_richcompare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b, i
     Py_RETURN_FALSE;
 }
 
+static PyObject*
+meth_descr_get(PyObject *descr, PyObject *obj, PyObject* type)
+{
+  if (PythonQtSlotFunction_Check(descr)) {
+    PythonQtSlotFunctionObject *slotObj = (PythonQtSlotFunctionObject*)descr;
+    return PythonQtSlotFunction_New(slotObj->m_ml, obj, NULL);
+  }
+  else {
+    // wrong type
+    Py_IncRef(descr);
+    return descr;
+  }
+}
+
 PyTypeObject PythonQtSlotFunction_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "builtin_qt_slot",
@@ -827,6 +841,7 @@ PyTypeObject PythonQtSlotFunction_Type = {
     meth_getsets,       /* tp_getset */
     0,          /* tp_base */
     0,          /* tp_dict */
+    meth_descr_get,     /* tp_descr_get */
 };
 
 /* Clear out the free list */