Avoid false-positives for methods with no return

infer_types/_cli.py

@@ -17,6 +17,9 @@
     import pdb  # type: ignore[no-redef]
 
 
+TEST_NAMES = frozenset({'tests.py', 'conftest.py'})
+
+
 @dataclass(frozen=True)
 class Config:
     format: bool            # run code formatters
@@ -49,8 +52,13 @@ def add_annotations(root: Path, config: Config) -> None:
             continue
         if path.suffix != '.py':
             continue
-        if config.skip_tests and path.name.startswith('test_'):
-            continue
+        if config.skip_tests:
+            if path.name.startswith('test_'):
+                continue
+            if path.name in TEST_NAMES:
+                continue
+            if 'tests' in path.parts:
+                continue
         new_source = inferno.transform(path)
         if config.format:
             new_source = format_code(new_source)

infer_types/_extractors.py

@@ -15,6 +15,7 @@
 Extractor = Callable[[astroid.FunctionDef], Type]
 extractors: list[tuple[str, Extractor]] = []
 
+UNKNOWN_TYPE = Type.new('')
 
 KNOWN_NAMES = MappingProxyType({
     'dumps': 'str',
@@ -66,7 +67,7 @@ def walk(func_node: astroid.FunctionDef) -> Iterator[astroid.NodeNG]:
 
 @register(name='astypes')
 def _extract_astypes(func_node: astroid.FunctionDef) -> Type:
-    result = Type.new('')
+    result = UNKNOWN_TYPE
     for node in walk(func_node):
         if not isinstance(node, astroid.Return):
             continue
@@ -80,7 +81,7 @@ def _extract_astypes(func_node: astroid.FunctionDef) -> Type:
         else:
             result = result.merge(node_type)
     if result.unknown:
-        return Type.new('')
+        return UNKNOWN_TYPE
     return result
 
 
@@ -91,7 +92,7 @@ def _extract_inherit_method(func_node: astroid.FunctionDef) -> Type:
             cls_node = node
             break
     else:
-        return Type.new('')
+        return UNKNOWN_TYPE
     for parent in cls_node.getattr(func_node.name):
         if isinstance(parent, astroid.BoundMethod):
             parent = parent._proxied
@@ -122,22 +123,38 @@ def _extract_inherit_method(func_node: astroid.FunctionDef) -> Type:
         return_type = conv_node_to_type(mod_name, type_node)
         if return_type is not None:
             return return_type
-    return Type.new('')
+    return UNKNOWN_TYPE
 
 
 @register(name='yield')
 def _extract_yield(func_node: astroid.FunctionDef) -> Type:
     for node in walk(func_node):
         if isinstance(node, (astroid.Yield, astroid.YieldFrom)):
             return Type.new('Iterator', module='typing')
-    return Type.new('')
+    return UNKNOWN_TYPE
 
 
 @register(name='none')
 def _extract_no_return(func_node: astroid.FunctionDef) -> Type:
+    # ignore empty methods, they can be there for base class signatures
+    if isinstance(func_node.parent, astroid.ClassDef):
+        if not func_node.body:
+            return UNKNOWN_TYPE
+        if len(func_node.body) == 1:
+            node = func_node.body[0]
+
+            if isinstance(node, (astroid.Raise, astroid.Pass)):
+                return UNKNOWN_TYPE
+            if isinstance(node, astroid.Expr):
+                node = node.value
+                if isinstance(node, astroid.Const) and node.value == ...:
+                    return UNKNOWN_TYPE
+
     for node in walk(func_node):
+        if isinstance(node, (astroid.Yield, astroid.YieldFrom)):
+            return UNKNOWN_TYPE
         if isinstance(node, astroid.Return) and node.value is not None:
-            return Type.new('')
+            return UNKNOWN_TYPE
     return Type.new('None')
 
 

tests/test_inferno.py

@@ -215,6 +215,64 @@ class C:
         def m(self, x) -> Iterator:
             yield 12
     """,
+    # don't infer no return for empty base class methods
+    """
+    class A:
+        def m(self, x):
+            raise NotImplementedError
+    ---
+    class A:
+        def m(self, x):
+            raise NotImplementedError
+    """,
+    """
+    class A:
+        def m(self, x):
+            "some docstring"
+    ---
+    class A:
+        def m(self, x):
+            "some docstring"
+    """,
+    """
+    class A:
+        def m(self, x):
+            pass
+    ---
+    class A:
+        def m(self, x):
+            pass
+    """,
+    """
+    class A:
+        def m(self, x):
+            ...
+    ---
+    class A:
+        def m(self, x):
+            ...
+    """,
+    # infer no return for methods
+    """
+    class A:
+        def m(self, x):
+            pass
+            1 + 2
+    ---
+    class A:
+        def m(self, x) -> None:
+            pass
+            1 + 2
+    """,
+    """
+    class A:
+        def m(self, x):
+            13
+    ---
+    class A:
+        def m(self, x) -> None:
+            13
+    """,
 ])
 def test_inferno(transform, fused: str) -> None:
     given, expected = fused.split('---')