refactor: handle ret-like expressions in remove_parentheses and precedence checks

Author: asuto15

crates/ide-assists/src/handlers/remove_parentheses.rs

@@ -174,7 +174,7 @@ mod tests {
             r#"fn f() { !return false }"#,
         );
 
-        // Binary operators should still allow removal
+        // Binary operators should still allow removal unless a ret-like expression is immediately followed by `||` or `&&`.
         check_assist(
             remove_parentheses,
             r#"fn f() { true || $0(return) }"#,
@@ -297,14 +297,27 @@ mod tests {
             remove_parentheses,
             r#"fn f() { let _x = true && !$0(return false) && true; }"#,
         );
+        check_assist_not_applicable(
+            remove_parentheses,
+            r#"fn f() { let _x = $0(return) || true; }"#,
+        );
+        check_assist_not_applicable(
+            remove_parentheses,
+            r#"fn f() { let _x = $0(return) && true; }"#,
+        );
     }
 
     #[test]
     fn remove_parens_return_in_disjunction_is_ok() {
         check_assist(
             remove_parentheses,
-            r#"fn f() { let _ = true || $0(return); }"#,
-            r#"fn f() { let _ = true || return; }"#,
+            r#"fn f() { let _x = true || $0(return); }"#,
+            r#"fn f() { let _x = true || return; }"#,
+        );
+        check_assist(
+            remove_parentheses,
+            r#"fn f() { let _x = true && $0(return); }"#,
+            r#"fn f() { let _x = true && return; }"#,
         );
     }
 

crates/syntax/src/ast/prec.rs

@@ -5,7 +5,7 @@ use stdx::always;
 use crate::{
     AstNode, Direction, SyntaxNode, T,
     algo::skip_trivia_token,
-    ast::{self, BinExpr, BinaryOp, Expr, HasArgList, RangeItem},
+    ast::{self, BinaryOp, Expr, HasArgList, RangeItem},
     match_ast,
 };
 
@@ -225,19 +225,11 @@ impl Expr {
         // For `||`, removing parens could reparse as `<ret-like> || <closure>`.
         // For `&&`, we avoid introducing `<ret-like> && <expr>` into a binary chain.
 
-        if matches!(
-            self,
-            Expr::ReturnExpr(_)
-                | Expr::BreakExpr(_)
-                | Expr::BecomeExpr(_)
-                | Expr::YeetExpr(_)
-                | Expr::YieldExpr(_)
-        ) && let Some(paren_expr) = self.syntax().parent().and_then(ast::ParenExpr::cast)
-            && let Some(parent_expr) = paren_expr.syntax().parent().and_then(ast::Expr::cast)
-            && BinExpr::can_cast(parent_expr.syntax().kind())
-            && let Some(r_paren) = paren_expr.r_paren_token()
+        if self.precedence() == ExprPrecedence::Jump
+            && let Some(node) =
+                place_of.ancestors().find(|it| it.parent().is_none_or(|p| &p == parent.syntax()))
             && let Some(next) =
-                r_paren.next_token().and_then(|t| skip_trivia_token(t, Direction::Next))
+                node.last_token().and_then(|t| skip_trivia_token(t.next_token()?, Direction::Next))
             && matches!(next.kind(), T![||] | T![&&])
         {
             return true;