add except* support to B012&B025, add tests for any except-handling rules

Author: jakkdl

README.rst

@@ -360,6 +360,11 @@ Change Log
 ----------
 
 
+FUTURE
+~~~~~~
+
+* B012 and B025 now also handle try/except*
+
 24.10.31
 ~~~~~~~~
 

bugbear.py

@@ -457,7 +457,7 @@ def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
         else:
             self.b040_caught_exception = B040CaughtException(node.name, False)
 
-        names = self.check_for_b013_b029_b030(node)
+        names = self.check_for_b013_b014_b029_b030(node)
 
         if (
             "BaseException" in names
@@ -604,6 +604,8 @@ def visit_Try(self, node) -> None:
         self.check_for_b025(node)
         self.generic_visit(node)
 
+    visit_TryStar = visit_Try
+
     def visit_Compare(self, node) -> None:
         self.check_for_b015(node)
         self.generic_visit(node)
@@ -770,7 +772,7 @@ def _loop(node, bad_node_types) -> None:
         for child in node.finalbody:
             _loop(child, (ast.Return, ast.Continue, ast.Break))
 
-    def check_for_b013_b029_b030(self, node: ast.ExceptHandler) -> list[str]:
+    def check_for_b013_b014_b029_b030(self, node: ast.ExceptHandler) -> list[str]:
         handlers: Iterable[ast.expr | None] = _flatten_excepthandler(node.type)
         names: list[str] = []
         bad_handlers: list[object] = []
@@ -2058,6 +2060,7 @@ def visit_Lambda(self, node) -> None:
 error = namedtuple("error", "lineno col message type vars")
 Error = partial(partial, error, type=BugBearChecker, vars=())
 
+# note: bare except* is a syntax error
 B001 = Error(
     message=(
         "B001 Do not use bare `except:`, it also catches unexpected "

tests/b012_py311.py

@@ -0,0 +1,29 @@
+def a():
+    try:
+        pass
+    except* Exception:
+        pass
+    finally:
+        return  # warning
+
+
+def b():
+    try:
+        pass
+    except* Exception:
+        pass
+    finally:
+        if 1 + 0 == 2 - 1:
+            return  # warning
+
+
+def c():
+    try:
+        pass
+    except* Exception:
+        pass
+    finally:
+        try:
+            return  # warning
+        except* Exception:
+            pass

tests/b014_py311.py

@@ -0,0 +1,76 @@
+"""
+This is a copy of b014 but with except* instead. Should emit:
+B014 - on lines 11, 17, 28, 42, 49, 56, and 74.
+"""
+
+import binascii
+import re
+
+try:
+    pass
+except* (Exception, TypeError):
+    # TypeError is a subclass of Exception, so it doesn't add anything
+    pass
+
+try:
+    pass
+except* (OSError, OSError) as err:
+    # Duplicate exception types are useless
+    pass
+
+
+class MyError(Exception):
+    pass
+
+
+try:
+    pass
+except* (MyError, MyError):
+    # Detect duplicate non-builtin errors
+    pass
+
+
+try:
+    pass
+except* (MyError, Exception) as e:
+    # Don't assume that we're all subclasses of Exception
+    pass
+
+
+try:
+    pass
+except* (MyError, BaseException) as e:
+    # But we *can* assume that everything is a subclass of BaseException
+    raise e
+
+
+try:
+    pass
+except* (re.error, re.error):
+    # Duplicate exception types as attributes
+    pass
+
+
+try:
+    pass
+except* (IOError, EnvironmentError, OSError):
+    # Detect if a primary exception and any its aliases are present.
+    #
+    # Since Python 3.3, IOError, EnvironmentError, WindowsError, mmap.error,
+    # socket.error and select.error are aliases of OSError. See PEP 3151 for
+    # more info.
+    pass
+
+
+try:
+    pass
+except* (MyException, NotImplemented):
+    # NotImplemented is not an exception, let's not crash on it.
+    pass
+
+
+try:
+    pass
+except* (ValueError, binascii.Error):
+    # binascii.Error is a subclass of ValueError.
+    pass

tests/b025_py311.py

@@ -0,0 +1,38 @@
+"""
+Should emit:
+B025 - on lines 15, 22, 31
+"""
+
+import pickle
+
+try:
+    a = 1
+except* ValueError:
+    a = 2
+finally:
+    a = 3
+
+try:
+    a = 1
+except* ValueError:
+    a = 2
+except* ValueError:
+    a = 2
+
+try:
+    a = 1
+except* pickle.PickleError:
+    a = 2
+except* ValueError:
+    a = 2
+except* pickle.PickleError:
+    a = 2
+
+try:
+    a = 1
+except* (ValueError, TypeError):
+    a = 2
+except* ValueError:
+    a = 2
+except* (OSError, TypeError):
+    a = 2

tests/b029_py311.py

@@ -0,0 +1,14 @@
+"""
+Should emit:
+B029 - on lines 8 and 13
+"""
+
+try:
+    pass
+except* ():
+    pass
+
+try:
+    pass
+except* () as e:
+    pass

tests/b030_py311.py

@@ -0,0 +1,40 @@
+try:
+    pass
+except* (ValueError, (RuntimeError, (KeyError, TypeError))):  # error
+    pass
+
+try:
+    pass
+except* (ValueError, *(RuntimeError, *(KeyError, TypeError))):  # ok
+    pass
+
+try:
+    pass
+except* 1:  # error
+    pass
+
+try:
+    pass
+except* (1, ValueError):  # error
+    pass
+
+try:
+    pass
+except* (ValueError, *(RuntimeError, TypeError)):  # ok
+    pass
+
+
+def what_to_catch():
+    return (ValueError, TypeError)
+
+
+try:
+    pass
+except* what_to_catch():  # ok
+    pass
+
+
+try:
+    pass
+except* a.b[1].c:  # ok
+    pass

tests/b036_py311.py

@@ -0,0 +1,59 @@
+
+try:
+    pass
+except* BaseException:  # bad
+    print("aaa")
+    pass
+
+
+try:
+    pass
+except* BaseException as ex:  # bad
+    print(ex)
+    pass
+
+
+try:
+    pass
+except* ValueError:
+    raise
+except* BaseException:  # bad
+    pass
+
+
+try:
+    pass
+except* BaseException:  # ok - reraised
+    print("aaa")
+    raise
+
+
+try:
+    pass
+except* BaseException as ex:  # bad - raised something else
+    print("aaa")
+    raise KeyError from ex
+
+try:
+    pass
+except* BaseException as e:
+    raise e  # ok - raising same thing
+
+try:
+    pass
+except* BaseException:
+    if 0:
+        raise  # ok - raised somewhere within branch
+
+try:
+    pass
+except* BaseException:
+    try:  # nested try
+        pass
+    except* ValueError:
+        raise  # bad - raising within a nested try/except*, but not in the main one
+
+try:
+    pass
+except* BaseException:
+    raise a.b from None  # bad (regression test for #449)

tests/b904_py311.py

@@ -0,0 +1,55 @@
+"""
+Should emit:
+B904 - on lines 10, 11 and 16
+"""
+
+try:
+    raise ValueError
+except* ValueError:
+    if "abc":
+        raise TypeError
+    raise UserWarning
+except* AssertionError:
+    raise  # Bare `raise` should not be an error
+except* Exception as err:
+    assert err
+    raise Exception("No cause here...")
+except* BaseException as base_err:
+    # Might use this instead of bare raise with the `.with_traceback()` method
+    raise base_err
+finally:
+    raise Exception("Nothing to chain from, so no warning here")
+
+try:
+    raise ValueError
+except* ValueError:
+    # should not emit, since we are not raising something
+    def proxy():
+        raise NameError
+
+
+try:
+    from preferred_library import Thing
+except* ImportError:
+    try:
+        from fallback_library import Thing
+    except* ImportError:
+
+        class Thing:
+            def __getattr__(self, name):
+                # same as the case above, should not emit.
+                raise AttributeError
+
+
+try:
+    from preferred_library import Thing
+except* ImportError:
+    try:
+        from fallback_library import Thing
+    except* ImportError:
+
+        def context_switch():
+            try:
+                raise ValueError
+            except* ValueError:
+                raise Exception