ide_assists/handlers/
remove_parentheses.rs

1use syntax::{AstNode, SyntaxKind, T, ast, syntax_editor::Position};
2
3use crate::{AssistContext, AssistId, Assists};
4
5// Assist: remove_parentheses
6//
7// Removes redundant parentheses.
8//
9// ```
10// fn main() {
11//     _ = $0(2) + 2;
12// }
13// ```
14// ->
15// ```
16// fn main() {
17//     _ = 2 + 2;
18// }
19// ```
20pub(crate) fn remove_parentheses(acc: &mut Assists, ctx: &AssistContext<'_, '_>) -> Option<()> {
21    let parens = ctx.find_node_at_offset::<ast::ParenExpr>()?;
22
23    let cursor_in_range =
24        parens.l_paren_token()?.text_range().contains_range(ctx.selection_trimmed())
25            || parens.r_paren_token()?.text_range().contains_range(ctx.selection_trimmed());
26    if !cursor_in_range {
27        return None;
28    }
29
30    let expr = parens.expr()?;
31
32    let parent = parens.syntax().parent()?;
33    if expr.needs_parens_in(&parent) {
34        return None;
35    }
36
37    let target = parens.syntax().text_range();
38    acc.add(
39        AssistId::refactor("remove_parentheses"),
40        "Remove redundant parentheses",
41        target,
42        |builder| {
43            let editor = builder.make_editor(parens.syntax());
44            let make = editor.make();
45            let prev_token = parens.syntax().first_token().and_then(|it| it.prev_token());
46            let need_to_add_ws = match prev_token {
47                Some(it) => {
48                    let tokens = [T![&], T![!], T!['('], T!['['], T!['{']];
49                    it.kind() != SyntaxKind::WHITESPACE && !tokens.contains(&it.kind())
50                }
51                None => false,
52            };
53            if need_to_add_ws {
54                editor.insert(Position::before(parens.syntax()), make.whitespace(" "));
55            }
56            editor.replace(parens.syntax(), expr.syntax());
57            builder.add_file_edits(ctx.vfs_file_id(), editor);
58        },
59    )
60}
61
62#[cfg(test)]
63mod tests {
64    use crate::tests::{check_assist, check_assist_not_applicable};
65
66    use super::*;
67
68    #[test]
69    fn remove_parens_space() {
70        check_assist(
71            remove_parentheses,
72            r#"fn f() { match$0(true) {} }"#,
73            r#"fn f() { match true {} }"#,
74        );
75    }
76
77    #[test]
78    fn remove_parens_simple() {
79        check_assist(remove_parentheses, r#"fn f() { $0(2) + 2; }"#, r#"fn f() { 2 + 2; }"#);
80        check_assist(remove_parentheses, r#"fn f() { ($02) + 2; }"#, r#"fn f() { 2 + 2; }"#);
81        check_assist(remove_parentheses, r#"fn f() { (2)$0 + 2; }"#, r#"fn f() { 2 + 2; }"#);
82        check_assist(remove_parentheses, r#"fn f() { (2$0) + 2; }"#, r#"fn f() { 2 + 2; }"#);
83    }
84
85    #[test]
86    fn remove_parens_closure() {
87        check_assist(remove_parentheses, r#"fn f() { &$0(|| 42) }"#, r#"fn f() { &|| 42 }"#);
88
89        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0(|| 42).f() }"#);
90    }
91
92    #[test]
93    fn remove_parens_if_let_chains() {
94        check_assist_not_applicable(
95            remove_parentheses,
96            r#"fn f() { if let true = $0(true && true) {} }"#,
97        );
98    }
99
100    #[test]
101    fn remove_parens_associativity() {
102        check_assist(
103            remove_parentheses,
104            r#"fn f() { $0(2 + 2) + 2; }"#,
105            r#"fn f() { 2 + 2 + 2; }"#,
106        );
107        check_assist_not_applicable(remove_parentheses, r#"fn f() { 2 + $0(2 + 2); }"#);
108    }
109
110    #[test]
111    fn remove_parens_precedence() {
112        check_assist(
113            remove_parentheses,
114            r#"fn f() { $0(2 * 3) + 1; }"#,
115            r#"fn f() { 2 * 3 + 1; }"#,
116        );
117        check_assist(remove_parentheses, r#"fn f() { ( $0(2) ); }"#, r#"fn f() { ( 2 ); }"#);
118        check_assist(remove_parentheses, r#"fn f() { $0(2?)?; }"#, r#"fn f() { 2??; }"#);
119        check_assist(remove_parentheses, r#"fn f() { f(($02 + 2)); }"#, r#"fn f() { f(2 + 2); }"#);
120        check_assist(
121            remove_parentheses,
122            r#"fn f() { (1<2) &&$0(3>4); }"#,
123            r#"fn f() { (1<2) && 3>4; }"#,
124        );
125    }
126
127    #[test]
128    fn remove_parens_doesnt_apply_precedence() {
129        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0(2 + 2) * 8; }"#);
130        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0(2 + 2).f(); }"#);
131        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0(2 + 2).await; }"#);
132        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0!(2..2); }"#);
133    }
134
135    #[test]
136    fn remove_parens_doesnt_apply_with_cursor_not_on_paren() {
137        check_assist_not_applicable(remove_parentheses, r#"fn f() { (2 +$0 2) }"#);
138        check_assist_not_applicable(remove_parentheses, r#"fn f() {$0 (2 + 2) }"#);
139    }
140
141    #[test]
142    fn remove_parens_doesnt_apply_when_expr_would_be_turned_into_a_statement() {
143        check_assist_not_applicable(remove_parentheses, r#"fn x() -> u8 { $0({ 0 } + 1) }"#);
144        check_assist_not_applicable(
145            remove_parentheses,
146            r#"fn x() -> u8 { $0(if true { 0 } else { 1 } + 1) }"#,
147        );
148        check_assist_not_applicable(remove_parentheses, r#"fn x() -> u8 { $0(loop {} + 1) }"#);
149    }
150
151    #[test]
152    fn remove_parens_doesnt_apply_weird_syntax_and_edge_cases() {
153        // removing `()` would break code because {} would be counted as the loop/if body
154        check_assist_not_applicable(remove_parentheses, r#"fn f() { for _ in $0(0..{3}) {} }"#);
155        check_assist_not_applicable(remove_parentheses, r#"fn f() { for _ in $0(S {}) {} }"#);
156        check_assist_not_applicable(remove_parentheses, r#"fn f() { if $0(S {} == 2) {} }"#);
157        check_assist_not_applicable(remove_parentheses, r#"fn f() { if $0(return) {} }"#);
158    }
159
160    #[test]
161    fn remove_parens_prefix_with_ret_like_prefix() {
162        check_assist(remove_parentheses, r#"fn f() { !$0(return) }"#, r#"fn f() { !return }"#);
163        // `break`, `continue` behave the same under prefix operators
164        check_assist(remove_parentheses, r#"fn f() { !$0(break) }"#, r#"fn f() { !break }"#);
165        check_assist(remove_parentheses, r#"fn f() { !$0(continue) }"#, r#"fn f() { !continue }"#);
166        check_assist(
167            remove_parentheses,
168            r#"fn f() { !$0(return false) }"#,
169            r#"fn f() { !return false }"#,
170        );
171
172        // Binary operators should still allow removal unless a ret-like expression is immediately followed by `||` or `&&`.
173        check_assist(
174            remove_parentheses,
175            r#"fn f() { true || $0(return) }"#,
176            r#"fn f() { true || return }"#,
177        );
178        check_assist(
179            remove_parentheses,
180            r#"fn f() { cond && $0(return) }"#,
181            r#"fn f() { cond && return }"#,
182        );
183    }
184
185    #[test]
186    fn remove_parens_return_with_value_followed_by_block() {
187        check_assist(
188            remove_parentheses,
189            r#"fn f() { if $0(return ()) {} }"#,
190            r#"fn f() { if return () {} }"#,
191        );
192    }
193
194    #[test]
195    fn remove_exprs_let_else_restrictions() {
196        // `}` is not allowed before `else` here
197        check_assist_not_applicable(
198            remove_parentheses,
199            r#"fn f() { let _ = $0(S{}) else { return }; }"#,
200        );
201
202        // logic operators can't directly appear in the let-else
203        check_assist_not_applicable(
204            remove_parentheses,
205            r#"fn f() { let _ = $0(false || false) else { return }; }"#,
206        );
207        check_assist_not_applicable(
208            remove_parentheses,
209            r#"fn f() { let _ = $0(true && true) else { return }; }"#,
210        );
211    }
212
213    #[test]
214    fn remove_parens_weird_places() {
215        check_assist(
216            remove_parentheses,
217            r#"fn f() { match () { _ =>$0(()) } }"#,
218            r#"fn f() { match () { _ => () } }"#,
219        );
220
221        check_assist(
222            remove_parentheses,
223            r#"fn x() -> u8 { { [$0({ 0 } + 1)] } }"#,
224            r#"fn x() -> u8 { { [{ 0 } + 1] } }"#,
225        );
226    }
227
228    #[test]
229    fn remove_parens_return_dot_f() {
230        check_assist(
231            remove_parentheses,
232            r#"fn f() { $0(return).f() }"#,
233            r#"fn f() { return.f() }"#,
234        );
235    }
236
237    #[test]
238    fn remove_parens_prefix_then_return_something() {
239        check_assist(
240            remove_parentheses,
241            r#"fn f() { &$0(return ()) }"#,
242            r#"fn f() { &return () }"#,
243        );
244    }
245
246    #[test]
247    fn remove_parens_return_in_unary_not() {
248        check_assist(
249            remove_parentheses,
250            r#"fn f() { cond && !$0(return) }"#,
251            r#"fn f() { cond && !return }"#,
252        );
253        check_assist(
254            remove_parentheses,
255            r#"fn f() { cond && !$0(return false) }"#,
256            r#"fn f() { cond && !return false }"#,
257        );
258    }
259
260    #[test]
261    fn remove_parens_return_in_disjunction_with_closure_risk() {
262        // `return` may only be blocked when it would form `return ||` or `return &&`
263        check_assist_not_applicable(
264            remove_parentheses,
265            r#"fn f() { let _x = true && $0(return) || true; }"#,
266        );
267        check_assist_not_applicable(
268            remove_parentheses,
269            r#"fn f() { let _x = true && !$0(return) || true; }"#,
270        );
271        check_assist_not_applicable(
272            remove_parentheses,
273            r#"fn f() { let _x = true && $0(return false) || true; }"#,
274        );
275        check_assist_not_applicable(
276            remove_parentheses,
277            r#"fn f() { let _x = true && !$0(return false) || true; }"#,
278        );
279        check_assist_not_applicable(
280            remove_parentheses,
281            r#"fn f() { let _x = true && $0(return) && true; }"#,
282        );
283        check_assist_not_applicable(
284            remove_parentheses,
285            r#"fn f() { let _x = true && !$0(return) && true; }"#,
286        );
287        check_assist_not_applicable(
288            remove_parentheses,
289            r#"fn f() { let _x = true && $0(return false) && true; }"#,
290        );
291        check_assist_not_applicable(
292            remove_parentheses,
293            r#"fn f() { let _x = true && !$0(return false) && true; }"#,
294        );
295        check_assist_not_applicable(
296            remove_parentheses,
297            r#"fn f() { let _x = $0(return) || true; }"#,
298        );
299        check_assist_not_applicable(
300            remove_parentheses,
301            r#"fn f() { let _x = $0(return) && true; }"#,
302        );
303    }
304
305    #[test]
306    fn remove_parens_return_in_disjunction_is_ok() {
307        check_assist(
308            remove_parentheses,
309            r#"fn f() { let _x = true || $0(return); }"#,
310            r#"fn f() { let _x = true || return; }"#,
311        );
312        check_assist(
313            remove_parentheses,
314            r#"fn f() { let _x = true && $0(return); }"#,
315            r#"fn f() { let _x = true && return; }"#,
316        );
317    }
318
319    #[test]
320    fn remove_parens_conflict_cast_before_l_angle() {
321        check_assist_not_applicable(remove_parentheses, r#"fn f() { _ = $0(1 as u32) << 10; }"#);
322        check_assist_not_applicable(remove_parentheses, r#"fn f() { _ = $0(1 as u32) < 10; }"#);
323    }
324
325    #[test]
326    fn remove_parens_double_paren_stmt() {
327        check_assist(
328            remove_parentheses,
329            r#"fn x() -> u8 { $0(({ 0 } + 1)) }"#,
330            r#"fn x() -> u8 { ({ 0 } + 1) }"#,
331        );
332
333        check_assist(
334            remove_parentheses,
335            r#"fn x() -> u8 { (($0{ 0 } + 1)) }"#,
336            r#"fn x() -> u8 { ({ 0 } + 1) }"#,
337        );
338    }
339
340    #[test]
341    fn remove_parens_im_tired_of_naming_tests() {
342        check_assist(
343            remove_parentheses,
344            r#"fn f() { 2 + $0(return 2) }"#,
345            r#"fn f() { 2 + return 2 }"#,
346        );
347
348        check_assist_not_applicable(remove_parentheses, r#"fn f() { $0(return 2) + 2 }"#);
349    }
350
351    #[test]
352    fn remove_parens_indirect_calls() {
353        check_assist(
354            remove_parentheses,
355            r#"fn f(call: fn(usize), arg: usize) { $0(call)(arg); }"#,
356            r#"fn f(call: fn(usize), arg: usize) { call(arg); }"#,
357        );
358        check_assist(
359            remove_parentheses,
360            r#"fn f<F>(call: F, arg: usize) where F: Fn(usize) { $0(call)(arg); }"#,
361            r#"fn f<F>(call: F, arg: usize) where F: Fn(usize) { call(arg); }"#,
362        );
363
364        // Parentheses are necessary when calling a function-like pointer that is a member of a struct or union.
365        check_assist_not_applicable(
366            remove_parentheses,
367            r#"
368struct Foo<T> {
369    t: T,
370}
371
372impl Foo<fn(usize)> {
373    fn foo(&self, arg: usize) {
374        $0(self.t)(arg);
375    }
376}"#,
377        );
378    }
379}
ide_assists/handlers/remove_parentheses.rs

ide_assists/handlers/
remove_parentheses.rs
