crates/ide_assists/src/handlers/generate_function.rs

   1 use rustc_hash::{FxHashMap, FxHashSet};
   2
   3 use hir::{HasSource, HirDisplay, Module, Semantics, TypeInfo};
   4 use ide_db::helpers::FamousDefs;
   5 use ide_db::{
   6     base_db::FileId,
   7     defs::{Definition, NameRefClass},
   8     helpers::SnippetCap,
   9     RootDatabase,
  10 };
  11 use stdx::to_lower_snake_case;
  12 use syntax::{
  13     ast::{
  14         self,
  15         edit::{AstNodeEdit, IndentLevel},
  16         make, AstNode, CallExpr, HasArgList, HasModuleItem,
  17     },
  18     SyntaxKind, SyntaxNode, TextRange, TextSize,
  19 };
  20
  21 use crate::{
  22     utils::convert_reference_type,
  23     utils::{find_struct_impl, render_snippet, Cursor},
  24     AssistContext, AssistId, AssistKind, Assists,
  25 };
  26
  27 // Assist: generate_function
  28 //
  29 // Adds a stub function with a signature matching the function under the cursor.
  30 //
  31 // ```
  32 // struct Baz;
  33 // fn baz() -> Baz { Baz }
  34 // fn foo() {
  35 //     bar$0("", baz());
  36 // }
  37 //
  38 // ```
  39 // ->
  40 // ```
  41 // struct Baz;
  42 // fn baz() -> Baz { Baz }
  43 // fn foo() {
  44 //     bar("", baz());
  45 // }
  46 //
  47 // fn bar(arg: &str, baz: Baz) ${0:-> _} {
  48 //     todo!()
  49 // }
  50 //
  51 // ```
  52 pub(crate) fn generate_function(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
  53     gen_fn(acc, ctx).or_else(|| gen_method(acc, ctx))
  54 }
  55
  56 fn gen_fn(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
  57     let path_expr: ast::PathExpr = ctx.find_node_at_offset()?;
  58     let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
  59     let path = path_expr.path()?;
  60     let name_ref = path.segment()?.name_ref()?;
  61     if ctx.sema.resolve_path(&path).is_some() {
  62         // The function call already resolves, no need to add a function
  63         return None;
  64     }
  65
  66     let fn_name = &*name_ref.text();
  67     let target_module;
  68     let mut adt_name = None;
  69
  70     let (target, file, insert_offset) = match path.qualifier() {
  71         Some(qualifier) => match ctx.sema.resolve_path(&qualifier) {
  72             Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) => {
  73                 target_module = Some(module);
  74                 get_fn_target(ctx, &target_module, call.clone())?
  75             }
  76             Some(hir::PathResolution::Def(hir::ModuleDef::Adt(adt))) => {
  77                 let current_module = current_module(call.syntax(), ctx)?;
  78                 let module = adt.module(ctx.sema.db);
  79                 target_module = if current_module == module { None } else { Some(module) };
  80                 if current_module.krate() != module.krate() {
  81                     return None;
  82                 }
  83                 let (impl_, file) = get_adt_source(ctx, &adt, fn_name)?;
  84                 let (target, insert_offset) = get_method_target(ctx, &module, &impl_)?;
  85                 adt_name = if impl_.is_none() { Some(adt.name(ctx.sema.db)) } else { None };
  86                 (target, file, insert_offset)
  87             }
  88             _ => {
  89                 return None;
  90             }
  91         },
  92         _ => {
  93             target_module = None;
  94             get_fn_target(ctx, &target_module, call.clone())?
  95         }
  96     };
  97     let function_builder = FunctionBuilder::from_call(ctx, &call, fn_name, target_module, target)?;
  98     let text_range = call.syntax().text_range();
  99     let label = format!("Generate {} function", function_builder.fn_name);
 100     add_func_to_accumulator(
 101         acc,
 102         ctx,
 103         text_range,
 104         function_builder,
 105         insert_offset,
 106         file,
 107         adt_name,
 108         label,
 109     )
 110 }
 111
 112 fn gen_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 113     let call: ast::MethodCallExpr = ctx.find_node_at_offset()?;
 114     let fn_name = call.name_ref()?;
 115     let adt = ctx.sema.type_of_expr(&call.receiver()?)?.original().strip_references().as_adt()?;
 116
 117     let current_module = current_module(call.syntax(), ctx)?;
 118     let target_module = adt.module(ctx.sema.db);
 119
 120     if current_module.krate() != target_module.krate() {
 121         return None;
 122     }
 123     let (impl_, file) = get_adt_source(ctx, &adt, fn_name.text().as_str())?;
 124     let (target, insert_offset) = get_method_target(ctx, &target_module, &impl_)?;
 125     let function_builder =
 126         FunctionBuilder::from_method_call(ctx, &call, &fn_name, target_module, target)?;
 127     let text_range = call.syntax().text_range();
 128     let adt_name = if impl_.is_none() { Some(adt.name(ctx.sema.db)) } else { None };
 129     let label = format!("Generate {} method", function_builder.fn_name);
 130     add_func_to_accumulator(
 131         acc,
 132         ctx,
 133         text_range,
 134         function_builder,
 135         insert_offset,
 136         file,
 137         adt_name,
 138         label,
 139     )
 140 }
 141
 142 fn add_func_to_accumulator(
 143     acc: &mut Assists,
 144     ctx: &AssistContext,
 145     text_range: TextRange,
 146     function_builder: FunctionBuilder,
 147     insert_offset: TextSize,
 148     file: FileId,
 149     adt_name: Option<hir::Name>,
 150     label: String,
 151 ) -> Option<()> {
 152     acc.add(AssistId("generate_function", AssistKind::Generate), label, text_range, |builder| {
 153         let function_template = function_builder.render();
 154         let mut func = function_template.to_string(ctx.config.snippet_cap);
 155         if let Some(name) = adt_name {
 156             func = format!("\nimpl {} {{\n{}\n}}", name, func);
 157         }
 158         builder.edit_file(file);
 159         match ctx.config.snippet_cap {
 160             Some(cap) => builder.insert_snippet(cap, insert_offset, func),
 161             None => builder.insert(insert_offset, func),
 162         }
 163     })
 164 }
 165
 166 fn current_module(current_node: &SyntaxNode, ctx: &AssistContext) -> Option<Module> {
 167     ctx.sema.scope(current_node).module()
 168 }
 169
 170 fn get_adt_source(
 171     ctx: &AssistContext,
 172     adt: &hir::Adt,
 173     fn_name: &str,
 174 ) -> Option<(Option<ast::Impl>, FileId)> {
 175     let range = adt.source(ctx.sema.db)?.syntax().original_file_range(ctx.sema.db);
 176     let file = ctx.sema.parse(range.file_id);
 177     let adt_source =
 178         ctx.sema.find_node_at_offset_with_macros(file.syntax(), range.range.start())?;
 179     find_struct_impl(ctx, &adt_source, fn_name).map(|impl_| (impl_, range.file_id))
 180 }
 181
 182 struct FunctionTemplate {
 183     leading_ws: String,
 184     fn_def: ast::Fn,
 185     ret_type: Option<ast::RetType>,
 186     should_focus_return_type: bool,
 187     trailing_ws: String,
 188     tail_expr: ast::Expr,
 189 }
 190
 191 impl FunctionTemplate {
 192     fn to_string(&self, cap: Option<SnippetCap>) -> String {
 193         let f = match cap {
 194             Some(cap) => {
 195                 let cursor = if self.should_focus_return_type {
 196                     // Focus the return type if there is one
 197                     match self.ret_type {
 198                         Some(ref ret_type) => ret_type.syntax(),
 199                         None => self.tail_expr.syntax(),
 200                     }
 201                 } else {
 202                     self.tail_expr.syntax()
 203                 };
 204                 render_snippet(cap, self.fn_def.syntax(), Cursor::Replace(cursor))
 205             }
 206             None => self.fn_def.to_string(),
 207         };
 208
 209         format!("{}{}{}", self.leading_ws, f, self.trailing_ws)
 210     }
 211 }
 212
 213 struct FunctionBuilder {
 214     target: GeneratedFunctionTarget,
 215     fn_name: ast::Name,
 216     type_params: Option<ast::GenericParamList>,
 217     params: ast::ParamList,
 218     ret_type: Option<ast::RetType>,
 219     should_focus_return_type: bool,
 220     needs_pub: bool,
 221     is_async: bool,
 222 }
 223
 224 impl FunctionBuilder {
 225     /// Prepares a generated function that matches `call`.
 226     /// The function is generated in `target_module` or next to `call`
 227     fn from_call(
 228         ctx: &AssistContext,
 229         call: &ast::CallExpr,
 230         fn_name: &str,
 231         target_module: Option<hir::Module>,
 232         target: GeneratedFunctionTarget,
 233     ) -> Option<Self> {
 234         let needs_pub = target_module.is_some();
 235         let target_module = target_module.or_else(|| current_module(target.syntax(), ctx))?;
 236         let fn_name = make::name(fn_name);
 237         let (type_params, params) =
 238             fn_args(ctx, target_module, ast::CallableExpr::Call(call.clone()))?;
 239
 240         let await_expr = call.syntax().parent().and_then(ast::AwaitExpr::cast);
 241         let is_async = await_expr.is_some();
 242
 243         let (ret_type, should_focus_return_type) =
 244             make_return_type(ctx, &ast::Expr::CallExpr(call.clone()), target_module);
 245
 246         Some(Self {
 247             target,
 248             fn_name,
 249             type_params,
 250             params,
 251             ret_type,
 252             should_focus_return_type,
 253             needs_pub,
 254             is_async,
 255         })
 256     }
 257
 258     fn from_method_call(
 259         ctx: &AssistContext,
 260         call: &ast::MethodCallExpr,
 261         name: &ast::NameRef,
 262         target_module: Module,
 263         target: GeneratedFunctionTarget,
 264     ) -> Option<Self> {
 265         let needs_pub =
 266             !module_is_descendant(&current_module(call.syntax(), ctx)?, &target_module, ctx);
 267         let fn_name = make::name(&name.text());
 268         let (type_params, params) =
 269             fn_args(ctx, target_module, ast::CallableExpr::MethodCall(call.clone()))?;
 270
 271         let await_expr = call.syntax().parent().and_then(ast::AwaitExpr::cast);
 272         let is_async = await_expr.is_some();
 273
 274         let (ret_type, should_focus_return_type) =
 275             make_return_type(ctx, &ast::Expr::MethodCallExpr(call.clone()), target_module);
 276
 277         Some(Self {
 278             target,
 279             fn_name,
 280             type_params,
 281             params,
 282             ret_type,
 283             should_focus_return_type,
 284             needs_pub,
 285             is_async,
 286         })
 287     }
 288
 289     fn render(self) -> FunctionTemplate {
 290         let placeholder_expr = make::ext::expr_todo();
 291         let fn_body = make::block_expr(vec![], Some(placeholder_expr));
 292         let visibility = if self.needs_pub { Some(make::visibility_pub_crate()) } else { None };
 293         let mut fn_def = make::fn_(
 294             visibility,
 295             self.fn_name,
 296             self.type_params,
 297             self.params,
 298             fn_body,
 299             self.ret_type,
 300             self.is_async,
 301         );
 302         let leading_ws;
 303         let trailing_ws;
 304
 305         match self.target {
 306             GeneratedFunctionTarget::BehindItem(it) => {
 307                 let indent = IndentLevel::from_node(&it);
 308                 leading_ws = format!("\n\n{}", indent);
 309                 fn_def = fn_def.indent(indent);
 310                 trailing_ws = String::new();
 311             }
 312             GeneratedFunctionTarget::InEmptyItemList(it) => {
 313                 let indent = IndentLevel::from_node(&it);
 314                 leading_ws = format!("\n{}", indent + 1);
 315                 fn_def = fn_def.indent(indent + 1);
 316                 trailing_ws = format!("\n{}", indent);
 317             }
 318         };
 319
 320         FunctionTemplate {
 321             leading_ws,
 322             ret_type: fn_def.ret_type(),
 323             // PANIC: we guarantee we always create a function body with a tail expr
 324             tail_expr: fn_def.body().unwrap().tail_expr().unwrap(),
 325             should_focus_return_type: self.should_focus_return_type,
 326             fn_def,
 327             trailing_ws,
 328         }
 329     }
 330 }
 331
 332 /// Makes an optional return type along with whether the return type should be focused by the cursor.
 333 /// If we cannot infer what the return type should be, we create a placeholder type.
 334 ///
 335 /// The rule for whether we focus a return type or not (and thus focus the function body),
 336 /// is rather simple:
 337 /// * If we could *not* infer what the return type should be, focus it (so the user can fill-in
 338 /// the correct return type).
 339 /// * If we could infer the return type, don't focus it (and thus focus the function body) so the
 340 /// user can change the `todo!` function body.
 341 fn make_return_type(
 342     ctx: &AssistContext,
 343     call: &ast::Expr,
 344     target_module: Module,
 345 ) -> (Option<ast::RetType>, bool) {
 346     let (ret_ty, should_focus_return_type) = {
 347         match ctx.sema.type_of_expr(call).map(TypeInfo::original) {
 348             Some(ty) if ty.is_unknown() => (Some(make::ty_placeholder()), true),
 349             None => (Some(make::ty_placeholder()), true),
 350             Some(ty) if ty.is_unit() => (None, false),
 351             Some(ty) => {
 352                 let rendered = ty.display_source_code(ctx.db(), target_module.into());
 353                 match rendered {
 354                     Ok(rendered) => (Some(make::ty(&rendered)), false),
 355                     Err(_) => (Some(make::ty_placeholder()), true),
 356                 }
 357             }
 358         }
 359     };
 360     let ret_type = ret_ty.map(make::ret_type);
 361     (ret_type, should_focus_return_type)
 362 }
 363
 364 fn get_fn_target(
 365     ctx: &AssistContext,
 366     target_module: &Option<Module>,
 367     call: CallExpr,
 368 ) -> Option<(GeneratedFunctionTarget, FileId, TextSize)> {
 369     let mut file = ctx.file_id();
 370     let target = match target_module {
 371         Some(target_module) => {
 372             let module_source = target_module.definition_source(ctx.db());
 373             let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, &module_source)?;
 374             file = in_file;
 375             target
 376         }
 377         None => next_space_for_fn_after_call_site(ast::CallableExpr::Call(call))?,
 378     };
 379     Some((target.clone(), file, get_insert_offset(&target)))
 380 }
 381
 382 fn get_method_target(
 383     ctx: &AssistContext,
 384     target_module: &Module,
 385     impl_: &Option<ast::Impl>,
 386 ) -> Option<(GeneratedFunctionTarget, TextSize)> {
 387     let target = match impl_ {
 388         Some(impl_) => next_space_for_fn_in_impl(impl_)?,
 389         None => {
 390             next_space_for_fn_in_module(ctx.sema.db, &target_module.definition_source(ctx.sema.db))?
 391                 .1
 392         }
 393     };
 394     Some((target.clone(), get_insert_offset(&target)))
 395 }
 396
 397 fn get_insert_offset(target: &GeneratedFunctionTarget) -> TextSize {
 398     match &target {
 399         GeneratedFunctionTarget::BehindItem(it) => it.text_range().end(),
 400         GeneratedFunctionTarget::InEmptyItemList(it) => it.text_range().start() + TextSize::of('{'),
 401     }
 402 }
 403
 404 #[derive(Clone)]
 405 enum GeneratedFunctionTarget {
 406     BehindItem(SyntaxNode),
 407     InEmptyItemList(SyntaxNode),
 408 }
 409
 410 impl GeneratedFunctionTarget {
 411     fn syntax(&self) -> &SyntaxNode {
 412         match self {
 413             GeneratedFunctionTarget::BehindItem(it) => it,
 414             GeneratedFunctionTarget::InEmptyItemList(it) => it,
 415         }
 416     }
 417 }
 418
 419 /// Computes the type variables and arguments required for the generated function
 420 fn fn_args(
 421     ctx: &AssistContext,
 422     target_module: hir::Module,
 423     call: ast::CallableExpr,
 424 ) -> Option<(Option<ast::GenericParamList>, ast::ParamList)> {
 425     let mut arg_names = Vec::new();
 426     let mut arg_types = Vec::new();
 427     for arg in call.arg_list()?.args() {
 428         arg_names.push(fn_arg_name(&ctx.sema, &arg));
 429         arg_types.push(fn_arg_type(ctx, target_module, &arg));
 430     }
 431     deduplicate_arg_names(&mut arg_names);
 432     let params = arg_names.into_iter().zip(arg_types).map(|(name, ty)| {
 433         make::param(make::ext::simple_ident_pat(make::name(&name)).into(), make::ty(&ty))
 434     });
 435
 436     Some((
 437         None,
 438         make::param_list(
 439             match call {
 440                 ast::CallableExpr::Call(_) => None,
 441                 ast::CallableExpr::MethodCall(_) => Some(make::self_param()),
 442             },
 443             params,
 444         ),
 445     ))
 446 }
 447
 448 /// Makes duplicate argument names unique by appending incrementing numbers.
 449 ///
 450 /// ```
 451 /// let mut names: Vec<String> =
 452 ///     vec!["foo".into(), "foo".into(), "bar".into(), "baz".into(), "bar".into()];
 453 /// deduplicate_arg_names(&mut names);
 454 /// let expected: Vec<String> =
 455 ///     vec!["foo_1".into(), "foo_2".into(), "bar_1".into(), "baz".into(), "bar_2".into()];
 456 /// assert_eq!(names, expected);
 457 /// ```
 458 fn deduplicate_arg_names(arg_names: &mut Vec<String>) {
 459     let arg_name_counts = arg_names.iter().fold(FxHashMap::default(), |mut m, name| {
 460         *m.entry(name).or_insert(0) += 1;
 461         m
 462     });
 463     let duplicate_arg_names: FxHashSet<String> = arg_name_counts
 464         .into_iter()
 465         .filter(|(_, count)| *count >= 2)
 466         .map(|(name, _)| name.clone())
 467         .collect();
 468
 469     let mut counter_per_name = FxHashMap::default();
 470     for arg_name in arg_names.iter_mut() {
 471         if duplicate_arg_names.contains(arg_name) {
 472             let counter = counter_per_name.entry(arg_name.clone()).or_insert(1);
 473             arg_name.push('_');
 474             arg_name.push_str(&counter.to_string());
 475             *counter += 1;
 476         }
 477     }
 478 }
 479
 480 fn fn_arg_name(sema: &Semantics<RootDatabase>, arg_expr: &ast::Expr) -> String {
 481     let name = (|| match arg_expr {
 482         ast::Expr::CastExpr(cast_expr) => Some(fn_arg_name(sema, &cast_expr.expr()?)),
 483         expr => {
 484             let name_ref = expr.syntax().descendants().filter_map(ast::NameRef::cast).last()?;
 485             if let Some(NameRefClass::Definition(Definition::Const(_) | Definition::Static(_))) =
 486                 NameRefClass::classify(sema, &name_ref)
 487             {
 488                 return Some(name_ref.to_string().to_lowercase());
 489             };
 490             Some(to_lower_snake_case(&name_ref.to_string()))
 491         }
 492     })();
 493     match name {
 494         Some(mut name) if name.starts_with(|c: char| c.is_ascii_digit()) => {
 495             name.insert_str(0, "arg");
 496             name
 497         }
 498         Some(name) => name,
 499         None => "arg".to_string(),
 500     }
 501 }
 502
 503 fn fn_arg_type(ctx: &AssistContext, target_module: hir::Module, fn_arg: &ast::Expr) -> String {
 504     fn maybe_displayed_type(
 505         ctx: &AssistContext,
 506         target_module: hir::Module,
 507         fn_arg: &ast::Expr,
 508     ) -> Option<String> {
 509         let ty = ctx.sema.type_of_expr(fn_arg)?.adjusted();
 510         if ty.is_unknown() {
 511             return None;
 512         }
 513
 514         if ty.is_reference() || ty.is_mutable_reference() {
 515             let famous_defs = &FamousDefs(&ctx.sema, ctx.sema.scope(fn_arg.syntax()).krate());
 516             convert_reference_type(ty.strip_references(), ctx.db(), famous_defs)
 517                 .map(|conversion| conversion.convert_type(ctx.db()))
 518                 .or_else(|| ty.display_source_code(ctx.db(), target_module.into()).ok())
 519         } else {
 520             ty.display_source_code(ctx.db(), target_module.into()).ok()
 521         }
 522     }
 523
 524     maybe_displayed_type(ctx, target_module, fn_arg).unwrap_or_else(|| String::from("_"))
 525 }
 526
 527 /// Returns the position inside the current mod or file
 528 /// directly after the current block
 529 /// We want to write the generated function directly after
 530 /// fns, impls or macro calls, but inside mods
 531 fn next_space_for_fn_after_call_site(expr: ast::CallableExpr) -> Option<GeneratedFunctionTarget> {
 532     let mut ancestors = expr.syntax().ancestors().peekable();
 533     let mut last_ancestor: Option<SyntaxNode> = None;
 534     while let Some(next_ancestor) = ancestors.next() {
 535         match next_ancestor.kind() {
 536             SyntaxKind::SOURCE_FILE => {
 537                 break;
 538             }
 539             SyntaxKind::ITEM_LIST => {
 540                 if ancestors.peek().map(|a| a.kind()) == Some(SyntaxKind::MODULE) {
 541                     break;
 542                 }
 543             }
 544             _ => {}
 545         }
 546         last_ancestor = Some(next_ancestor);
 547     }
 548     last_ancestor.map(GeneratedFunctionTarget::BehindItem)
 549 }
 550
 551 fn next_space_for_fn_in_module(
 552     db: &dyn hir::db::AstDatabase,
 553     module_source: &hir::InFile<hir::ModuleSource>,
 554 ) -> Option<(FileId, GeneratedFunctionTarget)> {
 555     let file = module_source.file_id.original_file(db);
 556     let assist_item = match &module_source.value {
 557         hir::ModuleSource::SourceFile(it) => match it.items().last() {
 558             Some(last_item) => GeneratedFunctionTarget::BehindItem(last_item.syntax().clone()),
 559             None => GeneratedFunctionTarget::BehindItem(it.syntax().clone()),
 560         },
 561         hir::ModuleSource::Module(it) => match it.item_list().and_then(|it| it.items().last()) {
 562             Some(last_item) => GeneratedFunctionTarget::BehindItem(last_item.syntax().clone()),
 563             None => GeneratedFunctionTarget::InEmptyItemList(it.item_list()?.syntax().clone()),
 564         },
 565         hir::ModuleSource::BlockExpr(it) => {
 566             if let Some(last_item) =
 567                 it.statements().take_while(|stmt| matches!(stmt, ast::Stmt::Item(_))).last()
 568             {
 569                 GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
 570             } else {
 571                 GeneratedFunctionTarget::InEmptyItemList(it.syntax().clone())
 572             }
 573         }
 574     };
 575     Some((file, assist_item))
 576 }
 577
 578 fn next_space_for_fn_in_impl(impl_: &ast::Impl) -> Option<GeneratedFunctionTarget> {
 579     if let Some(last_item) = impl_.assoc_item_list().and_then(|it| it.assoc_items().last()) {
 580         Some(GeneratedFunctionTarget::BehindItem(last_item.syntax().clone()))
 581     } else {
 582         Some(GeneratedFunctionTarget::InEmptyItemList(impl_.assoc_item_list()?.syntax().clone()))
 583     }
 584 }
 585
 586 fn module_is_descendant(module: &hir::Module, ans: &hir::Module, ctx: &AssistContext) -> bool {
 587     if module == ans {
 588         return true;
 589     }
 590     for c in ans.children(ctx.sema.db) {
 591         if module_is_descendant(module, &c, ctx) {
 592             return true;
 593         }
 594     }
 595     false
 596 }
 597
 598 #[cfg(test)]
 599 mod tests {
 600     use crate::tests::{check_assist, check_assist_not_applicable};
 601
 602     use super::*;
 603
 604     #[test]
 605     fn add_function_with_no_args() {
 606         check_assist(
 607             generate_function,
 608             r"
 609 fn foo() {
 610     bar$0();
 611 }
 612 ",
 613             r"
 614 fn foo() {
 615     bar();
 616 }
 617
 618 fn bar() ${0:-> _} {
 619     todo!()
 620 }
 621 ",
 622         )
 623     }
 624
 625     #[test]
 626     fn add_function_from_method() {
 627         // This ensures that the function is correctly generated
 628         // in the next outer mod or file
 629         check_assist(
 630             generate_function,
 631             r"
 632 impl Foo {
 633     fn foo() {
 634         bar$0();
 635     }
 636 }
 637 ",
 638             r"
 639 impl Foo {
 640     fn foo() {
 641         bar();
 642     }
 643 }
 644
 645 fn bar() ${0:-> _} {
 646     todo!()
 647 }
 648 ",
 649         )
 650     }
 651
 652     #[test]
 653     fn add_function_directly_after_current_block() {
 654         // The new fn should not be created at the end of the file or module
 655         check_assist(
 656             generate_function,
 657             r"
 658 fn foo1() {
 659     bar$0();
 660 }
 661
 662 fn foo2() {}
 663 ",
 664             r"
 665 fn foo1() {
 666     bar();
 667 }
 668
 669 fn bar() ${0:-> _} {
 670     todo!()
 671 }
 672
 673 fn foo2() {}
 674 ",
 675         )
 676     }
 677
 678     #[test]
 679     fn add_function_with_no_args_in_same_module() {
 680         check_assist(
 681             generate_function,
 682             r"
 683 mod baz {
 684     fn foo() {
 685         bar$0();
 686     }
 687 }
 688 ",
 689             r"
 690 mod baz {
 691     fn foo() {
 692         bar();
 693     }
 694
 695     fn bar() ${0:-> _} {
 696         todo!()
 697     }
 698 }
 699 ",
 700         )
 701     }
 702
 703     #[test]
 704     fn add_function_with_upper_camel_case_arg() {
 705         check_assist(
 706             generate_function,
 707             r"
 708 struct BazBaz;
 709 fn foo() {
 710     bar$0(BazBaz);
 711 }
 712 ",
 713             r"
 714 struct BazBaz;
 715 fn foo() {
 716     bar(BazBaz);
 717 }
 718
 719 fn bar(baz_baz: BazBaz) ${0:-> _} {
 720     todo!()
 721 }
 722 ",
 723         );
 724     }
 725
 726     #[test]
 727     fn add_function_with_upper_camel_case_arg_as_cast() {
 728         check_assist(
 729             generate_function,
 730             r"
 731 struct BazBaz;
 732 fn foo() {
 733     bar$0(&BazBaz as *const BazBaz);
 734 }
 735 ",
 736             r"
 737 struct BazBaz;
 738 fn foo() {
 739     bar(&BazBaz as *const BazBaz);
 740 }
 741
 742 fn bar(baz_baz: *const BazBaz) ${0:-> _} {
 743     todo!()
 744 }
 745 ",
 746         );
 747     }
 748
 749     #[test]
 750     fn add_function_with_function_call_arg() {
 751         check_assist(
 752             generate_function,
 753             r"
 754 struct Baz;
 755 fn baz() -> Baz { todo!() }
 756 fn foo() {
 757     bar$0(baz());
 758 }
 759 ",
 760             r"
 761 struct Baz;
 762 fn baz() -> Baz { todo!() }
 763 fn foo() {
 764     bar(baz());
 765 }
 766
 767 fn bar(baz: Baz) ${0:-> _} {
 768     todo!()
 769 }
 770 ",
 771         );
 772     }
 773
 774     #[test]
 775     fn add_function_with_method_call_arg() {
 776         check_assist(
 777             generate_function,
 778             r"
 779 struct Baz;
 780 impl Baz {
 781     fn foo(&self) -> Baz {
 782         ba$0r(self.baz())
 783     }
 784     fn baz(&self) -> Baz {
 785         Baz
 786     }
 787 }
 788 ",
 789             r"
 790 struct Baz;
 791 impl Baz {
 792     fn foo(&self) -> Baz {
 793         bar(self.baz())
 794     }
 795     fn baz(&self) -> Baz {
 796         Baz
 797     }
 798 }
 799
 800 fn bar(baz: Baz) -> Baz {
 801     ${0:todo!()}
 802 }
 803 ",
 804         )
 805     }
 806
 807     #[test]
 808     fn add_function_with_string_literal_arg() {
 809         check_assist(
 810             generate_function,
 811             r#"
 812 fn foo() {
 813     $0bar("bar")
 814 }
 815 "#,
 816             r#"
 817 fn foo() {
 818     bar("bar")
 819 }
 820
 821 fn bar(arg: &str) {
 822     ${0:todo!()}
 823 }
 824 "#,
 825         )
 826     }
 827
 828     #[test]
 829     fn add_function_with_char_literal_arg() {
 830         check_assist(
 831             generate_function,
 832             r#"
 833 fn foo() {
 834     $0bar('x')
 835 }
 836 "#,
 837             r#"
 838 fn foo() {
 839     bar('x')
 840 }
 841
 842 fn bar(arg: char) {
 843     ${0:todo!()}
 844 }
 845 "#,
 846         )
 847     }
 848
 849     #[test]
 850     fn add_function_with_int_literal_arg() {
 851         check_assist(
 852             generate_function,
 853             r"
 854 fn foo() {
 855     $0bar(42)
 856 }
 857 ",
 858             r"
 859 fn foo() {
 860     bar(42)
 861 }
 862
 863 fn bar(arg: i32) {
 864     ${0:todo!()}
 865 }
 866 ",
 867         )
 868     }
 869
 870     #[test]
 871     fn add_function_with_cast_int_literal_arg() {
 872         check_assist(
 873             generate_function,
 874             r"
 875 fn foo() {
 876     $0bar(42 as u8)
 877 }
 878 ",
 879             r"
 880 fn foo() {
 881     bar(42 as u8)
 882 }
 883
 884 fn bar(arg: u8) {
 885     ${0:todo!()}
 886 }
 887 ",
 888         )
 889     }
 890
 891     #[test]
 892     fn name_of_cast_variable_is_used() {
 893         // Ensures that the name of the cast type isn't used
 894         // in the generated function signature.
 895         check_assist(
 896             generate_function,
 897             r"
 898 fn foo() {
 899     let x = 42;
 900     bar$0(x as u8)
 901 }
 902 ",
 903             r"
 904 fn foo() {
 905     let x = 42;
 906     bar(x as u8)
 907 }
 908
 909 fn bar(x: u8) {
 910     ${0:todo!()}
 911 }
 912 ",
 913         )
 914     }
 915
 916     #[test]
 917     fn add_function_with_variable_arg() {
 918         check_assist(
 919             generate_function,
 920             r"
 921 fn foo() {
 922     let worble = ();
 923     $0bar(worble)
 924 }
 925 ",
 926             r"
 927 fn foo() {
 928     let worble = ();
 929     bar(worble)
 930 }
 931
 932 fn bar(worble: ()) {
 933     ${0:todo!()}
 934 }
 935 ",
 936         )
 937     }
 938
 939     #[test]
 940     fn add_function_with_impl_trait_arg() {
 941         check_assist(
 942             generate_function,
 943             r#"
 944 //- minicore: sized
 945 trait Foo {}
 946 fn foo() -> impl Foo {
 947     todo!()
 948 }
 949 fn baz() {
 950     $0bar(foo())
 951 }
 952 "#,
 953             r#"
 954 trait Foo {}
 955 fn foo() -> impl Foo {
 956     todo!()
 957 }
 958 fn baz() {
 959     bar(foo())
 960 }
 961
 962 fn bar(foo: impl Foo) {
 963     ${0:todo!()}
 964 }
 965 "#,
 966         )
 967     }
 968
 969     #[test]
 970     fn borrowed_arg() {
 971         check_assist(
 972             generate_function,
 973             r"
 974 struct Baz;
 975 fn baz() -> Baz { todo!() }
 976
 977 fn foo() {
 978     bar$0(&baz())
 979 }
 980 ",
 981             r"
 982 struct Baz;
 983 fn baz() -> Baz { todo!() }
 984
 985 fn foo() {
 986     bar(&baz())
 987 }
 988
 989 fn bar(baz: &Baz) {
 990     ${0:todo!()}
 991 }
 992 ",
 993         )
 994     }
 995
 996     #[test]
 997     fn add_function_with_qualified_path_arg() {
 998         check_assist(
 999             generate_function,
1000             r"
1001 mod Baz {
1002     pub struct Bof;
1003     pub fn baz() -> Bof { Bof }
1004 }
1005 fn foo() {
1006     $0bar(Baz::baz())
1007 }
1008 ",
1009             r"
1010 mod Baz {
1011     pub struct Bof;
1012     pub fn baz() -> Bof { Bof }
1013 }
1014 fn foo() {
1015     bar(Baz::baz())
1016 }
1017
1018 fn bar(baz: Baz::Bof) {
1019     ${0:todo!()}
1020 }
1021 ",
1022         )
1023     }
1024
1025     #[test]
1026     fn add_function_with_generic_arg() {
1027         // FIXME: This is wrong, generated `bar` should include generic parameter.
1028         check_assist(
1029             generate_function,
1030             r"
1031 fn foo<T>(t: T) {
1032     $0bar(t)
1033 }
1034 ",
1035             r"
1036 fn foo<T>(t: T) {
1037     bar(t)
1038 }
1039
1040 fn bar(t: T) {
1041     ${0:todo!()}
1042 }
1043 ",
1044         )
1045     }
1046
1047     #[test]
1048     fn add_function_with_fn_arg() {
1049         // FIXME: The argument in `bar` is wrong.
1050         check_assist(
1051             generate_function,
1052             r"
1053 struct Baz;
1054 impl Baz {
1055     fn new() -> Self { Baz }
1056 }
1057 fn foo() {
1058     $0bar(Baz::new);
1059 }
1060 ",
1061             r"
1062 struct Baz;
1063 impl Baz {
1064     fn new() -> Self { Baz }
1065 }
1066 fn foo() {
1067     bar(Baz::new);
1068 }
1069
1070 fn bar(new: fn) ${0:-> _} {
1071     todo!()
1072 }
1073 ",
1074         )
1075     }
1076
1077     #[test]
1078     fn add_function_with_closure_arg() {
1079         // FIXME: The argument in `bar` is wrong.
1080         check_assist(
1081             generate_function,
1082             r"
1083 fn foo() {
1084     let closure = |x: i64| x - 1;
1085     $0bar(closure)
1086 }
1087 ",
1088             r"
1089 fn foo() {
1090     let closure = |x: i64| x - 1;
1091     bar(closure)
1092 }
1093
1094 fn bar(closure: _) {
1095     ${0:todo!()}
1096 }
1097 ",
1098         )
1099     }
1100
1101     #[test]
1102     fn unresolveable_types_default_to_placeholder() {
1103         check_assist(
1104             generate_function,
1105             r"
1106 fn foo() {
1107     $0bar(baz)
1108 }
1109 ",
1110             r"
1111 fn foo() {
1112     bar(baz)
1113 }
1114
1115 fn bar(baz: _) {
1116     ${0:todo!()}
1117 }
1118 ",
1119         )
1120     }
1121
1122     #[test]
1123     fn arg_names_dont_overlap() {
1124         check_assist(
1125             generate_function,
1126             r"
1127 struct Baz;
1128 fn baz() -> Baz { Baz }
1129 fn foo() {
1130     $0bar(baz(), baz())
1131 }
1132 ",
1133             r"
1134 struct Baz;
1135 fn baz() -> Baz { Baz }
1136 fn foo() {
1137     bar(baz(), baz())
1138 }
1139
1140 fn bar(baz_1: Baz, baz_2: Baz) {
1141     ${0:todo!()}
1142 }
1143 ",
1144         )
1145     }
1146
1147     #[test]
1148     fn arg_name_counters_start_at_1_per_name() {
1149         check_assist(
1150             generate_function,
1151             r#"
1152 struct Baz;
1153 fn baz() -> Baz { Baz }
1154 fn foo() {
1155     $0bar(baz(), baz(), "foo", "bar")
1156 }
1157 "#,
1158             r#"
1159 struct Baz;
1160 fn baz() -> Baz { Baz }
1161 fn foo() {
1162     bar(baz(), baz(), "foo", "bar")
1163 }
1164
1165 fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) {
1166     ${0:todo!()}
1167 }
1168 "#,
1169         )
1170     }
1171
1172     #[test]
1173     fn add_function_in_module() {
1174         check_assist(
1175             generate_function,
1176             r"
1177 mod bar {}
1178
1179 fn foo() {
1180     bar::my_fn$0()
1181 }
1182 ",
1183             r"
1184 mod bar {
1185     pub(crate) fn my_fn() {
1186         ${0:todo!()}
1187     }
1188 }
1189
1190 fn foo() {
1191     bar::my_fn()
1192 }
1193 ",
1194         )
1195     }
1196
1197     #[test]
1198     fn qualified_path_uses_correct_scope() {
1199         check_assist(
1200             generate_function,
1201             r#"
1202 mod foo {
1203     pub struct Foo;
1204 }
1205 fn bar() {
1206     use foo::Foo;
1207     let foo = Foo;
1208     baz$0(foo)
1209 }
1210 "#,
1211             r#"
1212 mod foo {
1213     pub struct Foo;
1214 }
1215 fn bar() {
1216     use foo::Foo;
1217     let foo = Foo;
1218     baz(foo)
1219 }
1220
1221 fn baz(foo: foo::Foo) {
1222     ${0:todo!()}
1223 }
1224 "#,
1225         )
1226     }
1227
1228     #[test]
1229     fn add_function_in_module_containing_other_items() {
1230         check_assist(
1231             generate_function,
1232             r"
1233 mod bar {
1234     fn something_else() {}
1235 }
1236
1237 fn foo() {
1238     bar::my_fn$0()
1239 }
1240 ",
1241             r"
1242 mod bar {
1243     fn something_else() {}
1244
1245     pub(crate) fn my_fn() {
1246         ${0:todo!()}
1247     }
1248 }
1249
1250 fn foo() {
1251     bar::my_fn()
1252 }
1253 ",
1254         )
1255     }
1256
1257     #[test]
1258     fn add_function_in_nested_module() {
1259         check_assist(
1260             generate_function,
1261             r"
1262 mod bar {
1263     mod baz {}
1264 }
1265
1266 fn foo() {
1267     bar::baz::my_fn$0()
1268 }
1269 ",
1270             r"
1271 mod bar {
1272     mod baz {
1273         pub(crate) fn my_fn() {
1274             ${0:todo!()}
1275         }
1276     }
1277 }
1278
1279 fn foo() {
1280     bar::baz::my_fn()
1281 }
1282 ",
1283         )
1284     }
1285
1286     #[test]
1287     fn add_function_in_another_file() {
1288         check_assist(
1289             generate_function,
1290             r"
1291 //- /main.rs
1292 mod foo;
1293
1294 fn main() {
1295     foo::bar$0()
1296 }
1297 //- /foo.rs
1298 ",
1299             r"
1300
1301
1302 pub(crate) fn bar() {
1303     ${0:todo!()}
1304 }",
1305         )
1306     }
1307
1308     #[test]
1309     fn add_function_with_return_type() {
1310         check_assist(
1311             generate_function,
1312             r"
1313 fn main() {
1314     let x: u32 = foo$0();
1315 }
1316 ",
1317             r"
1318 fn main() {
1319     let x: u32 = foo();
1320 }
1321
1322 fn foo() -> u32 {
1323     ${0:todo!()}
1324 }
1325 ",
1326         )
1327     }
1328
1329     #[test]
1330     fn add_function_not_applicable_if_function_already_exists() {
1331         check_assist_not_applicable(
1332             generate_function,
1333             r"
1334 fn foo() {
1335     bar$0();
1336 }
1337
1338 fn bar() {}
1339 ",
1340         )
1341     }
1342
1343     #[test]
1344     fn add_function_not_applicable_if_unresolved_variable_in_call_is_selected() {
1345         check_assist_not_applicable(
1346             // bar is resolved, but baz isn't.
1347             // The assist is only active if the cursor is on an unresolved path,
1348             // but the assist should only be offered if the path is a function call.
1349             generate_function,
1350             r#"
1351 fn foo() {
1352     bar(b$0az);
1353 }
1354
1355 fn bar(baz: ()) {}
1356 "#,
1357         )
1358     }
1359
1360     #[test]
1361     fn create_method_with_no_args() {
1362         check_assist(
1363             generate_function,
1364             r#"
1365 struct Foo;
1366 impl Foo {
1367     fn foo(&self) {
1368         self.bar()$0;
1369     }
1370 }
1371 "#,
1372             r#"
1373 struct Foo;
1374 impl Foo {
1375     fn foo(&self) {
1376         self.bar();
1377     }
1378
1379     fn bar(&self) ${0:-> _} {
1380         todo!()
1381     }
1382 }
1383 "#,
1384         )
1385     }
1386
1387     #[test]
1388     fn create_function_with_async() {
1389         check_assist(
1390             generate_function,
1391             r"
1392 fn foo() {
1393     $0bar(42).await();
1394 }
1395 ",
1396             r"
1397 fn foo() {
1398     bar(42).await();
1399 }
1400
1401 async fn bar(arg: i32) ${0:-> _} {
1402     todo!()
1403 }
1404 ",
1405         )
1406     }
1407
1408     #[test]
1409     fn create_method() {
1410         check_assist(
1411             generate_function,
1412             r"
1413 struct S;
1414 fn foo() {S.bar$0();}
1415 ",
1416             r"
1417 struct S;
1418 fn foo() {S.bar();}
1419 impl S {
1420
1421
1422 fn bar(&self) ${0:-> _} {
1423     todo!()
1424 }
1425 }
1426 ",
1427         )
1428     }
1429
1430     #[test]
1431     fn create_method_within_an_impl() {
1432         check_assist(
1433             generate_function,
1434             r"
1435 struct S;
1436 fn foo() {S.bar$0();}
1437 impl S {}
1438
1439 ",
1440             r"
1441 struct S;
1442 fn foo() {S.bar();}
1443 impl S {
1444     fn bar(&self) ${0:-> _} {
1445         todo!()
1446     }
1447 }
1448
1449 ",
1450         )
1451     }
1452
1453     #[test]
1454     fn create_method_from_different_module() {
1455         check_assist(
1456             generate_function,
1457             r"
1458 mod s {
1459     pub struct S;
1460 }
1461 fn foo() {s::S.bar$0();}
1462 ",
1463             r"
1464 mod s {
1465     pub struct S;
1466 impl S {
1467
1468
1469     pub(crate) fn bar(&self) ${0:-> _} {
1470         todo!()
1471     }
1472 }
1473 }
1474 fn foo() {s::S.bar();}
1475 ",
1476         )
1477     }
1478
1479     #[test]
1480     fn create_method_from_descendant_module() {
1481         check_assist(
1482             generate_function,
1483             r"
1484 struct S;
1485 mod s {
1486     fn foo() {
1487         super::S.bar$0();
1488     }
1489 }
1490
1491 ",
1492             r"
1493 struct S;
1494 mod s {
1495     fn foo() {
1496         super::S.bar();
1497     }
1498 }
1499 impl S {
1500
1501
1502 fn bar(&self) ${0:-> _} {
1503     todo!()
1504 }
1505 }
1506
1507 ",
1508         )
1509     }
1510
1511     #[test]
1512     fn create_method_with_cursor_anywhere_on_call_expresion() {
1513         check_assist(
1514             generate_function,
1515             r"
1516 struct S;
1517 fn foo() {$0S.bar();}
1518 ",
1519             r"
1520 struct S;
1521 fn foo() {S.bar();}
1522 impl S {
1523
1524
1525 fn bar(&self) ${0:-> _} {
1526     todo!()
1527 }
1528 }
1529 ",
1530         )
1531     }
1532
1533     #[test]
1534     fn create_static_method() {
1535         check_assist(
1536             generate_function,
1537             r"
1538 struct S;
1539 fn foo() {S::bar$0();}
1540 ",
1541             r"
1542 struct S;
1543 fn foo() {S::bar();}
1544 impl S {
1545
1546
1547 fn bar() ${0:-> _} {
1548     todo!()
1549 }
1550 }
1551 ",
1552         )
1553     }
1554
1555     #[test]
1556     fn create_static_method_within_an_impl() {
1557         check_assist(
1558             generate_function,
1559             r"
1560 struct S;
1561 fn foo() {S::bar$0();}
1562 impl S {}
1563
1564 ",
1565             r"
1566 struct S;
1567 fn foo() {S::bar();}
1568 impl S {
1569     fn bar() ${0:-> _} {
1570         todo!()
1571     }
1572 }
1573
1574 ",
1575         )
1576     }
1577
1578     #[test]
1579     fn create_static_method_from_different_module() {
1580         check_assist(
1581             generate_function,
1582             r"
1583 mod s {
1584     pub struct S;
1585 }
1586 fn foo() {s::S::bar$0();}
1587 ",
1588             r"
1589 mod s {
1590     pub struct S;
1591 impl S {
1592
1593
1594     pub(crate) fn bar() ${0:-> _} {
1595         todo!()
1596     }
1597 }
1598 }
1599 fn foo() {s::S::bar();}
1600 ",
1601         )
1602     }
1603
1604     #[test]
1605     fn create_static_method_with_cursor_anywhere_on_call_expresion() {
1606         check_assist(
1607             generate_function,
1608             r"
1609 struct S;
1610 fn foo() {$0S::bar();}
1611 ",
1612             r"
1613 struct S;
1614 fn foo() {S::bar();}
1615 impl S {
1616
1617
1618 fn bar() ${0:-> _} {
1619     todo!()
1620 }
1621 }
1622 ",
1623         )
1624     }
1625
1626     #[test]
1627     fn no_panic_on_invalid_global_path() {
1628         check_assist(
1629             generate_function,
1630             r"
1631 fn main() {
1632     ::foo$0();
1633 }
1634 ",
1635             r"
1636 fn main() {
1637     ::foo();
1638 }
1639
1640 fn foo() ${0:-> _} {
1641     todo!()
1642 }
1643 ",
1644         )
1645     }
1646
1647     #[test]
1648     fn handle_tuple_indexing() {
1649         check_assist(
1650             generate_function,
1651             r"
1652 fn main() {
1653     let a = ((),);
1654     foo$0(a.0);
1655 }
1656 ",
1657             r"
1658 fn main() {
1659     let a = ((),);
1660     foo(a.0);
1661 }
1662
1663 fn foo(arg0: ()) ${0:-> _} {
1664     todo!()
1665 }
1666 ",
1667         )
1668     }
1669
1670     #[test]
1671     fn add_function_with_const_arg() {
1672         check_assist(
1673             generate_function,
1674             r"
1675 const VALUE: usize = 0;
1676 fn main() {
1677     foo$0(VALUE);
1678 }
1679 ",
1680             r"
1681 const VALUE: usize = 0;
1682 fn main() {
1683     foo(VALUE);
1684 }
1685
1686 fn foo(value: usize) ${0:-> _} {
1687     todo!()
1688 }
1689 ",
1690         )
1691     }
1692
1693     #[test]
1694     fn add_function_with_static_arg() {
1695         check_assist(
1696             generate_function,
1697             r"
1698 static VALUE: usize = 0;
1699 fn main() {
1700     foo$0(VALUE);
1701 }
1702 ",
1703             r"
1704 static VALUE: usize = 0;
1705 fn main() {
1706     foo(VALUE);
1707 }
1708
1709 fn foo(value: usize) ${0:-> _} {
1710     todo!()
1711 }
1712 ",
1713         )
1714     }
1715
1716     #[test]
1717     fn add_function_with_static_mut_arg() {
1718         check_assist(
1719             generate_function,
1720             r"
1721 static mut VALUE: usize = 0;
1722 fn main() {
1723     foo$0(VALUE);
1724 }
1725 ",
1726             r"
1727 static mut VALUE: usize = 0;
1728 fn main() {
1729     foo(VALUE);
1730 }
1731
1732 fn foo(value: usize) ${0:-> _} {
1733     todo!()
1734 }
1735 ",
1736         )
1737     }
1738 }