ENH: Warn when defaults use non-interface attrs.

Warn if an interface default uses a non-interface member in its
implementation.

Author: Scott Sanderson

interface/__init__.py

@@ -1,4 +1,5 @@
-from .interface import default, implements, InvalidImplementation, Interface
+from .interface import implements, InvalidImplementation, Interface
+from .default import default
 
 __all__ = [
     'default',

interface/default.py

@@ -1,3 +1,11 @@
+import dis
+import warnings
+
+from .compat import PY3
+from .formatting import bulleted_list
+from .functional import keysorted, sliding_window
+
+
 class default(object):
     """Default implementation of a function in terms of interface methods.
     """
@@ -6,3 +14,83 @@ def __init__(self, implementation):
 
     def __repr__(self):
         return "{}({})".format(type(self).__name__, self.implementation)
+
+
+class DefaultUsesNonInterfaceMembers(UserWarning):
+    pass
+
+
+if PY3:  # pragma: nocover-py2
+    _DEFAULT_USES_NON_INTERFACE_MEMBER_TEMPLATE = (
+        "Default implementation of {iface}.{method} uses non-interface attributes.\n\n"
+        "The following attributes may be accessed but are not part of "
+        "the interface:\n"
+        "{non_members}\n\n"
+        "Consider changing the implementation of {method} or making these attributes"
+        " part of {iface}."
+    )
+
+    def warn_if_defaults_use_non_interface_members(interface_name,
+                                                   defaults,
+                                                   members):
+        """Warn if an interface default uses non-interface members of self.
+        """
+        for method_name, attrs in non_member_attributes(defaults, members):
+            warnings.warn(_DEFAULT_USES_NON_INTERFACE_MEMBER_TEMPLATE.format(
+                iface=interface_name,
+                method=method_name,
+                non_members=bulleted_list(attrs),
+            ))
+
+    def non_member_attributes(defaults, members):
+        from .typed_signature import TypedSignature
+
+        for default_name, default in keysorted(defaults):
+            impl = default.implementation
+
+            if isinstance(impl, staticmethod):
+                # staticmethods can't use attributes of the interface.
+                continue
+
+            self_name = TypedSignature(impl).first_argument_name
+            if self_name is None:
+                # No parameters.
+                # TODO: This is probably a bug in the interface, since a method
+                # with no parameters that's not a staticmethod probably can't
+                # be called in any natural way.
+                continue
+
+            used = accessed_attributes_of_local(impl, self_name)
+            non_interface_usages = used - members
+
+            if non_interface_usages:
+                yield default_name, sorted(non_interface_usages)
+
+    def accessed_attributes_of_local(f, local_name):
+        """
+        Get a list of attributes of ``local_name`` accessed by ``f``.
+
+        The analysis performed by this function is conservative, meaning that
+        it's not guaranteed to find **all** attributes used.
+        """
+        used = set()
+        # Find sequences of the form: LOAD_FAST(local_name), LOAD_ATTR(<name>).
+        # This will find all usages of the form ``local_name.<name>``.
+        #
+        # It will **NOT** find usages in which ``local_name`` is aliased to
+        # another name.
+        for first, second in sliding_window(dis.get_instructions(f), 2):
+            if first.opname == 'LOAD_FAST' and first.argval == local_name:
+                if second.opname == 'LOAD_ATTR':
+                    used.add(second.argval)
+        return used
+
+else:  # pragma: nocover-py3
+    def warn_if_defaults_use_non_interface_members(*args, **kwargs):
+        pass
+
+    def non_member_warnings(*args, **kwargs):
+        return iter(())
+
+    def accessed_attributes_of_local(*args, **kwargs):
+        return set()

interface/formatting.py

@@ -0,0 +1,6 @@
+"""String formatting utilities.
+"""
+
+
+def bulleted_list(items):
+    return "\n".join(map("  - {}".format, items))

interface/functional.py

@@ -3,6 +3,8 @@
 ----------
 Functional programming utilities.
 """
+from collections import deque
+from operator import itemgetter
 from .compat import viewkeys
 
 
@@ -16,6 +18,10 @@ def keyfilter(f, d):
     return {k: v for k, v in d.items() if f(k)}
 
 
+def keysorted(d):
+    return sorted(d.items(), key=itemgetter(0))
+
+
 def valfilter(f, d):
     return {k: v for k, v in d.items() if f(v)}
 
@@ -25,3 +31,19 @@ def dzip(left, right):
         k: (left.get(k), right.get(k))
         for k in viewkeys(left) & viewkeys(right)
     }
+
+
+def sliding_window(iterable, n):
+    it = iter(iterable)
+    items = deque(maxlen=n)
+    try:
+        for i in range(n):
+            items.append(next(it))
+    except StopIteration:
+        return
+
+    yield tuple(items)
+
+    for item in it:
+        items.append(item)
+        yield tuple(items)

interface/interface.py

@@ -3,14 +3,13 @@
 ---------
 """
 from collections import defaultdict
-from functools import wraps
-import inspect
 from operator import attrgetter, itemgetter
 from textwrap import dedent
 from weakref import WeakKeyDictionary
 
-from .compat import raise_from, viewkeys, with_metaclass
-from .default import default  # noqa reexport
+from .compat import raise_from, with_metaclass
+from .default import default, warn_if_defaults_use_non_interface_members
+from .formatting import bulleted_list
 from .functional import complement, keyfilter, valfilter
 from .typecheck import compatible
 from .typed_signature import TypedSignature
@@ -75,9 +74,7 @@ def _conflicting_defaults(typename, conflicts):
             {interfaces}"""
         ).format(
             attr=attrname,
-            interfaces="\n".join(sorted([
-                "  - {name}".format(name=iface.__name__) for iface in interfaces
-            ]))
+            interfaces=bulleted_list(sorted(map(getname, interfaces))),
         )
     return InvalidImplementation(message)
 
@@ -108,6 +105,12 @@ def __new__(mcls, name, bases, clsdict):
             if isinstance(v, default):
                 defaults[k] = v
 
+        warn_if_defaults_use_non_interface_members(
+            name,
+            defaults,
+            set(signatures.keys())
+        )
+
         clsdict['_signatures'] = signatures
         clsdict['_defaults'] = defaults
         return super(InterfaceMeta, mcls).__new__(mcls, name, bases, clsdict)
@@ -284,7 +287,7 @@ def __new__(mcls, name, bases, clsdict, interfaces=empty_set):
         errors = []
         default_impls = {}
         default_providers = defaultdict(list)
-        for iface in newtype.interfaces():
+        for iface in sorted(newtype.interfaces(), key=getname):
             try:
                 defaults_from_iface = iface.verify(newtype)
                 for name, impl in defaults_from_iface.items():
@@ -306,7 +309,7 @@ def __new__(mcls, name, bases, clsdict, interfaces=empty_set):
         elif len(errors) == 1:
             raise errors[0]
         else:
-            raise InvalidImplementation("\n\n".join(map(str, errors)))
+            raise InvalidImplementation("\n".join(map(str, errors)))
 
     def __init__(mcls, name, bases, clsdict, interfaces=empty_set):
         mcls._interfaces = interfaces
@@ -372,7 +375,7 @@ def implements(*interfaces):
         ordered_ifaces = tuple(sorted(interfaces, key=getname))
         iface_names = list(map(getname, ordered_ifaces))
 
-        name = "Implements{I}".format(I="_".join(iface_names))
+        name = "Implements{}".format("_".join(iface_names))
         doc = dedent(
             """\
             Implementation of {interfaces}.

interface/tests/test_functional.py

@@ -0,0 +1,41 @@
+from functools import total_ordering
+
+import pytest
+
+from ..functional import keysorted, sliding_window
+
+
+def test_sliding_window():
+    assert list(sliding_window([], 2)) == []
+    assert list(sliding_window([1, 2, 3], 2)) == [(1, 2), (2, 3)]
+    assert list(sliding_window([1, 2, 3, 4], 2)) == [(1, 2), (2, 3), (3, 4)]
+    assert list(sliding_window([1, 2, 3, 4], 3)) == [(1, 2, 3), (2, 3, 4)]
+
+
+def test_keysorted():
+
+    @total_ordering
+    class Unorderable(object):
+
+        def __init__(self, obj):
+            self.obj = obj
+
+        def __eq__(self, other):
+            raise AssertionError("Can't compare this.")
+
+        __ne__ = __lt__ = __eq__
+
+    with pytest.raises(AssertionError):
+        sorted([Unorderable(0), Unorderable(0)])
+
+    d = {'c': Unorderable(3), 'b': Unorderable(2), 'a': Unorderable(1)}
+    items = keysorted(d)
+
+    assert items[0][0] == 'a'
+    assert items[0][1].obj == 1
+
+    assert items[1][0] == 'b'
+    assert items[1][1].obj == 2
+
+    assert items[2][0] == 'c'
+    assert items[2][1].obj == 3

interface/tests/test_interface.py

@@ -1,9 +1,13 @@
 import pytest
 from textwrap import dedent
 
+from ..compat import PY3
 from ..interface import implements, InvalidImplementation, Interface, default
 
 
+py3_only = pytest.mark.skipif(not PY3, reason="Python 3 Only")
+
+
 def test_valid_implementation():
 
     class I(Interface):  # pragma: nocover
@@ -220,12 +224,12 @@ class D failed to implement interface I:
             The following methods of I were not implemented:
               - m0(self, a)
 
-            class D failed to implemente interface J:
+            class D failed to implement interface J:
 
             The following methods of J were implemented with invalid signatures:
-            - m1(self, z) != m1(self, a)
-            """
+              - m1(self, z) != m1(self, a)"""
         )
+        assert actual == expected
 
 
 def test_implements_memoization():
@@ -570,3 +574,67 @@ def foo(a, b):  # pragma: nocover
         pass
 
     assert repr(foo) == "default({})".format(foo.implementation)
+
+
+@py3_only
+def test_default_warns_if_method_uses_non_interface_methods():  # pragma: nocover-py2
+
+    with pytest.warns(UserWarning) as warns:
+
+        class HasDefault(Interface):
+
+            def interface_method(self, x):
+                pass
+
+            @default
+            def foo(self, a, b):
+                # Shouldn't cause warnings.
+                self.default_method()
+                self.default_classmethod()
+                self.default_staticmethod()
+                self.interface_method(a)
+
+            @default
+            def probably_broken_method_with_no_args():
+                pass  # This eex
+
+            @default
+            @staticmethod
+            def default_staticmethod():
+                # Shouldn't cause warnings.
+                global some_nonexistent_method
+                return some_nonexistent_method()
+
+            @default
+            def default_method(self, x):
+                foo = self.foo(1, 2)  # Should be fine.
+                wut = self.not_in_interface(2, 3)  # Should cause a warning.
+                return foo + wut
+
+            @default
+            @classmethod
+            def default_classmethod(cls, x):
+                return cls.class_bar(2, 3)  # Should cause a warning.
+
+    messages = warns.list
+    assert len(messages) == 2
+
+    first = str(messages[0].message)
+    expected_first = """\
+Default implementation of HasDefault.default_classmethod uses non-interface attributes.
+
+The following attributes may be accessed but are not part of the interface:
+  - class_bar
+
+Consider changing the implementation of default_classmethod or making these attributes part of HasDefault."""  # noqa
+    assert first == expected_first
+
+    second = str(messages[1].message)
+    expected_second = """\
+Default implementation of HasDefault.default_method uses non-interface attributes.
+
+The following attributes may be accessed but are not part of the interface:
+  - not_in_interface
+
+Consider changing the implementation of default_method or making these attributes part of HasDefault."""  # noqa
+    assert second == expected_second

interface/tests/test_typecheck.py

@@ -1,5 +1,6 @@
 from ..compat import PY3, signature
 from ..typecheck import compatible
+from ..typed_signature import TypedSignature
 
 
 def test_compatible_when_equal():
@@ -72,5 +73,10 @@ def impl(a, b, c, d=3, e=5, f=5):  # pragma: nocover
     assert not compatible(iface, impl)
 
 
+def test_first_argument_name():
+    assert TypedSignature(lambda x, y, z: x).first_argument_name == 'x'
+    assert TypedSignature(lambda: 0).first_argument_name is None
+
+
 if PY3:  # pragma: nocover
     from ._py3_typecheck_tests import *