6 BLOCK_EXPR, BREAK_EXPR, CLOSURE_EXPR, COMMENT, LOOP_EXPR, MATCH_ARM, MATCH_GUARD,
7 PATH_EXPR, RETURN_EXPR,
12 use crate::{utils::suggest_name, AssistContext, AssistId, AssistKind, Assists};
14 // Assist: extract_variable
16 // Extracts subexpression into a variable.
26 // let $0var_name = (1 + 2);
30 pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
31 if ctx.has_empty_selection() {
35 let node = match ctx.covering_element() {
36 NodeOrToken::Node(it) => it,
37 NodeOrToken::Token(it) if it.kind() == COMMENT => {
38 cov_mark::hit!(extract_var_in_comment_is_not_applicable);
41 NodeOrToken::Token(it) => it.parent()?,
43 let node = node.ancestors().take_while(|anc| anc.text_range() == node.text_range()).last()?;
46 .take_while(|it| ctx.selection_trimmed().contains_range(it.text_range()))
47 .find_map(valid_target_expr)?;
49 if let Some(ty_info) = ctx.sema.type_of_expr(&to_extract) {
50 if ty_info.adjusted().is_unit() {
55 let reference_modifier = match get_receiver_type(ctx, &to_extract) {
56 Some(receiver_type) if receiver_type.is_mutable_reference() => "&mut ",
57 Some(receiver_type) if receiver_type.is_reference() => "&",
61 let parent_ref_expr = to_extract.syntax().parent().and_then(ast::RefExpr::cast);
62 let var_modifier = match parent_ref_expr {
63 Some(expr) if expr.mut_token().is_some() => "mut ",
67 let anchor = Anchor::from(&to_extract)?;
68 let indent = anchor.syntax().prev_sibling_or_token()?.as_token()?.clone();
69 let target = to_extract.syntax().text_range();
71 AssistId("extract_variable", AssistKind::RefactorExtract),
72 "Extract into variable",
76 match to_extract.syntax().parent().and_then(ast::RecordExprField::cast) {
77 Some(field) => field.name_ref(),
81 let mut buf = String::new();
83 let var_name = match &field_shorthand {
84 Some(it) => it.to_string(),
85 None => suggest_name::for_variable(&to_extract, &ctx.sema),
87 let expr_range = match &field_shorthand {
88 Some(it) => it.syntax().text_range().cover(to_extract.syntax().text_range()),
89 None => to_extract.syntax().text_range(),
93 Anchor::Before(_) | Anchor::Replace(_) => {
94 format_to!(buf, "let {var_modifier}{var_name} = {reference_modifier}")
96 Anchor::WrapInBlock(_) => {
97 format_to!(buf, "{{ let {var_name} = {reference_modifier}")
100 format_to!(buf, "{to_extract}");
102 if let Anchor::Replace(stmt) = anchor {
103 cov_mark::hit!(test_extract_var_expr_stmt);
104 if stmt.semicolon_token().is_none() {
107 match ctx.config.snippet_cap {
109 let snip = buf.replace(
110 &format!("let {var_modifier}{var_name}"),
111 &format!("let {var_modifier}$0{var_name}"),
113 edit.replace_snippet(cap, expr_range, snip)
115 None => edit.replace(expr_range, buf),
122 // We want to maintain the indent level,
123 // but we do not want to duplicate possible
124 // extra newlines in the indent block
125 let text = indent.text();
126 if text.starts_with('\n') {
128 buf.push_str(text.trim_start_matches('\n'));
133 edit.replace(expr_range, var_name.clone());
134 let offset = anchor.syntax().text_range().start();
135 match ctx.config.snippet_cap {
137 let snip = buf.replace(
138 &format!("let {var_modifier}{var_name}"),
139 &format!("let {var_modifier}$0{var_name}"),
141 edit.insert_snippet(cap, offset, snip)
143 None => edit.insert(offset, buf),
146 if let Anchor::WrapInBlock(_) = anchor {
147 edit.insert(anchor.syntax().text_range().end(), " }");
153 /// Check whether the node is a valid expression which can be extracted to a variable.
154 /// In general that's true for any expression, but in some cases that would produce invalid code.
155 fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
157 PATH_EXPR | LOOP_EXPR => None,
158 BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
159 RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
161 ast::BlockExpr::cast(node).filter(|it| it.is_standalone()).map(ast::Expr::from)
163 _ => ast::Expr::cast(node),
167 fn get_receiver_type(ctx: &AssistContext<'_>, expression: &ast::Expr) -> Option<hir::Type> {
168 let receiver = get_receiver(expression.clone())?;
169 Some(ctx.sema.type_of_expr(&receiver)?.original())
172 /// In the expression `a.b.c.x()`, find `a`
173 fn get_receiver(expression: ast::Expr) -> Option<ast::Expr> {
175 ast::Expr::FieldExpr(field) if field.expr().is_some() => {
176 let nested_expression = &field.expr()?;
177 get_receiver(nested_expression.to_owned())
179 _ => Some(expression),
186 Replace(ast::ExprStmt),
187 WrapInBlock(SyntaxNode),
191 fn from(to_extract: &ast::Expr) -> Option<Anchor> {
195 .take_while(|it| !ast::Item::can_cast(it.kind()) || ast::MacroCall::can_cast(it.kind()))
197 if ast::MacroCall::can_cast(node.kind()) {
201 node.parent().and_then(ast::StmtList::cast).and_then(|it| it.tail_expr())
203 if expr.syntax() == &node {
204 cov_mark::hit!(test_extract_var_last_expr);
205 return Some(Anchor::Before(node));
209 if let Some(parent) = node.parent() {
210 if parent.kind() == CLOSURE_EXPR {
211 cov_mark::hit!(test_extract_var_in_closure_no_block);
212 return Some(Anchor::WrapInBlock(node));
214 if parent.kind() == MATCH_ARM {
215 if node.kind() == MATCH_GUARD {
216 cov_mark::hit!(test_extract_var_in_match_guard);
218 cov_mark::hit!(test_extract_var_in_match_arm_no_block);
219 return Some(Anchor::WrapInBlock(node));
224 if let Some(stmt) = ast::Stmt::cast(node.clone()) {
225 if let ast::Stmt::ExprStmt(stmt) = stmt {
226 if stmt.expr().as_ref() == Some(to_extract) {
227 return Some(Anchor::Replace(stmt));
230 return Some(Anchor::Before(node));
236 fn syntax(&self) -> &SyntaxNode {
238 Anchor::Before(it) | Anchor::WrapInBlock(it) => it,
239 Anchor::Replace(stmt) => stmt.syntax(),
246 use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
251 fn test_extract_var_simple() {
260 let $0var_name = 1 + 1;
267 fn extract_var_in_comment_is_not_applicable() {
268 cov_mark::check!(extract_var_in_comment_is_not_applicable);
269 check_assist_not_applicable(extract_variable, "fn main() { 1 + /* $0comment$0 */ 1; }");
273 fn test_extract_var_expr_stmt() {
274 cov_mark::check!(test_extract_var_expr_stmt);
283 let $0var_name = 1 + 1;
295 let $0var_name = { let x = 0; x };
302 fn test_extract_var_part_of_expr_stmt() {
318 fn test_extract_var_last_expr() {
319 cov_mark::check!(test_extract_var_last_expr);
329 let $0var_name = 1 + 1;
341 fn bar(i: i32) -> i32 {
347 let $0bar = bar(1 + 1);
351 fn bar(i: i32) -> i32 {
359 fn test_extract_var_in_match_arm_no_block() {
360 cov_mark::check!(test_extract_var_in_match_arm_no_block);
366 let tuple = match x {
367 true => ($02 + 2$0, true)
375 let tuple = match x {
376 true => { let $0var_name = 2 + 2; (var_name, true) }
385 fn test_extract_var_in_match_arm_with_block() {
391 let tuple = match x {
403 let tuple = match x {
406 let $0var_name = 2 + y;
417 fn test_extract_var_in_match_guard() {
418 cov_mark::check!(test_extract_var_in_match_guard);
424 () if $010 > 0$0 => 1
431 let $0var_name = 10 > 0;
442 fn test_extract_var_in_closure_no_block() {
443 cov_mark::check!(test_extract_var_in_closure_no_block);
448 let lambda = |x: u32| $0x * 2$0;
453 let lambda = |x: u32| { let $0var_name = x * 2; var_name };
460 fn test_extract_var_in_closure_with_block() {
465 let lambda = |x: u32| { $0x * 2$0 };
470 let lambda = |x: u32| { let $0var_name = x * 2; var_name };
477 fn test_extract_var_path_simple() {
482 let o = $0Some(true)$0;
487 let $0var_name = Some(true);
495 fn test_extract_var_path_method() {
500 let v = $0bar.foo()$0;
505 let $0foo = bar.foo();
513 fn test_extract_var_return() {
523 let $0var_name = 2 + 2;
531 fn test_extract_var_does_not_add_extra_whitespace() {
545 let $0var_name = 2 + 2;
562 let $0var_name = 2 + 2;
587 let $0var_name = 2 + 2;
595 fn test_extract_var_break() {
608 let $0var_name = 2 + 2;
617 fn test_extract_var_for_cast() {
622 let v = $00f32 as u32$0;
627 let $0var_name = 0f32 as u32;
635 fn extract_var_field_shorthand() {
661 fn extract_var_name_from_type() {
675 let $0test = { Test(10) };
683 fn extract_var_name_from_parameter() {
687 fn bar(test: u32, size: u32)
694 fn bar(test: u32, size: u32)
705 fn extract_var_parameter_name_has_precedence_over_type() {
709 struct TextSize(u32);
710 fn bar(test: u32, size: TextSize)
713 bar(1, $0{ TextSize(1+1) }$0);
717 struct TextSize(u32);
718 fn bar(test: u32, size: TextSize)
721 let $0size = { TextSize(1+1) };
729 fn extract_var_name_from_function() {
733 fn is_required(test: u32, size: u32) -> bool
736 $0is_required(1, 2)$0
740 fn is_required(test: u32, size: u32) -> bool
743 let $0is_required = is_required(1, 2);
751 fn extract_var_name_from_method() {
757 fn bar(&self, n: u32) -> u32 { n }
767 fn bar(&self, n: u32) -> u32 { n }
771 let $0bar = S.bar(1);
779 fn extract_var_name_from_method_param() {
785 fn bar(&self, n: u32, size: u32) { n }
795 fn bar(&self, n: u32, size: u32) { n }
807 fn extract_var_name_from_ufcs_method_param() {
813 fn bar(&self, n: u32, size: u32) { n }
817 S::bar(&S, $01 + 1$0, 2)
823 fn bar(&self, n: u32, size: u32) { n }
835 fn extract_var_parameter_name_has_precedence_over_function() {
839 fn bar(test: u32, size: u32)
842 bar(1, $0symbol_size(1, 2)$0);
846 fn bar(test: u32, size: u32)
849 let $0size = symbol_size(1, 2);
857 fn extract_macro_call() {
883 fn test_extract_var_for_return_not_applicable() {
884 check_assist_not_applicable(extract_variable, "fn foo() { $0return$0; } ");
888 fn test_extract_var_for_break_not_applicable() {
889 check_assist_not_applicable(extract_variable, "fn main() { loop { $0break$0; }; }");
893 fn test_extract_var_unit_expr_not_applicable() {
894 check_assist_not_applicable(
908 // FIXME: This is not quite correct, but good enough(tm) for the sorting heuristic
910 fn extract_var_target() {
911 check_assist_target(extract_variable, "fn foo() -> u32 { $0return 2 + 2$0; }", "2 + 2");
918 let tuple = match x {
919 true => ($02 + 2$0, true)
929 fn extract_var_no_block_body() {
930 check_assist_not_applicable(
933 const X: usize = $0100$0;
939 fn test_extract_var_mutable_reference_parameter() {
956 let $0vec = &mut s.vec;
963 fn test_extract_var_mutable_reference_parameter_deep_nesting() {
978 $0f.field.field.vec$0.push(0);
992 let $0vec = &mut f.field.field.vec;
999 fn test_extract_var_reference_parameter() {
1006 fn do_thing(&self) {
1016 $0s.sub$0.do_thing();
1022 fn do_thing(&self) {
1039 fn test_extract_var_reference_parameter_deep_nesting() {
1045 fn do_thing(&self) {
1063 $0s.sub.field.field$0.do_thing();
1068 fn do_thing(&self) {
1086 let $0z = &s.sub.field.field;
1093 fn test_extract_var_regular_parameter() {
1100 fn do_thing(&self) {
1110 $0s.sub$0.do_thing();
1116 fn do_thing(&self) {
1133 fn test_extract_var_mutable_reference_local() {
1155 fn do_thing(&self) {
1162 let local = &mut S::new();
1163 $0local.sub$0.do_thing();
1184 fn do_thing(&self) {
1191 let local = &mut S::new();
1192 let $0x = &mut local.sub;
1199 fn test_extract_var_reference_local() {
1221 fn do_thing(&self) {
1228 let local = &S::new();
1229 $0local.sub$0.do_thing();
1250 fn do_thing(&self) {
1257 let local = &S::new();
1258 let $0x = &local.sub;
1265 fn test_extract_var_for_mutable_borrow() {
1274 let mut $0var_name = 0;
1275 let v = &mut var_name;