Merge pull request RustPython#1667 from youknowone/whatsleft

whats_left prints inherited but unimplemented attrs + more types

Author: youknowone

tests/generator/not_impl_methods_footer.txt

@@ -1,12 +1,26 @@
-not_implemented = [(name, method)
-                   for name, (val, methods) in expected_methods.items()
-                   for method in methods
-                   if not hasattr(val, method)]
-
-for r in not_implemented:
-    print(r[0], ".", r[1], sep="")
-if not not_implemented:
+
+def attr_is_not_inherited(type_, attr):
+    """
+    returns True if type_'s attr is not inherited from any of its base classes
+    """
+    bases = type_.__mro__[1:]
+
+    return getattr(type_, attr) not in (getattr(base, attr, None) for base in bases)
+
+
+not_implementeds = []
+for name, (typ, methods) in expected_methods.items():
+    for method in methods:
+        has_method = hasattr(typ, method)
+        is_inherited = has_method and not attr_is_not_inherited(typ, method)
+        if has_method and not is_inherited:
+            continue
+        not_implementeds.append((name, method, is_inherited))
+
+for r in not_implementeds:
+    print(r[0], ".", r[1], " (inherited)" if r[2] else "", sep="")
+if not not_implementeds:
     print("Not much \\o/")
 
 if platform.python_implementation() == "CPython":
-    assert len(not_implemented) == 0, "CPython should have all the methods"
+    assert len(not_implementeds) == 0, "CPython should have all the methods"

tests/not_impl_gen.py

@@ -26,37 +26,70 @@ def attr_is_not_inherited(type_, attr):
 
 
 def gen_methods(header, footer, output):
-    objects = [
+    types = [
         bool,
         bytearray,
         bytes,
         complex,
         dict,
+        enumerate,
+        filter,
         float,
         frozenset,
         int,
         list,
+        map,
         memoryview,
         range,
         set,
+        slice,
         str,
+        super,
         tuple,
         object,
+        zip,
+
+        classmethod,
+        staticmethod,
+        property,
+
+        Exception,
+        BaseException,
+    ]
+    objects = [(t.__name__, t.__name__) for t in types]
+    objects.extend([
+        ('NoneType', 'type(None)'),
+    ])
+
+    iters = [
+        ('bytearray_iterator', 'type(bytearray().__iter__())'),
+        ('bytes_iterator', 'type(bytes().__iter__())'),
+        ('dict_keyiterator', 'type(dict().__iter__())'),
+        ('dict_valueiterator', 'type(dict().values().__iter__())'),
+        ('dict_itemiterator', 'type(dict().items().__iter__())'),
+        ('dict_values', 'type(dict().values())'),
+        ('dict_items', 'type(dict().items())'),
+        ('set_iterator', 'type(set().__iter__())'),
+        ('list_iterator', 'type(list().__iter__())'),
+        ('range_iterator', 'type(range(0).__iter__())'),
+        ('str_iterator', 'type(str().__iter__())'),
+        ('tuple_iterator', 'type(tuple().__iter__())'),
     ]
 
     output.write(header.read())
     output.write("expected_methods = {\n")
 
-    for obj in objects:
-        output.write(f" '{obj.__name__}': ({obj.__name__}, [\n")
+    for name, typ_code in objects + iters:
+        typ = eval(typ_code)
+        output.write(f" '{name}': ({typ_code}, [\n")
         output.write(
             "\n".join(
                 f"    {attr!r},"
-                for attr in dir(obj)
-                if attr_is_not_inherited(obj, attr)
+                for attr in dir(typ)
+                if attr_is_not_inherited(typ, attr)
             )
         )
-        output.write("\n ])," + ("\n" if objects[-1] == obj else "\n\n"))
+        output.write("\n ])," + ("\n" if objects[-1] == typ else "\n\n"))
 
     output.write("}\n\n")
     output.write(footer.read())