Make provided/implementedBy and adapter registries respect super().

The query functions now start by looking at the next class in the MRO (interfaces directly provided by the underlying object are not found).

Adapter registries automatically pick up providedBy change to start finding the correct implementations of adapters, but to make that really useful they needed to change to unpack super() arguments and pass __self__ to the factory.

Fixes #11

Unfortunately, this makes PyPy unable to build the C extensions.

Additional crash-safety for adapter lookup.

Make the C functions get the cache only after resolving the
``required`` into a tuple, in case of side-effects like...clearing the
cache. This could lead to the ``cache`` object being deallocated
before we used it.

Drop the ``tuplefy`` function in favor of a direct call to
``PySequence_Tuple``. It's what the ``tuple`` constructor would do
anyway and saves a few steps.

Make sure that getting ``providedBy(super())`` and
``implementedBy(super())`` have no side effects.

.travis.yml

@@ -27,10 +27,6 @@ jobs:
         - sphinx-build -b doctest -d docs/_build/doctrees docs docs/_build/doctest
       after_success:
 
-    - name: PyPy C Extensions
-      env: PURE_PYTHON=0
-      python: pypy
-
     - name: CPython No C Extension
       env: PURE_PYTHON=1
       python: 3.8

CHANGES.rst

@@ -134,6 +134,23 @@
   `dolmen.builtins <https://pypi.org/project/dolmen.builtins/>`_.
   See `issue 138 <https://github.com/zopefoundation/zope.interface/issues/138>`_.
 
+- Make ``providedBy()`` and ``implementedBy()`` respect ``super``
+  objects. For instance, if class ``Derived`` implements ``IDerived``
+  and extends ``Base`` which in turn implements ``IBase``, then
+  ``providedBy(super(Derived, derived))`` will return ``[IBase]``.
+  Previously it would have returned ``[IDerived]`` (in general, it
+  would previously have returned whatever would have been returned
+  without ``super``).
+
+  Along with this change, adapter registries will unpack ``super``
+  objects into their ``__self___`` before passing it to the factory.
+  Together, this means that ``component.getAdapter(super(Derived,
+  self), ITarget)`` is now meaningful.
+
+  See `issue 11 <https://github.com/zopefoundation/zope.interface/issues/11>`_.
+
+- Fix a potential interpreter crash in the low-level adapter
+  registry lookup functions. See issue 11.
 
 4.7.1 (2019-11-11)
 ==================

docs/adapter.rst

@@ -202,11 +202,11 @@ factories:
    ...     pass
 
    >>> @zope.interface.implementer(IR)
-   ... class X:
+   ... class X(object):
    ...     pass
 
    >>> @zope.interface.implementer(IProvide1)
-   ... class Y:
+   ... class Y(object):
    ...     def __init__(self, context):
    ...         self.context = context
 
@@ -238,6 +238,29 @@ We can register and lookup by name too:
   >>> y.context is x
   True
 
+Passing ``super`` objects works as expected to find less specific adapters:
+
+.. doctest::
+
+  >>> class IDerived(IR):
+  ...     pass
+  >>> @zope.interface.implementer(IDerived)
+  ... class Derived(X):
+  ...     pass
+  >>> class DerivedAdapter(Y):
+  ...     def query_next(self):
+  ...        return registry.queryAdapter(
+  ...            super(type(self.context), self.context),
+  ...            IProvide1)
+  >>> registry.register([IDerived], IProvide1, '', DerivedAdapter)
+  >>> derived = Derived()
+  >>> adapter = registry.queryAdapter(derived, IProvide1)
+  >>> adapter.__class__.__name__
+  'DerivedAdapter'
+  >>> adapter = adapter.query_next()
+  >>> adapter.__class__.__name__
+  'Y'
+
 When the adapter factory produces ``None``, then this is treated as if no
 adapter has been found. This allows us to prevent adaptation (when desired)
 and let the adapter factory determine whether adaptation is possible based on

docs/conf.py

@@ -17,7 +17,9 @@
 import pkg_resources
 sys.path.append(os.path.abspath('../src'))
 rqmt = pkg_resources.require('zope.interface')[0]
-
+# Import and document the pure-python versions of things; they tend to have better
+# docstrings and signatures.
+os.environ['PURE_PYTHON'] = '1'
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.

setup.py

@@ -69,10 +69,12 @@ def _unavailable(self, e):
 ]
 
 is_jython = 'java' in sys.platform
+is_pypy = hasattr(sys, 'pypy_version_info')
 
-# Jython cannot build the C optimizations. Everywhere else,
-# including PyPy, defer the decision to runtime.
-if is_jython:
+# Jython cannot build the C optimizations. Nor, as of 7.3, can PyPy (
+# it doesn't have PySuper_Type) Everywhere else, defer the decision to
+# runtime.
+if is_jython or is_pypy:
     ext_modules = []
 else:
     ext_modules = codeoptimization

src/zope/interface/_zope_interface_coptimizations.c

@@ -43,6 +43,11 @@ static PyObject *str__conform__, *str_call_conform, *adapter_hooks;
 static PyObject *str_uncached_lookup, *str_uncached_lookupAll;
 static PyObject *str_uncached_subscriptions;
 static PyObject *str_registry, *strro, *str_generation, *strchanged;
+static PyObject *str__get__;
+static PyObject *str__self__;
+static PyObject *str__thisclass__;
+static PyObject *str__self_class__;
+static PyObject *str__mro__;
 
 static PyTypeObject *Implements;
 
@@ -91,6 +96,7 @@ import_declarations(void)
   return 0;
 }
 
+
 static PyTypeObject SpecType;   /* Forward */
 
 static PyObject *
@@ -111,6 +117,12 @@ implementedBy(PyObject *ignored, PyObject *cls)
 
   PyObject *dict = NULL, *spec;
 
+  if (PyObject_TypeCheck(cls, &PySuper_Type))
+  {
+      // Let merging be handled by Python.
+      return implementedByFallback(cls);
+  }
+
   if (PyType_Check(cls))
     {
       dict = TYPE(cls)->tp_dict;
@@ -168,6 +180,7 @@ getObjectSpecification(PyObject *ignored, PyObject *ob)
   if (result != NULL && PyObject_TypeCheck(result, &SpecType))
     return result;
 
+
   PyErr_Clear();
 
   /* We do a getattr here so as not to be defeated by proxies */
@@ -176,11 +189,11 @@ getObjectSpecification(PyObject *ignored, PyObject *ob)
     {
       PyErr_Clear();
       if (imported_declarations == 0 && import_declarations() < 0)
-        return NULL;
+          return NULL;
+
       Py_INCREF(empty);
       return empty;
     }
-
   result = implementedBy(NULL, cls);
   Py_DECREF(cls);
 
@@ -192,7 +205,15 @@ providedBy(PyObject *ignored, PyObject *ob)
 {
   PyObject *result, *cls, *cp;
 
+  result = NULL;
+
+  if (PyObject_TypeCheck(ob, &PySuper_Type))
+  {
+      return implementedBy(NULL, ob);
+  }
+
   result = PyObject_GetAttr(ob, str__providedBy__);
+
   if (result == NULL)
     {
       PyErr_Clear();
@@ -947,27 +968,14 @@ _getcache(lookup *self, PyObject *provided, PyObject *name)
 
         return result
 */
-static PyObject *
-tuplefy(PyObject *v)
-{
-  if (! PyTuple_Check(v))
-    {
-      v = PyObject_CallFunctionObjArgs(OBJECT(&PyTuple_Type), v, NULL);
-      if (v == NULL)
-        return NULL;
-    }
-  else
-    Py_INCREF(v);
 
-  return v;
-}
 static PyObject *
 _lookup(lookup *self,
         PyObject *required, PyObject *provided, PyObject *name,
         PyObject *default_)
 {
   PyObject *result, *key, *cache;
-
+  result = key = cache = NULL;
 #ifdef PY3K
   if ( name && !PyUnicode_Check(name) )
 #else
@@ -978,14 +986,19 @@ _lookup(lookup *self,
                     "name is not a string or unicode");
     return NULL;
   }
-  cache = _getcache(self, provided, name);
-  if (cache == NULL)
-    return NULL;
 
-  required = tuplefy(required);
+  /* If `required` is a lazy sequence, it could have arbitrary side-effects,
+     such as clearing our caches. So we must not retreive the cache until
+     after resolving it. */
+  required = PySequence_Tuple(required);
   if (required == NULL)
     return NULL;
 
+
+  cache = _getcache(self, provided, name);
+  if (cache == NULL)
+    return NULL;
+
   if (PyTuple_GET_SIZE(required) == 1)
     key = PyTuple_GET_ITEM(required, 0);
   else
@@ -1154,12 +1167,23 @@ _adapter_hook(lookup *self,
     return NULL;
 
   if (factory != Py_None)
-    {
+  {
+      if (PyObject_TypeCheck(object, &PySuper_Type)) {
+          PyObject* self = PyObject_GetAttr(object, str__self__);
+          if (self == NULL)
+          {
+              Py_DECREF(factory);
+              return NULL;
+          }
+          // Borrow the reference to self
+          Py_DECREF(self);
+          object = self;
+      }
       result = PyObject_CallFunctionObjArgs(factory, object, NULL);
       Py_DECREF(factory);
       if (result == NULL || result != Py_None)
         return result;
-    }
+  }
   else
     result = factory; /* None */
 
@@ -1217,15 +1241,16 @@ _lookupAll(lookup *self, PyObject *required, PyObject *provided)
 {
   PyObject *cache, *result;
 
+  /* resolve before getting cache. See note in _lookup. */
+  required = PySequence_Tuple(required);
+  if (required == NULL)
+    return NULL;
+
   ASSURE_DICT(self->_mcache);
   cache = _subcache(self->_mcache, provided);
   if (cache == NULL)
     return NULL;
 
-  required = tuplefy(required);
-  if (required == NULL)
-    return NULL;
-
   result = PyDict_GetItem(cache, required);
   if (result == NULL)
     {
@@ -1287,15 +1312,16 @@ _subscriptions(lookup *self, PyObject *required, PyObject *provided)
 {
   PyObject *cache, *result;
 
+  /* resolve before getting cache. See note in _lookup. */
+  required = PySequence_Tuple(required);
+  if (required == NULL)
+    return NULL;
+
   ASSURE_DICT(self->_scache);
   cache = _subcache(self->_scache, provided);
   if (cache == NULL)
     return NULL;
 
-  required = tuplefy(required);
-  if (required == NULL)
-    return NULL;
-
   result = PyDict_GetItem(cache, required);
   if (result == NULL)
     {
@@ -1736,6 +1762,11 @@ init(void)
   DEFINE_STRING(_generation);
   DEFINE_STRING(ro);
   DEFINE_STRING(changed);
+  DEFINE_STRING(__self__);
+  DEFINE_STRING(__get__);
+  DEFINE_STRING(__thisclass__);
+  DEFINE_STRING(__self_class__);
+  DEFINE_STRING(__mro__);
 #undef DEFINE_STRING
   adapter_hooks = PyList_New(0);
   if (adapter_hooks == NULL)