Make TRY301 trigger only if a raise throws a caught exception

crates/ruff/resources/test/fixtures/tryceratops/TRY301.py

@@ -57,3 +57,11 @@ def fine():
         a = process()  # This throws the exception now
     finally:
         print("finally")
+
+
+def fine():
+    try:
+        raise ValueError("a doesn't exist")
+
+    except TypeError: # A different exception is caught
+        print("A different exception is caught")

crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs

@@ -1,13 +1,18 @@
-use rustpython_parser::ast::{ExceptHandler, Ranged, Stmt};
+use rustpython_parser::ast::{self, ExceptHandler, Expr, Ranged, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
+use ruff_python_ast::{
+    comparable::ComparableExpr,
+    helpers::{self, map_callable},
+    statement_visitor::{walk_stmt, StatementVisitor},
+};
 
 use crate::checkers::ast::Checker;
 
 /// ## What it does
-/// Checks for `raise` statements within `try` blocks.
+/// Checks for `raise` statements within `try` blocks. The only `raise`s
+/// caught are those that throw exceptions caught by the `try` statement itself.
 ///
 /// ## Why is this bad?
 /// Raising and catching exceptions within the same `try` block is redundant,
@@ -83,9 +88,42 @@ pub(crate) fn raise_within_try(checker: &mut Checker, body: &[Stmt], handlers: &
         visitor.raises
     };
 
+    if raises.is_empty() {
+        return;
+    }
+
+    let handled_exceptions = helpers::extract_handled_exceptions(handlers);
+    let comparables: Vec<ComparableExpr> = handled_exceptions
+        .iter()
+        .filter_map(|handler| {
+            if let Expr::Name(ast::ExprName { .. }) = handler {
+                Some(ComparableExpr::from(*handler))
+            } else {
+                None
+            }
+        })
+        .collect();
+
     for stmt in raises {
-        checker
-            .diagnostics
-            .push(Diagnostic::new(RaiseWithinTry, stmt.range()));
+        let Stmt::Raise(ast::StmtRaise { exc: Some(exception), .. }) = stmt else {
+            continue;
+        };
+
+        // We can't check exception sub-classes without a type-checker implementation, so let's
+        // just catch the blanket `Exception` for now.
+        if comparables.contains(&ComparableExpr::from(map_callable(exception)))
+            || handled_exceptions.iter().any(|expr| {
+                checker
+                    .semantic()
+                    .resolve_call_path(expr)
+                    .map_or(false, |call_path| {
+                        matches!(call_path.as_slice(), ["", "Exception" | "BaseException"])
+                    })
+            })
+        {
+            checker
+                .diagnostics
+                .push(Diagnostic::new(RaiseWithinTry, stmt.range()));
+        }
     }
 }