Add b040: exception with note added not re-raised or used (#12097)

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B040.py

@@ -0,0 +1,196 @@
+def arbitrary_fun(*args, **kwargs): ...
+
+
+def broken():
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # error
+
+def not_broken():
+    try:
+        ...
+    except Exception as e:  # safe (other linters will catch this)
+        pass
+
+def not_broken2():
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")
+        raise  # safe
+
+def broken2():
+    # other exception raised
+    try:
+        ...
+    except Exception as e:
+        f = ValueError()
+        e.add_note("...")  # error
+        raise f
+
+def not_broken3():
+    # raised as cause
+    try:
+        ...
+    except Exception as e:
+        f = ValueError()
+        e.add_note("...")  # safe
+        raise f from e
+
+def not_broken4():
+    # assigned to other variable
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        foo = e
+
+def not_broken5():
+    # "used" in function call
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        # not that printing the exception is actually using it, but we treat
+        # it being used as a parameter to any function as "using" it
+        print(e)
+
+def not_broken6():
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        list(e)
+
+def not_broken7():
+    # kwarg
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        arbitrary_fun(kwarg=e)
+
+def not_broken8():
+    # stararg
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        arbitrary_fun(*(e,))
+
+def not_broken9():
+    try:
+        ...
+    except Exception as e:
+        e.add_note("...")  # safe
+        arbitrary_fun(**{"e": e})
+
+
+def broken3():
+    # multiple ExceptHandlers
+    try:
+        ...
+    except ValueError as e:
+        e.add_note("")  # error
+    except TypeError as e:
+        raise e
+
+def not_broken10():
+    # exception variable used before `add_note`
+    mylist = []
+    try:
+        ...
+    except Exception as e: # safe
+        mylist.append(e)
+        e.add_note("")
+
+def not_broken11():
+    # AnnAssign
+    try:
+        ...
+    except Exception as e:  # safe
+        e.add_note("")
+        ann_assign_target: Exception = e
+
+def broken4():
+    # special case: e is only used in the `add_note` call itself
+    try:
+        ...
+    except Exception as e:  # error
+        e.add_note(str(e))
+        e.add_note(str(e))
+
+def broken5():
+    # check nesting
+    try:
+        ...
+    except Exception as e:  # error
+        e.add_note("")
+        try:
+            ...
+        except ValueError as e:
+            raise
+
+def broken6():
+    # questionable if this should error
+    try:
+        ...
+    except Exception as e:
+        e.add_note("")
+        e = ValueError()
+
+
+
+def broken7():
+    exc = ValueError()
+    exc.add_note("")
+
+
+def not_broken12(exc: ValueError):
+    exc.add_note("")
+
+
+
+def not_broken13():
+    e2 = ValueError()
+    try:
+        ...
+    except Exception as e:
+        e2.add_note(str(e))  # safe
+    raise e2
+
+
+def broken8():
+    try:
+        ...
+    except Exception as e:  # should error
+        e.add_note("")
+        f = lambda e: e
+
+def broken9():
+    try:
+        ...
+    except Exception as e:  # should error
+        e.add_note("")
+
+        def habla(e):
+            raise e
+
+
+# *** unhandled cases ***
+# We also don't track other variables
+try:
+    ...
+except Exception as e:
+    e3 = e
+    e3.add_note("")  # should error
+
+# we currently only check the target of the except handler, even though this clearly
+# is hitting the same general pattern. But handling this case without a lot of false
+# alarms is very tricky without more infrastructure.
+try:
+    ...
+except Exception as e:
+    e2 = ValueError()  # should error
+    e2.add_note(str(e))

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -1474,6 +1474,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker, stmt, body, handlers, orelse, finalbody,
                 );
             }
+            if checker.enabled(Rule::SuppressedException) {
+                flake8_bugbear::rules::suppressed_exception(checker, handlers);
+            }
             if checker.enabled(Rule::ReturnInTryExceptFinally) {
                 flake8_simplify::rules::return_in_try_except_finally(
                     checker, body, handlers, finalbody,

crates/ruff_linter/src/codes.rs

@@ -347,6 +347,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Bugbear, "034") => (RuleGroup::Stable, rules::flake8_bugbear::rules::ReSubPositionalArgs),
         (Flake8Bugbear, "035") => (RuleGroup::Stable, rules::flake8_bugbear::rules::StaticKeyDictComprehension),
         (Flake8Bugbear, "039") => (RuleGroup::Preview, rules::flake8_bugbear::rules::MutableContextvarDefault),
+        (Flake8Bugbear, "040") => (RuleGroup::Preview, rules::flake8_bugbear::rules::SuppressedException),
         (Flake8Bugbear, "901") => (RuleGroup::Preview, rules::flake8_bugbear::rules::ReturnInGenerator),
         (Flake8Bugbear, "904") => (RuleGroup::Stable, rules::flake8_bugbear::rules::RaiseWithoutFromInsideExcept),
         (Flake8Bugbear, "905") => (RuleGroup::Stable, rules::flake8_bugbear::rules::ZipWithoutExplicitStrict),

crates/ruff_linter/src/rules/flake8_bugbear/mod.rs

@@ -65,6 +65,7 @@ mod tests {
     #[test_case(Rule::ReturnInGenerator, Path::new("B901.py"))]
     #[test_case(Rule::LoopIteratorMutation, Path::new("B909.py"))]
     #[test_case(Rule::MutableContextvarDefault, Path::new("B039.py"))]
+    #[test_case(Rule::SuppressedException, Path::new("B040.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(

crates/ruff_linter/src/rules/flake8_bugbear/rules/mod.rs

@@ -27,6 +27,7 @@ pub(crate) use setattr_with_constant::*;
 pub(crate) use star_arg_unpacking_after_keyword_arg::*;
 pub(crate) use static_key_dict_comprehension::*;
 pub(crate) use strip_with_multi_characters::*;
+pub(crate) use suppressed_exception::*;
 pub(crate) use unary_prefix_increment_decrement::*;
 pub(crate) use unintentional_type_annotation::*;
 pub(crate) use unreliable_callable_check::*;
@@ -65,6 +66,7 @@ mod setattr_with_constant;
 mod star_arg_unpacking_after_keyword_arg;
 mod static_key_dict_comprehension;
 mod strip_with_multi_characters;
+mod suppressed_exception;
 mod unary_prefix_increment_decrement;
 mod unintentional_type_annotation;
 mod unreliable_callable_check;