now prints except* in error messages

Author: jakkdl

bugbear.py

@@ -243,7 +243,7 @@ def _flatten_excepthandler(node: ast.expr | None) -> Iterator[ast.expr | None]:
         yield expr
 
 
-def _check_redundant_excepthandlers(names: Sequence[str], node):
+def _check_redundant_excepthandlers(names: Sequence[str], node, in_trystar):
     # See if any of the given exception names could be removed, e.g. from:
     #    (MyError, MyError)  # duplicate names
     #    (MyError, BaseException)  # everything derives from the Base
@@ -275,7 +275,7 @@ def _check_redundant_excepthandlers(names: Sequence[str], node):
         return B014(
             node.lineno,
             node.col_offset,
-            vars=(", ".join(names), as_, desc),
+            vars=(", ".join(names), as_, desc, in_trystar),
         )
     return None
 
@@ -388,6 +388,9 @@ class BugBearVisitor(ast.NodeVisitor):
     _b023_seen: set[error] = attr.ib(factory=set, init=False)
     _b005_imports: set[str] = attr.ib(factory=set, init=False)
 
+    # set to "*" when inside a try/except*, for correctly printing errors
+    in_trystar: str = attr.ib(default="")
+
     if False:
         # Useful for tracing what the hell is going on.
 
@@ -604,7 +607,11 @@ def visit_Try(self, node) -> None:
         self.check_for_b025(node)
         self.generic_visit(node)
 
-    visit_TryStar = visit_Try
+    def visit_TryStar(self, node) -> None:
+        outer_trystar = self.in_trystar
+        self.in_trystar = "*"
+        self.visit_Try(node)
+        self.in_trystar = outer_trystar
 
     def visit_Compare(self, node) -> None:
         self.check_for_b015(node)
@@ -764,7 +771,9 @@ def _loop(node, bad_node_types) -> None:
                 bad_node_types = (ast.Return,)
 
             elif isinstance(node, bad_node_types):
-                self.errors.append(B012(node.lineno, node.col_offset))
+                self.errors.append(
+                    B012(node.lineno, node.col_offset, vars=(self.in_trystar,))
+                )
 
             for child in ast.iter_child_nodes(node):
                 _loop(child, bad_node_types)
@@ -792,16 +801,27 @@ def check_for_b013_b014_b029_b030(self, node: ast.ExceptHandler) -> list[str]:
         if bad_handlers:
             self.errors.append(B030(node.lineno, node.col_offset))
         if len(names) == 0 and not bad_handlers and not ignored_handlers:
-            self.errors.append(B029(node.lineno, node.col_offset))
+            self.errors.append(
+                B029(node.lineno, node.col_offset, vars=(self.in_trystar,))
+            )
         elif (
             len(names) == 1
             and not bad_handlers
             and not ignored_handlers
             and isinstance(node.type, ast.Tuple)
         ):
-            self.errors.append(B013(node.lineno, node.col_offset, vars=names))
+            self.errors.append(
+                B013(
+                    node.lineno,
+                    node.col_offset,
+                    vars=(
+                        *names,
+                        self.in_trystar,
+                    ),
+                )
+            )
         else:
-            maybe_error = _check_redundant_excepthandlers(names, node)
+            maybe_error = _check_redundant_excepthandlers(names, node, self.in_trystar)
             if maybe_error is not None:
                 self.errors.append(maybe_error)
         return names
@@ -1217,7 +1237,9 @@ def check_for_b904(self, node) -> None:
             and not (isinstance(node.exc, ast.Name) and node.exc.id.islower())
             and any(isinstance(n, ast.ExceptHandler) for n in self.node_stack)
         ):
-            self.errors.append(B904(node.lineno, node.col_offset))
+            self.errors.append(
+                B904(node.lineno, node.col_offset, vars=(self.in_trystar,))
+            )
 
     def walk_function_body(self, node):
         def _loop(parent, node):
@@ -1481,7 +1503,9 @@ def check_for_b025(self, node) -> None:
         # sort to have a deterministic output
         duplicates = sorted({x for x in seen if seen.count(x) > 1})
         for duplicate in duplicates:
-            self.errors.append(B025(node.lineno, node.col_offset, vars=(duplicate,)))
+            self.errors.append(
+                B025(node.lineno, node.col_offset, vars=(duplicate, self.in_trystar))
+            )
 
     @staticmethod
     def _is_infinite_iterator(node: ast.expr) -> bool:
@@ -2060,7 +2084,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
+# note: bare except* is a syntax error, so B001 does not need to handle it
 B001 = Error(
     message=(
         "B001 Do not use bare `except:`, it also catches unexpected "
@@ -2182,20 +2206,20 @@ def visit_Lambda(self, node) -> None:
 B012 = Error(
     message=(
         "B012 return/continue/break inside finally blocks cause exceptions "
-        "to be silenced. Exceptions should be silenced in except blocks. Control "
+        "to be silenced. Exceptions should be silenced in except{0} blocks. Control "
         "statements can be moved outside the finally block."
     )
 )
 B013 = Error(
     message=(
         "B013 A length-one tuple literal is redundant.  "
-        "Write `except {0}:` instead of `except ({0},):`."
+        "Write `except{1} {0}:` instead of `except{1} ({0},):`."
     )
 )
 B014 = Error(
     message=(
-        "B014 Redundant exception types in `except ({0}){1}:`.  "
-        "Write `except {2}{1}:`, which catches exactly the same exceptions."
+        "B014 Redundant exception types in `except{3} ({0}){1}:`.  "
+        "Write `except{3} {2}{1}:`, which catches exactly the same exceptions."
     )
 )
 B014_REDUNDANT_EXCEPTIONS = {
@@ -2284,8 +2308,8 @@ def visit_Lambda(self, node) -> None:
 )
 B025 = Error(
     message=(
-        "B025 Exception `{0}` has been caught multiple times. Only the first except"
-        " will be considered and all other except catches can be safely removed."
+        "B025 Exception `{0}` has been caught multiple times. Only the first except{0}"
+        " will be considered and all other except{0} catches can be safely removed."
     )
 )
 B026 = Error(
@@ -2313,7 +2337,7 @@ def visit_Lambda(self, node) -> None:
 )
 B029 = Error(
     message=(
-        "B029 Using `except ():` with an empty tuple does not handle/catch "
+        "B029 Using `except{0} ():` with an empty tuple does not handle/catch "
         "anything. Add exceptions to handle."
     )
 )
@@ -2402,7 +2426,7 @@ def visit_Lambda(self, node) -> None:
 
 B904 = Error(
     message=(
-        "B904 Within an `except` clause, raise exceptions with `raise ... from err` or"
+        "B904 Within an `except{0}` clause, raise exceptions with `raise ... from err` or"
         " `raise ... from None` to distinguish them from errors in exception handling. "
         " See https://docs.python.org/3/tutorial/errors.html#exception-chaining for"
         " details."

tests/b013_py311.py

@@ -0,0 +1,40 @@
+"""
+Should emit:
+B013 - on lines 10 and 28
+"""
+
+import re
+
+try:
+    pass
+except* (ValueError,):
+    # pointless use of tuple
+    pass
+
+# fmt: off
+# Turn off black to keep brackets around
+# single except*ion for testing purposes.
+try:
+    pass
+except* (ValueError):
+    # not using a tuple means it's OK (if odd)
+    pass
+# fmt: on
+
+try:
+    pass
+except* ValueError:
+    # no warning here, all good
+    pass
+
+try:
+    pass
+except* (re.error,):
+    # pointless use of tuple with dotted attribute
+    pass
+
+try:
+    pass
+except* (a.b.c.d, b.c.d):
+    # attribute of attribute, etc.
+    pass

tests/test_bugbear.py

@@ -207,16 +207,16 @@ def test_b012(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         all_errors = [
-            B012(5, 8),
-            B012(13, 12),
-            B012(21, 12),
-            B012(31, 12),
-            B012(44, 20),
-            B012(66, 12),
-            B012(78, 12),
-            B012(94, 12),
-            B012(101, 8),
-            B012(107, 8),
+            B012(5, 8, vars=("",)),
+            B012(13, 12, vars=("",)),
+            B012(21, 12, vars=("",)),
+            B012(31, 12, vars=("",)),
+            B012(44, 20, vars=("",)),
+            B012(66, 12, vars=("",)),
+            B012(78, 12, vars=("",)),
+            B012(94, 12, vars=("",)),
+            B012(101, 8, vars=("",)),
+            B012(107, 8, vars=("",)),
         ]
         self.assertEqual(errors, self.errors(*all_errors))
 
@@ -226,9 +226,9 @@ def test_b012_py311(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         all_errors = [
-            B012(7, 8),
-            B012(17, 12),
-            B012(27, 12),
+            B012(7, 8, vars=("*",)),
+            B012(17, 12, vars=("*",)),
+            B012(27, 12, vars=("*",)),
         ]
         self.assertEqual(errors, self.errors(*all_errors))
 
@@ -237,7 +237,19 @@ def test_b013(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = self.errors(
-            B013(10, 0, vars=("ValueError",)), B013(32, 0, vars=("re.error",))
+            B013(10, 0, vars=("ValueError", "")),
+            B013(32, 0, vars=("re.error", "")),
+        )
+        self.assertEqual(errors, expected)
+
+    @unittest.skipIf(sys.version_info < (3, 11), "requires 3.11+")
+    def test_b013_py311(self):
+        filename = Path(__file__).absolute().parent / "b013_py311.py"
+        bbc = BugBearChecker(filename=str(filename))
+        errors = list(bbc.run())
+        expected = self.errors(
+            B013(10, 0, vars=("ValueError", "*")),
+            B013(32, 0, vars=("re.error", "*")),
         )
         self.assertEqual(errors, expected)
 
@@ -246,17 +258,17 @@ def test_b014(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = self.errors(
-            B014(11, 0, vars=("Exception, TypeError", "", "Exception")),
-            B014(17, 0, vars=("OSError, OSError", " as err", "OSError")),
-            B014(28, 0, vars=("MyError, MyError", "", "MyError")),
-            B014(42, 0, vars=("MyError, BaseException", " as e", "BaseException")),
-            B014(49, 0, vars=("re.error, re.error", "", "re.error")),
+            B014(11, 0, vars=("Exception, TypeError", "", "Exception", "")),
+            B014(17, 0, vars=("OSError, OSError", " as err", "OSError", "")),
+            B014(28, 0, vars=("MyError, MyError", "", "MyError", "")),
+            B014(42, 0, vars=("MyError, BaseException", " as e", "BaseException", "")),
+            B014(49, 0, vars=("re.error, re.error", "", "re.error", "")),
             B014(
                 56,
                 0,
-                vars=("IOError, EnvironmentError, OSError", "", "OSError"),
+                vars=("IOError, EnvironmentError, OSError", "", "OSError", ""),
             ),
-            B014(74, 0, vars=("ValueError, binascii.Error", "", "ValueError")),
+            B014(74, 0, vars=("ValueError, binascii.Error", "", "ValueError", "")),
         )
         self.assertEqual(errors, expected)
 
@@ -266,17 +278,17 @@ def test_b014_py311(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = self.errors(
-            B014(11, 0, vars=("Exception, TypeError", "", "Exception")),
-            B014(17, 0, vars=("OSError, OSError", " as err", "OSError")),
-            B014(28, 0, vars=("MyError, MyError", "", "MyError")),
-            B014(42, 0, vars=("MyError, BaseException", " as e", "BaseException")),
-            B014(49, 0, vars=("re.error, re.error", "", "re.error")),
+            B014(11, 0, vars=("Exception, TypeError", "", "Exception", "*")),
+            B014(17, 0, vars=("OSError, OSError", " as err", "OSError", "*")),
+            B014(28, 0, vars=("MyError, MyError", "", "MyError", "*")),
+            B014(42, 0, vars=("MyError, BaseException", " as e", "BaseException", "*")),
+            B014(49, 0, vars=("re.error, re.error", "", "re.error", "*")),
             B014(
                 56,
                 0,
-                vars=("IOError, EnvironmentError, OSError", "", "OSError"),
+                vars=("IOError, EnvironmentError, OSError", "", "OSError", "*"),
             ),
-            B014(74, 0, vars=("ValueError, binascii.Error", "", "ValueError")),
+            B014(74, 0, vars=("ValueError, binascii.Error", "", "ValueError", "*")),
         )
         self.assertEqual(errors, expected)
 
@@ -571,8 +583,8 @@ def test_b029(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = self.errors(
-            B029(8, 0),
-            B029(13, 0),
+            B029(8, 0, vars=("",)),
+            B029(13, 0, vars=("",)),
         )
         self.assertEqual(errors, expected)
 
@@ -582,8 +594,8 @@ def test_b029_py311(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = self.errors(
-            B029(8, 0),
-            B029(13, 0),
+            B029(8, 0, vars=("*",)),
+            B029(13, 0, vars=("*",)),
         )
         self.assertEqual(errors, expected)
 
@@ -987,10 +999,10 @@ def test_b904(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = [
-            B904(10, 8),
-            B904(11, 4),
-            B904(16, 4),
-            B904(55, 16),
+            B904(10, 8, vars=("",)),
+            B904(11, 4, vars=("",)),
+            B904(16, 4, vars=("",)),
+            B904(55, 16, vars=("",)),
         ]
         self.assertEqual(errors, self.errors(*expected))
 
@@ -1000,10 +1012,10 @@ def test_b904_py311(self):
         bbc = BugBearChecker(filename=str(filename))
         errors = list(bbc.run())
         expected = [
-            B904(10, 8),
-            B904(11, 4),
-            B904(16, 4),
-            B904(55, 16),
+            B904(10, 8, vars=("*",)),
+            B904(11, 4, vars=("*",)),
+            B904(16, 4, vars=("*",)),
+            B904(55, 16, vars=("*",)),
         ]
         self.assertEqual(errors, self.errors(*expected))