diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2021-02-22 20:28:17 +0000 |
---|---|---|
committer | GitHub <[email protected]> | 2021-02-22 20:28:17 +0000 |
commit | 27ed1ebf8997cea55fb446ce249b390607b84105 (patch) | |
tree | a49a763fee848041fd607f449ad13a0b1040636e /crates/ide_assists/src/handlers/wrap_return_type_in_result.rs | |
parent | 8687053b118f47ce1a4962d0baa19b22d40d2758 (diff) | |
parent | eb6cfa7f157690480fca5d55c69dba3fae87ad4f (diff) |
Merge #7759
7759: 7526: Rename ide related crates r=Veykril a=chetankhilosiya
renamed assists -> ide_assists and ssr -> ide_ssr.
the completion crate is already renamed.
Co-authored-by: Chetan Khilosiya <[email protected]>
Diffstat (limited to 'crates/ide_assists/src/handlers/wrap_return_type_in_result.rs')
-rw-r--r-- | crates/ide_assists/src/handlers/wrap_return_type_in_result.rs | 1158 |
1 files changed, 1158 insertions, 0 deletions
diff --git a/crates/ide_assists/src/handlers/wrap_return_type_in_result.rs b/crates/ide_assists/src/handlers/wrap_return_type_in_result.rs new file mode 100644 index 000000000..fec16fc49 --- /dev/null +++ b/crates/ide_assists/src/handlers/wrap_return_type_in_result.rs | |||
@@ -0,0 +1,1158 @@ | |||
1 | use std::iter; | ||
2 | |||
3 | use syntax::{ | ||
4 | ast::{self, make, BlockExpr, Expr, LoopBodyOwner}, | ||
5 | match_ast, AstNode, SyntaxNode, | ||
6 | }; | ||
7 | use test_utils::mark; | ||
8 | |||
9 | use crate::{AssistContext, AssistId, AssistKind, Assists}; | ||
10 | |||
11 | // Assist: wrap_return_type_in_result | ||
12 | // | ||
13 | // Wrap the function's return type into Result. | ||
14 | // | ||
15 | // ``` | ||
16 | // fn foo() -> i32$0 { 42i32 } | ||
17 | // ``` | ||
18 | // -> | ||
19 | // ``` | ||
20 | // fn foo() -> Result<i32, ${0:_}> { Ok(42i32) } | ||
21 | // ``` | ||
22 | pub(crate) fn wrap_return_type_in_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | ||
23 | let ret_type = ctx.find_node_at_offset::<ast::RetType>()?; | ||
24 | let parent = ret_type.syntax().parent()?; | ||
25 | let block_expr = match_ast! { | ||
26 | match parent { | ||
27 | ast::Fn(func) => func.body()?, | ||
28 | ast::ClosureExpr(closure) => match closure.body()? { | ||
29 | Expr::BlockExpr(block) => block, | ||
30 | // closures require a block when a return type is specified | ||
31 | _ => return None, | ||
32 | }, | ||
33 | _ => return None, | ||
34 | } | ||
35 | }; | ||
36 | |||
37 | let type_ref = &ret_type.ty()?; | ||
38 | let ret_type_str = type_ref.syntax().text().to_string(); | ||
39 | let first_part_ret_type = ret_type_str.splitn(2, '<').next(); | ||
40 | if let Some(ret_type_first_part) = first_part_ret_type { | ||
41 | if ret_type_first_part.ends_with("Result") { | ||
42 | mark::hit!(wrap_return_type_in_result_simple_return_type_already_result); | ||
43 | return None; | ||
44 | } | ||
45 | } | ||
46 | |||
47 | acc.add( | ||
48 | AssistId("wrap_return_type_in_result", AssistKind::RefactorRewrite), | ||
49 | "Wrap return type in Result", | ||
50 | type_ref.syntax().text_range(), | ||
51 | |builder| { | ||
52 | let mut tail_return_expr_collector = TailReturnCollector::new(); | ||
53 | tail_return_expr_collector.collect_jump_exprs(&block_expr, false); | ||
54 | tail_return_expr_collector.collect_tail_exprs(&block_expr); | ||
55 | |||
56 | for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap { | ||
57 | let ok_wrapped = make::expr_call( | ||
58 | make::expr_path(make::path_unqualified(make::path_segment(make::name_ref( | ||
59 | "Ok", | ||
60 | )))), | ||
61 | make::arg_list(iter::once(ret_expr_arg.clone())), | ||
62 | ); | ||
63 | builder.replace_ast(ret_expr_arg, ok_wrapped); | ||
64 | } | ||
65 | |||
66 | match ctx.config.snippet_cap { | ||
67 | Some(cap) => { | ||
68 | let snippet = format!("Result<{}, ${{0:_}}>", type_ref); | ||
69 | builder.replace_snippet(cap, type_ref.syntax().text_range(), snippet) | ||
70 | } | ||
71 | None => builder | ||
72 | .replace(type_ref.syntax().text_range(), format!("Result<{}, _>", type_ref)), | ||
73 | } | ||
74 | }, | ||
75 | ) | ||
76 | } | ||
77 | |||
78 | struct TailReturnCollector { | ||
79 | exprs_to_wrap: Vec<ast::Expr>, | ||
80 | } | ||
81 | |||
82 | impl TailReturnCollector { | ||
83 | fn new() -> Self { | ||
84 | Self { exprs_to_wrap: vec![] } | ||
85 | } | ||
86 | /// Collect all`return` expression | ||
87 | fn collect_jump_exprs(&mut self, block_expr: &BlockExpr, collect_break: bool) { | ||
88 | let statements = block_expr.statements(); | ||
89 | for stmt in statements { | ||
90 | let expr = match &stmt { | ||
91 | ast::Stmt::ExprStmt(stmt) => stmt.expr(), | ||
92 | ast::Stmt::LetStmt(stmt) => stmt.initializer(), | ||
93 | ast::Stmt::Item(_) => continue, | ||
94 | }; | ||
95 | if let Some(expr) = &expr { | ||
96 | self.handle_exprs(expr, collect_break); | ||
97 | } | ||
98 | } | ||
99 | |||
100 | // Browse tail expressions for each block | ||
101 | if let Some(expr) = block_expr.tail_expr() { | ||
102 | if let Some(last_exprs) = get_tail_expr_from_block(&expr) { | ||
103 | for last_expr in last_exprs { | ||
104 | let last_expr = match last_expr { | ||
105 | NodeType::Node(expr) => expr, | ||
106 | NodeType::Leaf(expr) => expr.syntax().clone(), | ||
107 | }; | ||
108 | |||
109 | if let Some(last_expr) = Expr::cast(last_expr.clone()) { | ||
110 | self.handle_exprs(&last_expr, collect_break); | ||
111 | } else if let Some(expr_stmt) = ast::Stmt::cast(last_expr) { | ||
112 | let expr_stmt = match &expr_stmt { | ||
113 | ast::Stmt::ExprStmt(stmt) => stmt.expr(), | ||
114 | ast::Stmt::LetStmt(stmt) => stmt.initializer(), | ||
115 | ast::Stmt::Item(_) => None, | ||
116 | }; | ||
117 | if let Some(expr) = &expr_stmt { | ||
118 | self.handle_exprs(expr, collect_break); | ||
119 | } | ||
120 | } | ||
121 | } | ||
122 | } | ||
123 | } | ||
124 | } | ||
125 | |||
126 | fn handle_exprs(&mut self, expr: &Expr, collect_break: bool) { | ||
127 | match expr { | ||
128 | Expr::BlockExpr(block_expr) => { | ||
129 | self.collect_jump_exprs(&block_expr, collect_break); | ||
130 | } | ||
131 | Expr::ReturnExpr(ret_expr) => { | ||
132 | if let Some(ret_expr_arg) = &ret_expr.expr() { | ||
133 | self.exprs_to_wrap.push(ret_expr_arg.clone()); | ||
134 | } | ||
135 | } | ||
136 | Expr::BreakExpr(break_expr) if collect_break => { | ||
137 | if let Some(break_expr_arg) = &break_expr.expr() { | ||
138 | self.exprs_to_wrap.push(break_expr_arg.clone()); | ||
139 | } | ||
140 | } | ||
141 | Expr::IfExpr(if_expr) => { | ||
142 | for block in if_expr.blocks() { | ||
143 | self.collect_jump_exprs(&block, collect_break); | ||
144 | } | ||
145 | } | ||
146 | Expr::LoopExpr(loop_expr) => { | ||
147 | if let Some(block_expr) = loop_expr.loop_body() { | ||
148 | self.collect_jump_exprs(&block_expr, collect_break); | ||
149 | } | ||
150 | } | ||
151 | Expr::ForExpr(for_expr) => { | ||
152 | if let Some(block_expr) = for_expr.loop_body() { | ||
153 | self.collect_jump_exprs(&block_expr, collect_break); | ||
154 | } | ||
155 | } | ||
156 | Expr::WhileExpr(while_expr) => { | ||
157 | if let Some(block_expr) = while_expr.loop_body() { | ||
158 | self.collect_jump_exprs(&block_expr, collect_break); | ||
159 | } | ||
160 | } | ||
161 | Expr::MatchExpr(match_expr) => { | ||
162 | if let Some(arm_list) = match_expr.match_arm_list() { | ||
163 | arm_list.arms().filter_map(|match_arm| match_arm.expr()).for_each(|expr| { | ||
164 | self.handle_exprs(&expr, collect_break); | ||
165 | }); | ||
166 | } | ||
167 | } | ||
168 | _ => {} | ||
169 | } | ||
170 | } | ||
171 | |||
172 | fn collect_tail_exprs(&mut self, block: &BlockExpr) { | ||
173 | if let Some(expr) = block.tail_expr() { | ||
174 | self.handle_exprs(&expr, true); | ||
175 | self.fetch_tail_exprs(&expr); | ||
176 | } | ||
177 | } | ||
178 | |||
179 | fn fetch_tail_exprs(&mut self, expr: &Expr) { | ||
180 | if let Some(exprs) = get_tail_expr_from_block(expr) { | ||
181 | for node_type in &exprs { | ||
182 | match node_type { | ||
183 | NodeType::Leaf(expr) => { | ||
184 | self.exprs_to_wrap.push(expr.clone()); | ||
185 | } | ||
186 | NodeType::Node(expr) => { | ||
187 | if let Some(last_expr) = Expr::cast(expr.clone()) { | ||
188 | self.fetch_tail_exprs(&last_expr); | ||
189 | } | ||
190 | } | ||
191 | } | ||
192 | } | ||
193 | } | ||
194 | } | ||
195 | } | ||
196 | |||
197 | #[derive(Debug)] | ||
198 | enum NodeType { | ||
199 | Leaf(ast::Expr), | ||
200 | Node(SyntaxNode), | ||
201 | } | ||
202 | |||
203 | /// Get a tail expression inside a block | ||
204 | fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> { | ||
205 | match expr { | ||
206 | Expr::IfExpr(if_expr) => { | ||
207 | let mut nodes = vec![]; | ||
208 | for block in if_expr.blocks() { | ||
209 | if let Some(block_expr) = block.tail_expr() { | ||
210 | if let Some(tail_exprs) = get_tail_expr_from_block(&block_expr) { | ||
211 | nodes.extend(tail_exprs); | ||
212 | } | ||
213 | } else if let Some(last_expr) = block.syntax().last_child() { | ||
214 | nodes.push(NodeType::Node(last_expr)); | ||
215 | } else { | ||
216 | nodes.push(NodeType::Node(block.syntax().clone())); | ||
217 | } | ||
218 | } | ||
219 | Some(nodes) | ||
220 | } | ||
221 | Expr::LoopExpr(loop_expr) => { | ||
222 | loop_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)]) | ||
223 | } | ||
224 | Expr::ForExpr(for_expr) => { | ||
225 | for_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)]) | ||
226 | } | ||
227 | Expr::WhileExpr(while_expr) => { | ||
228 | while_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)]) | ||
229 | } | ||
230 | Expr::BlockExpr(block_expr) => { | ||
231 | block_expr.tail_expr().map(|lc| vec![NodeType::Node(lc.syntax().clone())]) | ||
232 | } | ||
233 | Expr::MatchExpr(match_expr) => { | ||
234 | let arm_list = match_expr.match_arm_list()?; | ||
235 | let arms: Vec<NodeType> = arm_list | ||
236 | .arms() | ||
237 | .filter_map(|match_arm| match_arm.expr()) | ||
238 | .map(|expr| match expr { | ||
239 | Expr::ReturnExpr(ret_expr) => NodeType::Node(ret_expr.syntax().clone()), | ||
240 | Expr::BreakExpr(break_expr) => NodeType::Node(break_expr.syntax().clone()), | ||
241 | _ => match expr.syntax().last_child() { | ||
242 | Some(last_expr) => NodeType::Node(last_expr), | ||
243 | None => NodeType::Node(expr.syntax().clone()), | ||
244 | }, | ||
245 | }) | ||
246 | .collect(); | ||
247 | |||
248 | Some(arms) | ||
249 | } | ||
250 | Expr::BreakExpr(expr) => expr.expr().map(|e| vec![NodeType::Leaf(e)]), | ||
251 | Expr::ReturnExpr(ret_expr) => Some(vec![NodeType::Node(ret_expr.syntax().clone())]), | ||
252 | |||
253 | Expr::CallExpr(_) | ||
254 | | Expr::Literal(_) | ||
255 | | Expr::TupleExpr(_) | ||
256 | | Expr::ArrayExpr(_) | ||
257 | | Expr::ParenExpr(_) | ||
258 | | Expr::PathExpr(_) | ||
259 | | Expr::RecordExpr(_) | ||
260 | | Expr::IndexExpr(_) | ||
261 | | Expr::MethodCallExpr(_) | ||
262 | | Expr::AwaitExpr(_) | ||
263 | | Expr::CastExpr(_) | ||
264 | | Expr::RefExpr(_) | ||
265 | | Expr::PrefixExpr(_) | ||
266 | | Expr::RangeExpr(_) | ||
267 | | Expr::BinExpr(_) | ||
268 | | Expr::MacroCall(_) | ||
269 | | Expr::BoxExpr(_) => Some(vec![NodeType::Leaf(expr.clone())]), | ||
270 | _ => None, | ||
271 | } | ||
272 | } | ||
273 | |||
274 | #[cfg(test)] | ||
275 | mod tests { | ||
276 | use crate::tests::{check_assist, check_assist_not_applicable}; | ||
277 | |||
278 | use super::*; | ||
279 | |||
280 | #[test] | ||
281 | fn wrap_return_type_in_result_simple() { | ||
282 | check_assist( | ||
283 | wrap_return_type_in_result, | ||
284 | r#" | ||
285 | fn foo() -> i3$02 { | ||
286 | let test = "test"; | ||
287 | return 42i32; | ||
288 | } | ||
289 | "#, | ||
290 | r#" | ||
291 | fn foo() -> Result<i32, ${0:_}> { | ||
292 | let test = "test"; | ||
293 | return Ok(42i32); | ||
294 | } | ||
295 | "#, | ||
296 | ); | ||
297 | } | ||
298 | |||
299 | #[test] | ||
300 | fn wrap_return_type_in_result_simple_closure() { | ||
301 | check_assist( | ||
302 | wrap_return_type_in_result, | ||
303 | r#" | ||
304 | fn foo() { | ||
305 | || -> i32$0 { | ||
306 | let test = "test"; | ||
307 | return 42i32; | ||
308 | }; | ||
309 | } | ||
310 | "#, | ||
311 | r#" | ||
312 | fn foo() { | ||
313 | || -> Result<i32, ${0:_}> { | ||
314 | let test = "test"; | ||
315 | return Ok(42i32); | ||
316 | }; | ||
317 | } | ||
318 | "#, | ||
319 | ); | ||
320 | } | ||
321 | |||
322 | #[test] | ||
323 | fn wrap_return_type_in_result_simple_return_type_bad_cursor() { | ||
324 | check_assist_not_applicable( | ||
325 | wrap_return_type_in_result, | ||
326 | r#" | ||
327 | fn foo() -> i32 { | ||
328 | let test = "test";$0 | ||
329 | return 42i32; | ||
330 | } | ||
331 | "#, | ||
332 | ); | ||
333 | } | ||
334 | |||
335 | #[test] | ||
336 | fn wrap_return_type_in_result_simple_return_type_bad_cursor_closure() { | ||
337 | check_assist_not_applicable( | ||
338 | wrap_return_type_in_result, | ||
339 | r#" | ||
340 | fn foo() { | ||
341 | || -> i32 { | ||
342 | let test = "test";$0 | ||
343 | return 42i32; | ||
344 | }; | ||
345 | } | ||
346 | "#, | ||
347 | ); | ||
348 | } | ||
349 | |||
350 | #[test] | ||
351 | fn wrap_return_type_in_result_closure_non_block() { | ||
352 | check_assist_not_applicable(wrap_return_type_in_result, r#"fn foo() { || -> i$032 3; }"#); | ||
353 | } | ||
354 | |||
355 | #[test] | ||
356 | fn wrap_return_type_in_result_simple_return_type_already_result_std() { | ||
357 | check_assist_not_applicable( | ||
358 | wrap_return_type_in_result, | ||
359 | r#" | ||
360 | fn foo() -> std::result::Result<i32$0, String> { | ||
361 | let test = "test"; | ||
362 | return 42i32; | ||
363 | } | ||
364 | "#, | ||
365 | ); | ||
366 | } | ||
367 | |||
368 | #[test] | ||
369 | fn wrap_return_type_in_result_simple_return_type_already_result() { | ||
370 | mark::check!(wrap_return_type_in_result_simple_return_type_already_result); | ||
371 | check_assist_not_applicable( | ||
372 | wrap_return_type_in_result, | ||
373 | r#" | ||
374 | fn foo() -> Result<i32$0, String> { | ||
375 | let test = "test"; | ||
376 | return 42i32; | ||
377 | } | ||
378 | "#, | ||
379 | ); | ||
380 | } | ||
381 | |||
382 | #[test] | ||
383 | fn wrap_return_type_in_result_simple_return_type_already_result_closure() { | ||
384 | check_assist_not_applicable( | ||
385 | wrap_return_type_in_result, | ||
386 | r#" | ||
387 | fn foo() { | ||
388 | || -> Result<i32$0, String> { | ||
389 | let test = "test"; | ||
390 | return 42i32; | ||
391 | }; | ||
392 | } | ||
393 | "#, | ||
394 | ); | ||
395 | } | ||
396 | |||
397 | #[test] | ||
398 | fn wrap_return_type_in_result_simple_with_cursor() { | ||
399 | check_assist( | ||
400 | wrap_return_type_in_result, | ||
401 | r#" | ||
402 | fn foo() -> $0i32 { | ||
403 | let test = "test"; | ||
404 | return 42i32; | ||
405 | } | ||
406 | "#, | ||
407 | r#" | ||
408 | fn foo() -> Result<i32, ${0:_}> { | ||
409 | let test = "test"; | ||
410 | return Ok(42i32); | ||
411 | } | ||
412 | "#, | ||
413 | ); | ||
414 | } | ||
415 | |||
416 | #[test] | ||
417 | fn wrap_return_type_in_result_simple_with_tail() { | ||
418 | check_assist( | ||
419 | wrap_return_type_in_result, | ||
420 | r#" | ||
421 | fn foo() ->$0 i32 { | ||
422 | let test = "test"; | ||
423 | 42i32 | ||
424 | } | ||
425 | "#, | ||
426 | r#" | ||
427 | fn foo() -> Result<i32, ${0:_}> { | ||
428 | let test = "test"; | ||
429 | Ok(42i32) | ||
430 | } | ||
431 | "#, | ||
432 | ); | ||
433 | } | ||
434 | |||
435 | #[test] | ||
436 | fn wrap_return_type_in_result_simple_with_tail_closure() { | ||
437 | check_assist( | ||
438 | wrap_return_type_in_result, | ||
439 | r#" | ||
440 | fn foo() { | ||
441 | || ->$0 i32 { | ||
442 | let test = "test"; | ||
443 | 42i32 | ||
444 | }; | ||
445 | } | ||
446 | "#, | ||
447 | r#" | ||
448 | fn foo() { | ||
449 | || -> Result<i32, ${0:_}> { | ||
450 | let test = "test"; | ||
451 | Ok(42i32) | ||
452 | }; | ||
453 | } | ||
454 | "#, | ||
455 | ); | ||
456 | } | ||
457 | |||
458 | #[test] | ||
459 | fn wrap_return_type_in_result_simple_with_tail_only() { | ||
460 | check_assist( | ||
461 | wrap_return_type_in_result, | ||
462 | r#"fn foo() -> i32$0 { 42i32 }"#, | ||
463 | r#"fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }"#, | ||
464 | ); | ||
465 | } | ||
466 | |||
467 | #[test] | ||
468 | fn wrap_return_type_in_result_simple_with_tail_block_like() { | ||
469 | check_assist( | ||
470 | wrap_return_type_in_result, | ||
471 | r#" | ||
472 | fn foo() -> i32$0 { | ||
473 | if true { | ||
474 | 42i32 | ||
475 | } else { | ||
476 | 24i32 | ||
477 | } | ||
478 | } | ||
479 | "#, | ||
480 | r#" | ||
481 | fn foo() -> Result<i32, ${0:_}> { | ||
482 | if true { | ||
483 | Ok(42i32) | ||
484 | } else { | ||
485 | Ok(24i32) | ||
486 | } | ||
487 | } | ||
488 | "#, | ||
489 | ); | ||
490 | } | ||
491 | |||
492 | #[test] | ||
493 | fn wrap_return_type_in_result_simple_without_block_closure() { | ||
494 | check_assist( | ||
495 | wrap_return_type_in_result, | ||
496 | r#" | ||
497 | fn foo() { | ||
498 | || -> i32$0 { | ||
499 | if true { | ||
500 | 42i32 | ||
501 | } else { | ||
502 | 24i32 | ||
503 | } | ||
504 | }; | ||
505 | } | ||
506 | "#, | ||
507 | r#" | ||
508 | fn foo() { | ||
509 | || -> Result<i32, ${0:_}> { | ||
510 | if true { | ||
511 | Ok(42i32) | ||
512 | } else { | ||
513 | Ok(24i32) | ||
514 | } | ||
515 | }; | ||
516 | } | ||
517 | "#, | ||
518 | ); | ||
519 | } | ||
520 | |||
521 | #[test] | ||
522 | fn wrap_return_type_in_result_simple_with_nested_if() { | ||
523 | check_assist( | ||
524 | wrap_return_type_in_result, | ||
525 | r#" | ||
526 | fn foo() -> i32$0 { | ||
527 | if true { | ||
528 | if false { | ||
529 | 1 | ||
530 | } else { | ||
531 | 2 | ||
532 | } | ||
533 | } else { | ||
534 | 24i32 | ||
535 | } | ||
536 | } | ||
537 | "#, | ||
538 | r#" | ||
539 | fn foo() -> Result<i32, ${0:_}> { | ||
540 | if true { | ||
541 | if false { | ||
542 | Ok(1) | ||
543 | } else { | ||
544 | Ok(2) | ||
545 | } | ||
546 | } else { | ||
547 | Ok(24i32) | ||
548 | } | ||
549 | } | ||
550 | "#, | ||
551 | ); | ||
552 | } | ||
553 | |||
554 | #[test] | ||
555 | fn wrap_return_type_in_result_simple_with_await() { | ||
556 | check_assist( | ||
557 | wrap_return_type_in_result, | ||
558 | r#" | ||
559 | async fn foo() -> i$032 { | ||
560 | if true { | ||
561 | if false { | ||
562 | 1.await | ||
563 | } else { | ||
564 | 2.await | ||
565 | } | ||
566 | } else { | ||
567 | 24i32.await | ||
568 | } | ||
569 | } | ||
570 | "#, | ||
571 | r#" | ||
572 | async fn foo() -> Result<i32, ${0:_}> { | ||
573 | if true { | ||
574 | if false { | ||
575 | Ok(1.await) | ||
576 | } else { | ||
577 | Ok(2.await) | ||
578 | } | ||
579 | } else { | ||
580 | Ok(24i32.await) | ||
581 | } | ||
582 | } | ||
583 | "#, | ||
584 | ); | ||
585 | } | ||
586 | |||
587 | #[test] | ||
588 | fn wrap_return_type_in_result_simple_with_array() { | ||
589 | check_assist( | ||
590 | wrap_return_type_in_result, | ||
591 | r#"fn foo() -> [i32;$0 3] { [1, 2, 3] }"#, | ||
592 | r#"fn foo() -> Result<[i32; 3], ${0:_}> { Ok([1, 2, 3]) }"#, | ||
593 | ); | ||
594 | } | ||
595 | |||
596 | #[test] | ||
597 | fn wrap_return_type_in_result_simple_with_cast() { | ||
598 | check_assist( | ||
599 | wrap_return_type_in_result, | ||
600 | r#" | ||
601 | fn foo() -$0> i32 { | ||
602 | if true { | ||
603 | if false { | ||
604 | 1 as i32 | ||
605 | } else { | ||
606 | 2 as i32 | ||
607 | } | ||
608 | } else { | ||
609 | 24 as i32 | ||
610 | } | ||
611 | } | ||
612 | "#, | ||
613 | r#" | ||
614 | fn foo() -> Result<i32, ${0:_}> { | ||
615 | if true { | ||
616 | if false { | ||
617 | Ok(1 as i32) | ||
618 | } else { | ||
619 | Ok(2 as i32) | ||
620 | } | ||
621 | } else { | ||
622 | Ok(24 as i32) | ||
623 | } | ||
624 | } | ||
625 | "#, | ||
626 | ); | ||
627 | } | ||
628 | |||
629 | #[test] | ||
630 | fn wrap_return_type_in_result_simple_with_tail_block_like_match() { | ||
631 | check_assist( | ||
632 | wrap_return_type_in_result, | ||
633 | r#" | ||
634 | fn foo() -> i32$0 { | ||
635 | let my_var = 5; | ||
636 | match my_var { | ||
637 | 5 => 42i32, | ||
638 | _ => 24i32, | ||
639 | } | ||
640 | } | ||
641 | "#, | ||
642 | r#" | ||
643 | fn foo() -> Result<i32, ${0:_}> { | ||
644 | let my_var = 5; | ||
645 | match my_var { | ||
646 | 5 => Ok(42i32), | ||
647 | _ => Ok(24i32), | ||
648 | } | ||
649 | } | ||
650 | "#, | ||
651 | ); | ||
652 | } | ||
653 | |||
654 | #[test] | ||
655 | fn wrap_return_type_in_result_simple_with_loop_with_tail() { | ||
656 | check_assist( | ||
657 | wrap_return_type_in_result, | ||
658 | r#" | ||
659 | fn foo() -> i32$0 { | ||
660 | let my_var = 5; | ||
661 | loop { | ||
662 | println!("test"); | ||
663 | 5 | ||
664 | } | ||
665 | my_var | ||
666 | } | ||
667 | "#, | ||
668 | r#" | ||
669 | fn foo() -> Result<i32, ${0:_}> { | ||
670 | let my_var = 5; | ||
671 | loop { | ||
672 | println!("test"); | ||
673 | 5 | ||
674 | } | ||
675 | Ok(my_var) | ||
676 | } | ||
677 | "#, | ||
678 | ); | ||
679 | } | ||
680 | |||
681 | #[test] | ||
682 | fn wrap_return_type_in_result_simple_with_loop_in_let_stmt() { | ||
683 | check_assist( | ||
684 | wrap_return_type_in_result, | ||
685 | r#" | ||
686 | fn foo() -> i32$0 { | ||
687 | let my_var = let x = loop { | ||
688 | break 1; | ||
689 | }; | ||
690 | my_var | ||
691 | } | ||
692 | "#, | ||
693 | r#" | ||
694 | fn foo() -> Result<i32, ${0:_}> { | ||
695 | let my_var = let x = loop { | ||
696 | break 1; | ||
697 | }; | ||
698 | Ok(my_var) | ||
699 | } | ||
700 | "#, | ||
701 | ); | ||
702 | } | ||
703 | |||
704 | #[test] | ||
705 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_return_expr() { | ||
706 | check_assist( | ||
707 | wrap_return_type_in_result, | ||
708 | r#" | ||
709 | fn foo() -> i32$0 { | ||
710 | let my_var = 5; | ||
711 | let res = match my_var { | ||
712 | 5 => 42i32, | ||
713 | _ => return 24i32, | ||
714 | }; | ||
715 | res | ||
716 | } | ||
717 | "#, | ||
718 | r#" | ||
719 | fn foo() -> Result<i32, ${0:_}> { | ||
720 | let my_var = 5; | ||
721 | let res = match my_var { | ||
722 | 5 => 42i32, | ||
723 | _ => return Ok(24i32), | ||
724 | }; | ||
725 | Ok(res) | ||
726 | } | ||
727 | "#, | ||
728 | ); | ||
729 | |||
730 | check_assist( | ||
731 | wrap_return_type_in_result, | ||
732 | r#" | ||
733 | fn foo() -> i32$0 { | ||
734 | let my_var = 5; | ||
735 | let res = if my_var == 5 { | ||
736 | 42i32 | ||
737 | } else { | ||
738 | return 24i32; | ||
739 | }; | ||
740 | res | ||
741 | } | ||
742 | "#, | ||
743 | r#" | ||
744 | fn foo() -> Result<i32, ${0:_}> { | ||
745 | let my_var = 5; | ||
746 | let res = if my_var == 5 { | ||
747 | 42i32 | ||
748 | } else { | ||
749 | return Ok(24i32); | ||
750 | }; | ||
751 | Ok(res) | ||
752 | } | ||
753 | "#, | ||
754 | ); | ||
755 | } | ||
756 | |||
757 | #[test] | ||
758 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_deeper() { | ||
759 | check_assist( | ||
760 | wrap_return_type_in_result, | ||
761 | r#" | ||
762 | fn foo() -> i32$0 { | ||
763 | let my_var = 5; | ||
764 | match my_var { | ||
765 | 5 => { | ||
766 | if true { | ||
767 | 42i32 | ||
768 | } else { | ||
769 | 25i32 | ||
770 | } | ||
771 | }, | ||
772 | _ => { | ||
773 | let test = "test"; | ||
774 | if test == "test" { | ||
775 | return bar(); | ||
776 | } | ||
777 | 53i32 | ||
778 | }, | ||
779 | } | ||
780 | } | ||
781 | "#, | ||
782 | r#" | ||
783 | fn foo() -> Result<i32, ${0:_}> { | ||
784 | let my_var = 5; | ||
785 | match my_var { | ||
786 | 5 => { | ||
787 | if true { | ||
788 | Ok(42i32) | ||
789 | } else { | ||
790 | Ok(25i32) | ||
791 | } | ||
792 | }, | ||
793 | _ => { | ||
794 | let test = "test"; | ||
795 | if test == "test" { | ||
796 | return Ok(bar()); | ||
797 | } | ||
798 | Ok(53i32) | ||
799 | }, | ||
800 | } | ||
801 | } | ||
802 | "#, | ||
803 | ); | ||
804 | } | ||
805 | |||
806 | #[test] | ||
807 | fn wrap_return_type_in_result_simple_with_tail_block_like_early_return() { | ||
808 | check_assist( | ||
809 | wrap_return_type_in_result, | ||
810 | r#" | ||
811 | fn foo() -> i$032 { | ||
812 | let test = "test"; | ||
813 | if test == "test" { | ||
814 | return 24i32; | ||
815 | } | ||
816 | 53i32 | ||
817 | } | ||
818 | "#, | ||
819 | r#" | ||
820 | fn foo() -> Result<i32, ${0:_}> { | ||
821 | let test = "test"; | ||
822 | if test == "test" { | ||
823 | return Ok(24i32); | ||
824 | } | ||
825 | Ok(53i32) | ||
826 | } | ||
827 | "#, | ||
828 | ); | ||
829 | } | ||
830 | |||
831 | #[test] | ||
832 | fn wrap_return_type_in_result_simple_with_closure() { | ||
833 | check_assist( | ||
834 | wrap_return_type_in_result, | ||
835 | r#" | ||
836 | fn foo(the_field: u32) ->$0 u32 { | ||
837 | let true_closure = || { return true; }; | ||
838 | if the_field < 5 { | ||
839 | let mut i = 0; | ||
840 | if true_closure() { | ||
841 | return 99; | ||
842 | } else { | ||
843 | return 0; | ||
844 | } | ||
845 | } | ||
846 | the_field | ||
847 | } | ||
848 | "#, | ||
849 | r#" | ||
850 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
851 | let true_closure = || { return true; }; | ||
852 | if the_field < 5 { | ||
853 | let mut i = 0; | ||
854 | if true_closure() { | ||
855 | return Ok(99); | ||
856 | } else { | ||
857 | return Ok(0); | ||
858 | } | ||
859 | } | ||
860 | Ok(the_field) | ||
861 | } | ||
862 | "#, | ||
863 | ); | ||
864 | |||
865 | check_assist( | ||
866 | wrap_return_type_in_result, | ||
867 | r#" | ||
868 | fn foo(the_field: u32) -> u32$0 { | ||
869 | let true_closure = || { | ||
870 | return true; | ||
871 | }; | ||
872 | if the_field < 5 { | ||
873 | let mut i = 0; | ||
874 | |||
875 | |||
876 | if true_closure() { | ||
877 | return 99; | ||
878 | } else { | ||
879 | return 0; | ||
880 | } | ||
881 | } | ||
882 | let t = None; | ||
883 | |||
884 | t.unwrap_or_else(|| the_field) | ||
885 | } | ||
886 | "#, | ||
887 | r#" | ||
888 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
889 | let true_closure = || { | ||
890 | return true; | ||
891 | }; | ||
892 | if the_field < 5 { | ||
893 | let mut i = 0; | ||
894 | |||
895 | |||
896 | if true_closure() { | ||
897 | return Ok(99); | ||
898 | } else { | ||
899 | return Ok(0); | ||
900 | } | ||
901 | } | ||
902 | let t = None; | ||
903 | |||
904 | Ok(t.unwrap_or_else(|| the_field)) | ||
905 | } | ||
906 | "#, | ||
907 | ); | ||
908 | } | ||
909 | |||
910 | #[test] | ||
911 | fn wrap_return_type_in_result_simple_with_weird_forms() { | ||
912 | check_assist( | ||
913 | wrap_return_type_in_result, | ||
914 | r#" | ||
915 | fn foo() -> i32$0 { | ||
916 | let test = "test"; | ||
917 | if test == "test" { | ||
918 | return 24i32; | ||
919 | } | ||
920 | let mut i = 0; | ||
921 | loop { | ||
922 | if i == 1 { | ||
923 | break 55; | ||
924 | } | ||
925 | i += 1; | ||
926 | } | ||
927 | } | ||
928 | "#, | ||
929 | r#" | ||
930 | fn foo() -> Result<i32, ${0:_}> { | ||
931 | let test = "test"; | ||
932 | if test == "test" { | ||
933 | return Ok(24i32); | ||
934 | } | ||
935 | let mut i = 0; | ||
936 | loop { | ||
937 | if i == 1 { | ||
938 | break Ok(55); | ||
939 | } | ||
940 | i += 1; | ||
941 | } | ||
942 | } | ||
943 | "#, | ||
944 | ); | ||
945 | |||
946 | check_assist( | ||
947 | wrap_return_type_in_result, | ||
948 | r#" | ||
949 | fn foo() -> i32$0 { | ||
950 | let test = "test"; | ||
951 | if test == "test" { | ||
952 | return 24i32; | ||
953 | } | ||
954 | let mut i = 0; | ||
955 | loop { | ||
956 | loop { | ||
957 | if i == 1 { | ||
958 | break 55; | ||
959 | } | ||
960 | i += 1; | ||
961 | } | ||
962 | } | ||
963 | } | ||
964 | "#, | ||
965 | r#" | ||
966 | fn foo() -> Result<i32, ${0:_}> { | ||
967 | let test = "test"; | ||
968 | if test == "test" { | ||
969 | return Ok(24i32); | ||
970 | } | ||
971 | let mut i = 0; | ||
972 | loop { | ||
973 | loop { | ||
974 | if i == 1 { | ||
975 | break Ok(55); | ||
976 | } | ||
977 | i += 1; | ||
978 | } | ||
979 | } | ||
980 | } | ||
981 | "#, | ||
982 | ); | ||
983 | |||
984 | check_assist( | ||
985 | wrap_return_type_in_result, | ||
986 | r#" | ||
987 | fn foo() -> i3$02 { | ||
988 | let test = "test"; | ||
989 | let other = 5; | ||
990 | if test == "test" { | ||
991 | let res = match other { | ||
992 | 5 => 43, | ||
993 | _ => return 56, | ||
994 | }; | ||
995 | } | ||
996 | let mut i = 0; | ||
997 | loop { | ||
998 | loop { | ||
999 | if i == 1 { | ||
1000 | break 55; | ||
1001 | } | ||
1002 | i += 1; | ||
1003 | } | ||
1004 | } | ||
1005 | } | ||
1006 | "#, | ||
1007 | r#" | ||
1008 | fn foo() -> Result<i32, ${0:_}> { | ||
1009 | let test = "test"; | ||
1010 | let other = 5; | ||
1011 | if test == "test" { | ||
1012 | let res = match other { | ||
1013 | 5 => 43, | ||
1014 | _ => return Ok(56), | ||
1015 | }; | ||
1016 | } | ||
1017 | let mut i = 0; | ||
1018 | loop { | ||
1019 | loop { | ||
1020 | if i == 1 { | ||
1021 | break Ok(55); | ||
1022 | } | ||
1023 | i += 1; | ||
1024 | } | ||
1025 | } | ||
1026 | } | ||
1027 | "#, | ||
1028 | ); | ||
1029 | |||
1030 | check_assist( | ||
1031 | wrap_return_type_in_result, | ||
1032 | r#" | ||
1033 | fn foo(the_field: u32) -> u32$0 { | ||
1034 | if the_field < 5 { | ||
1035 | let mut i = 0; | ||
1036 | loop { | ||
1037 | if i > 5 { | ||
1038 | return 55u32; | ||
1039 | } | ||
1040 | i += 3; | ||
1041 | } | ||
1042 | match i { | ||
1043 | 5 => return 99, | ||
1044 | _ => return 0, | ||
1045 | }; | ||
1046 | } | ||
1047 | the_field | ||
1048 | } | ||
1049 | "#, | ||
1050 | r#" | ||
1051 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
1052 | if the_field < 5 { | ||
1053 | let mut i = 0; | ||
1054 | loop { | ||
1055 | if i > 5 { | ||
1056 | return Ok(55u32); | ||
1057 | } | ||
1058 | i += 3; | ||
1059 | } | ||
1060 | match i { | ||
1061 | 5 => return Ok(99), | ||
1062 | _ => return Ok(0), | ||
1063 | }; | ||
1064 | } | ||
1065 | Ok(the_field) | ||
1066 | } | ||
1067 | "#, | ||
1068 | ); | ||
1069 | |||
1070 | check_assist( | ||
1071 | wrap_return_type_in_result, | ||
1072 | r#" | ||
1073 | fn foo(the_field: u32) -> u3$02 { | ||
1074 | if the_field < 5 { | ||
1075 | let mut i = 0; | ||
1076 | match i { | ||
1077 | 5 => return 99, | ||
1078 | _ => return 0, | ||
1079 | } | ||
1080 | } | ||
1081 | the_field | ||
1082 | } | ||
1083 | "#, | ||
1084 | r#" | ||
1085 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
1086 | if the_field < 5 { | ||
1087 | let mut i = 0; | ||
1088 | match i { | ||
1089 | 5 => return Ok(99), | ||
1090 | _ => return Ok(0), | ||
1091 | } | ||
1092 | } | ||
1093 | Ok(the_field) | ||
1094 | } | ||
1095 | "#, | ||
1096 | ); | ||
1097 | |||
1098 | check_assist( | ||
1099 | wrap_return_type_in_result, | ||
1100 | r#" | ||
1101 | fn foo(the_field: u32) -> u32$0 { | ||
1102 | if the_field < 5 { | ||
1103 | let mut i = 0; | ||
1104 | if i == 5 { | ||
1105 | return 99 | ||
1106 | } else { | ||
1107 | return 0 | ||
1108 | } | ||
1109 | } | ||
1110 | the_field | ||
1111 | } | ||
1112 | "#, | ||
1113 | r#" | ||
1114 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
1115 | if the_field < 5 { | ||
1116 | let mut i = 0; | ||
1117 | if i == 5 { | ||
1118 | return Ok(99) | ||
1119 | } else { | ||
1120 | return Ok(0) | ||
1121 | } | ||
1122 | } | ||
1123 | Ok(the_field) | ||
1124 | } | ||
1125 | "#, | ||
1126 | ); | ||
1127 | |||
1128 | check_assist( | ||
1129 | wrap_return_type_in_result, | ||
1130 | r#" | ||
1131 | fn foo(the_field: u32) -> $0u32 { | ||
1132 | if the_field < 5 { | ||
1133 | let mut i = 0; | ||
1134 | if i == 5 { | ||
1135 | return 99; | ||
1136 | } else { | ||
1137 | return 0; | ||
1138 | } | ||
1139 | } | ||
1140 | the_field | ||
1141 | } | ||
1142 | "#, | ||
1143 | r#" | ||
1144 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
1145 | if the_field < 5 { | ||
1146 | let mut i = 0; | ||
1147 | if i == 5 { | ||
1148 | return Ok(99); | ||
1149 | } else { | ||
1150 | return Ok(0); | ||
1151 | } | ||
1152 | } | ||
1153 | Ok(the_field) | ||
1154 | } | ||
1155 | "#, | ||
1156 | ); | ||
1157 | } | ||
1158 | } | ||