crates/ide_assists/src/handlers/extract_module.rs

   1 use std::collections::{HashMap, HashSet};
   2
   3 use hir::{HasSource, ModuleSource};
   4 use ide_db::{
   5     assists::{AssistId, AssistKind},
   6     base_db::FileId,
   7     defs::{Definition, NameClass, NameRefClass},
   8     search::{FileReference, SearchScope},
   9 };
  10 use stdx::format_to;
  11 use syntax::{
  12     algo::find_node_at_range,
  13     ast::{
  14         self,
  15         edit::{AstNodeEdit, IndentLevel},
  16         make, HasName, HasVisibility,
  17     },
  18     match_ast, ted, AstNode, SourceFile, SyntaxNode, TextRange,
  19 };
  20
  21 use crate::{AssistContext, Assists};
  22
  23 use super::remove_unused_param::range_to_remove;
  24
  25 // Assist: extract_module
  26 //
  27 // Extracts a selected region as seperate module. All the references, visibility and imports are
  28 // resolved.
  29 //
  30 // ```
  31 // $0fn foo(name: i32) -> i32 {
  32 //     name + 1
  33 // }$0
  34 //
  35 // fn bar(name: i32) -> i32 {
  36 //     name + 2
  37 // }
  38 // ```
  39 // ->
  40 // ```
  41 // mod modname {
  42 //     pub(crate) fn foo(name: i32) -> i32 {
  43 //         name + 1
  44 //     }
  45 // }
  46 //
  47 // fn bar(name: i32) -> i32 {
  48 //     name + 2
  49 // }
  50 // ```
  51 pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
  52     if ctx.has_empty_selection() {
  53         return None;
  54     }
  55
  56     let node = ctx.covering_element();
  57     let node = match node {
  58         syntax::NodeOrToken::Node(n) => n,
  59         syntax::NodeOrToken::Token(t) => t.parent()?,
  60     };
  61
  62     let mut curr_parent_module: Option<ast::Module> = None;
  63     if let Some(mod_syn_opt) = node.ancestors().find(|it| ast::Module::can_cast(it.kind())) {
  64         curr_parent_module = ast::Module::cast(mod_syn_opt);
  65     }
  66
  67     let mut module = extract_target(&node, ctx.selection_trimmed())?;
  68     if module.body_items.len() == 0 {
  69         return None;
  70     }
  71
  72     let old_item_indent = module.body_items[0].indent_level();
  73
  74     //This takes place in three steps:
  75     //
  76     //- Firstly, we will update the references(usages) e.g. converting a
  77     //  function call bar() to modname::bar(), and similarly for other items
  78     //
  79     //- Secondly, changing the visibility of each item inside the newly selected module
  80     //  i.e. making a fn a() {} to pub(crate) fn a() {}
  81     //
  82     //- Thirdly, resolving all the imports this includes removing paths from imports
  83     //  outside the module, shifting/cloning them inside new module, or shifting the imports, or making
  84     //  new import statemnts
  85
  86     //We are getting item usages and record_fields together, record_fields
  87     //for change_visibility and usages for first point mentioned above in the process
  88     let (usages_to_be_processed, record_fields) = module.get_usages_and_record_fields(ctx);
  89
  90     let import_paths_to_be_removed = module.resolve_imports(curr_parent_module, &ctx);
  91     module.body_items = module.change_visibility(record_fields)?;
  92     if module.body_items.len() == 0 {
  93         return None;
  94     }
  95
  96     acc.add(
  97         AssistId("extract_module", AssistKind::RefactorExtract),
  98         "Extract Module",
  99         module.text_range,
 100         |builder| {
 101             let _ = &module;
 102
 103             let mut body_items = Vec::new();
 104             let new_item_indent = old_item_indent + 1;
 105             for item in module.body_items {
 106                 let item = item.indent(IndentLevel(1));
 107                 let mut indented_item = String::new();
 108                 format_to!(indented_item, "{}{}", new_item_indent, item.to_string());
 109                 body_items.push(indented_item);
 110             }
 111
 112             let body = body_items.join("\n\n");
 113
 114             let mut module_def = String::new();
 115
 116             format_to!(module_def, "mod {} {{\n{}\n{}}}", module.name, body, old_item_indent);
 117
 118             let mut usages_to_be_updated_for_curr_file = vec![];
 119             for usages_to_be_updated_for_file in usages_to_be_processed {
 120                 if usages_to_be_updated_for_file.0 == ctx.file_id() {
 121                     usages_to_be_updated_for_curr_file = usages_to_be_updated_for_file.1;
 122                     continue;
 123                 }
 124                 builder.edit_file(usages_to_be_updated_for_file.0);
 125                 for usage_to_be_processed in usages_to_be_updated_for_file.1 {
 126                     builder.replace(usage_to_be_processed.0, usage_to_be_processed.1)
 127                 }
 128             }
 129
 130             builder.edit_file(ctx.file_id());
 131             for usage_to_be_processed in usages_to_be_updated_for_curr_file {
 132                 builder.replace(usage_to_be_processed.0, usage_to_be_processed.1)
 133             }
 134
 135             for import_path_text_range in import_paths_to_be_removed {
 136                 builder.delete(import_path_text_range);
 137             }
 138             builder.replace(module.text_range, module_def)
 139         },
 140     )
 141 }
 142
 143 #[derive(Debug)]
 144 struct Module {
 145     text_range: TextRange,
 146     name: String,
 147     body_items: Vec<ast::Item>,
 148 }
 149
 150 fn extract_target(node: &SyntaxNode, selection_range: TextRange) -> Option<Module> {
 151     let mut body_items: Vec<ast::Item> = node
 152         .children()
 153         .filter_map(|child| {
 154             if let Some(item) = ast::Item::cast(child) {
 155                 if selection_range.contains_range(item.syntax().text_range()) {
 156                     return Some(item);
 157                 }
 158                 return None;
 159             }
 160             None
 161         })
 162         .collect();
 163
 164     if let Some(node_item) = ast::Item::cast(node.clone()) {
 165         body_items.push(node_item);
 166     }
 167
 168     Some(Module { text_range: selection_range, name: "modname".to_string(), body_items })
 169 }
 170
 171 impl Module {
 172     fn get_usages_and_record_fields(
 173         &self,
 174         ctx: &AssistContext,
 175     ) -> (HashMap<FileId, Vec<(TextRange, String)>>, Vec<SyntaxNode>) {
 176         let mut adt_fields = Vec::new();
 177         let mut refs: HashMap<FileId, Vec<(TextRange, String)>> = HashMap::new();
 178
 179         //Here impl is not included as each item inside impl will be tied to the parent of
 180         //implementing block(a struct, enum, etc), if the parent is in selected module, it will
 181         //get updated by ADT section given below or if it is not, then we dont need to do any operation
 182         self.body_items.clone().into_iter().for_each(|item| {
 183             match_ast! {
 184                 match (item.syntax()) {
 185                     ast::Adt(it) => {
 186                         if let Some( nod ) = ctx.sema.to_def(&it) {
 187                             let node_def = Definition::Adt(nod.into());
 188                             self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs);
 189
 190                             //Enum Fields are not allowed to explicitly specify pub, it is implied
 191                             match it {
 192                                 ast::Adt::Struct(x) => {
 193                                     if let Some(field_list) = x.field_list() {
 194                                         match field_list {
 195                                             ast::FieldList::RecordFieldList(record_field_list) => {
 196                                                 record_field_list.fields().for_each(|record_field| {
 197                                                     adt_fields.push(record_field.syntax().clone());
 198                                                 });
 199                                             },
 200                                             ast::FieldList::TupleFieldList(tuple_field_list) => {
 201                                                 tuple_field_list.fields().for_each(|tuple_field| {
 202                                                     adt_fields.push(tuple_field.syntax().clone());
 203                                                 });
 204                                             },
 205                                         }
 206                                     }
 207                                 },
 208                                 ast::Adt::Union(x) => {
 209                                         if let Some(record_field_list) = x.record_field_list() {
 210                                             record_field_list.fields().for_each(|record_field| {
 211                                                     adt_fields.push(record_field.syntax().clone());
 212                                             });
 213                                         }
 214                                 },
 215                                 ast::Adt::Enum(_) => {},
 216                             }
 217                         }
 218                     },
 219                     ast::TypeAlias(it) => {
 220                         if let Some( nod ) = ctx.sema.to_def(&it) {
 221                             let node_def = Definition::TypeAlias(nod.into());
 222                             self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs);
 223                         }
 224                     },
 225                     ast::Const(it) => {
 226                         if let Some( nod ) = ctx.sema.to_def(&it) {
 227                             let node_def = Definition::Const(nod.into());
 228                             self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs);
 229                         }
 230                     },
 231                     ast::Static(it) => {
 232                         if let Some( nod ) = ctx.sema.to_def(&it) {
 233                             let node_def = Definition::Static(nod.into());
 234                             self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs);
 235                         }
 236                     },
 237                     ast::Fn(it) => {
 238                         if let Some( nod ) = ctx.sema.to_def(&it) {
 239                             let node_def = Definition::Function(nod.into());
 240                             self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs);
 241                         }
 242                     },
 243                     _ => (),
 244                 }
 245             }
 246         });
 247
 248         return (refs, adt_fields);
 249     }
 250
 251     fn expand_and_group_usages_file_wise(
 252         &self,
 253         ctx: &AssistContext,
 254         node_def: Definition,
 255         refs: &mut HashMap<FileId, Vec<(TextRange, String)>>,
 256     ) {
 257         for (file_id, references) in node_def.usages(&ctx.sema).all() {
 258             if let Some(file_refs) = refs.get_mut(&file_id) {
 259                 let mut usages = self.expand_ref_to_usages(references, ctx, file_id);
 260                 file_refs.append(&mut usages);
 261             } else {
 262                 refs.insert(file_id, self.expand_ref_to_usages(references, ctx, file_id));
 263             }
 264         }
 265     }
 266
 267     fn expand_ref_to_usages(
 268         &self,
 269         refs: Vec<FileReference>,
 270         ctx: &AssistContext,
 271         file_id: FileId,
 272     ) -> Vec<(TextRange, String)> {
 273         let source_file = ctx.sema.parse(file_id);
 274
 275         let mut usages_to_be_processed_for_file = Vec::new();
 276         for usage in refs {
 277             if let Some(x) = self.get_usage_to_be_processed(&source_file, usage) {
 278                 usages_to_be_processed_for_file.push(x);
 279             }
 280         }
 281
 282         usages_to_be_processed_for_file
 283     }
 284
 285     fn get_usage_to_be_processed(
 286         &self,
 287         source_file: &SourceFile,
 288         FileReference { range, name, .. }: FileReference,
 289     ) -> Option<(TextRange, String)> {
 290         let path: Option<ast::Path> = find_node_at_range(source_file.syntax(), range);
 291
 292         let path = path?;
 293
 294         for desc in path.syntax().descendants() {
 295             if desc.to_string() == name.syntax().to_string()
 296                 && !self.text_range.contains_range(desc.text_range())
 297             {
 298                 if let Some(name_ref) = ast::NameRef::cast(desc) {
 299                     return Some((
 300                         name_ref.syntax().text_range(),
 301                         format!("{}::{}", self.name, name_ref),
 302                     ));
 303                 }
 304             }
 305         }
 306
 307         None
 308     }
 309
 310     fn change_visibility(&self, record_fields: Vec<SyntaxNode>) -> Option<Vec<ast::Item>> {
 311         let (body_items, mut replacements, record_field_parents, impls) =
 312             get_replacements_for_visibilty_change(self.body_items.clone(), false);
 313
 314         let impl_items = impls.into_iter().fold(Vec::new(), |mut impl_items, x| {
 315             let mut this_impl_items =
 316                 x.syntax().descendants().fold(Vec::new(), |mut this_impl_items, x| {
 317                     if let Some(item) = ast::Item::cast(x) {
 318                         this_impl_items.push(item);
 319                     }
 320                     return this_impl_items;
 321                 });
 322
 323             impl_items.append(&mut this_impl_items);
 324             return impl_items;
 325         });
 326
 327         let (_, mut impl_item_replacements, _, _) =
 328             get_replacements_for_visibilty_change(impl_items, true);
 329
 330         replacements.append(&mut impl_item_replacements);
 331
 332         record_field_parents.into_iter().for_each(|x| {
 333             x.1.descendants().filter_map(|x| ast::RecordField::cast(x)).for_each(|desc| {
 334                 let is_record_field_present = record_fields
 335                     .clone()
 336                     .into_iter()
 337                     .find(|x| x.to_string() == desc.to_string())
 338                     .is_some();
 339                 if is_record_field_present {
 340                     replacements.push((desc.visibility(), desc.syntax().clone()));
 341                 }
 342             });
 343         });
 344
 345         replacements.into_iter().for_each(|(vis, syntax)| {
 346             add_change_vis(vis, syntax.first_child_or_token());
 347         });
 348
 349         Some(body_items)
 350     }
 351
 352     fn resolve_imports(
 353         &mut self,
 354         curr_parent_module: Option<ast::Module>,
 355         ctx: &AssistContext,
 356     ) -> Vec<TextRange> {
 357         let mut import_paths_to_be_removed: Vec<TextRange> = vec![];
 358         let mut node_set: HashSet<String> = HashSet::new();
 359
 360         self.body_items.clone().into_iter().for_each(|item| {
 361             item.syntax().descendants().for_each(|x| {
 362                 if let Some(name) = ast::Name::cast(x.clone()) {
 363                     if let Some(name_classify) = NameClass::classify(&ctx.sema, &name) {
 364                         //Necessary to avoid two same names going through
 365                         if !node_set.contains(&name.syntax().to_string()) {
 366                             node_set.insert(name.syntax().to_string());
 367                             let def_opt: Option<Definition> = match name_classify {
 368                                 NameClass::Definition(def) => Some(def),
 369                                 _ => None,
 370                             };
 371
 372                             if let Some(def) = def_opt {
 373                                 if let Some(import_path) = self
 374                                     .process_names_and_namerefs_for_import_resolve(
 375                                         def,
 376                                         name.syntax(),
 377                                         &curr_parent_module,
 378                                         ctx,
 379                                     )
 380                                 {
 381                                     import_paths_to_be_removed.push(import_path);
 382                                 }
 383                             }
 384                         }
 385                     }
 386                 }
 387
 388                 if let Some(name_ref) = ast::NameRef::cast(x) {
 389                     if let Some(name_classify) = NameRefClass::classify(&ctx.sema, &name_ref) {
 390                         //Necessary to avoid two same names going through
 391                         if !node_set.contains(&name_ref.syntax().to_string()) {
 392                             node_set.insert(name_ref.syntax().to_string());
 393                             let def_opt: Option<Definition> = match name_classify {
 394                                 NameRefClass::Definition(def) => Some(def),
 395                                 _ => None,
 396                             };
 397
 398                             if let Some(def) = def_opt {
 399                                 if let Some(import_path) = self
 400                                     .process_names_and_namerefs_for_import_resolve(
 401                                         def,
 402                                         name_ref.syntax(),
 403                                         &curr_parent_module,
 404                                         ctx,
 405                                     )
 406                                 {
 407                                     import_paths_to_be_removed.push(import_path);
 408                                 }
 409                             }
 410                         }
 411                     }
 412                 }
 413             });
 414         });
 415
 416         import_paths_to_be_removed
 417     }
 418
 419     fn process_names_and_namerefs_for_import_resolve(
 420         &mut self,
 421         def: Definition,
 422         node_syntax: &SyntaxNode,
 423         curr_parent_module: &Option<ast::Module>,
 424         ctx: &AssistContext,
 425     ) -> Option<TextRange> {
 426         //We only need to find in the current file
 427         let selection_range = ctx.selection_trimmed();
 428         let curr_file_id = ctx.file_id();
 429         let search_scope = SearchScope::single_file(curr_file_id);
 430         let usage_res = def.usages(&ctx.sema).in_scope(search_scope).all();
 431         let file = ctx.sema.parse(curr_file_id);
 432
 433         let mut exists_inside_sel = false;
 434         let mut exists_outside_sel = false;
 435         usage_res.clone().into_iter().for_each(|x| {
 436             let mut non_use_nodes_itr = (&x.1).into_iter().filter_map(|x| {
 437                 if find_node_at_range::<ast::Use>(file.syntax(), x.range).is_none() {
 438                     let path_opt = find_node_at_range::<ast::Path>(file.syntax(), x.range);
 439                     return path_opt;
 440                 }
 441
 442                 None
 443             });
 444
 445             if non_use_nodes_itr
 446                 .clone()
 447                 .find(|x| !selection_range.contains_range(x.syntax().text_range()))
 448                 .is_some()
 449             {
 450                 exists_outside_sel = true;
 451             }
 452             if non_use_nodes_itr
 453                 .find(|x| selection_range.contains_range(x.syntax().text_range()))
 454                 .is_some()
 455             {
 456                 exists_inside_sel = true;
 457             }
 458         });
 459
 460         let source_exists_outside_sel_in_same_mod = does_source_exists_outside_sel_in_same_mod(
 461             def,
 462             ctx,
 463             curr_parent_module,
 464             selection_range,
 465             curr_file_id,
 466         );
 467
 468         let use_stmt_opt: Option<ast::Use> = usage_res.into_iter().find_map(|x| {
 469             let file_id = x.0;
 470             let mut use_opt: Option<ast::Use> = None;
 471             if file_id == curr_file_id {
 472                 (&x.1).into_iter().for_each(|x| {
 473                     let node_opt: Option<ast::Use> = find_node_at_range(file.syntax(), x.range);
 474                     if let Some(node) = node_opt {
 475                         use_opt = Some(node);
 476                     }
 477                 });
 478             }
 479             return use_opt;
 480         });
 481
 482         let mut use_tree_str_opt: Option<Vec<ast::Path>> = None;
 483         //Exists inside and outside selection
 484         // - Use stmt for item is present -> get the use_tree_str and reconstruct the path in new
 485         // module
 486         // - Use stmt for item is not present ->
 487         //If it is not found, the definition is either ported inside new module or it stays
 488         //outside:
 489         //- Def is inside: Nothing to import
 490         //- Def is outside: Import it inside with super
 491
 492         //Exists inside selection but not outside -> Check for the import of it in original module,
 493         //get the use_tree_str, reconstruct the use stmt in new module
 494
 495         let mut import_path_to_be_removed: Option<TextRange> = None;
 496         if exists_inside_sel && exists_outside_sel {
 497             //Changes to be made only inside new module
 498
 499             //If use_stmt exists, find the use_tree_str, reconstruct it inside new module
 500             //If not, insert a use stmt with super and the given nameref
 501             if let Some((use_tree_str, _)) =
 502                 self.process_use_stmt_for_import_resolve(use_stmt_opt, node_syntax)
 503             {
 504                 use_tree_str_opt = Some(use_tree_str);
 505             } else if source_exists_outside_sel_in_same_mod {
 506                 //Considered only after use_stmt is not present
 507                 //source_exists_outside_sel_in_same_mod | exists_outside_sel(exists_inside_sel =
 508                 //true for all cases)
 509                 // false | false -> Do nothing
 510                 // false | true -> If source is in selection -> nothing to do, If source is outside
 511                 // mod -> ust_stmt transversal
 512                 // true  | false -> super import insertion
 513                 // true  | true -> super import insertion
 514                 self.make_use_stmt_of_node_with_super(node_syntax);
 515             }
 516         } else if exists_inside_sel && !exists_outside_sel {
 517             //Changes to be made inside new module, and remove import from outside
 518
 519             if let Some((use_tree_str, text_range_opt)) =
 520                 self.process_use_stmt_for_import_resolve(use_stmt_opt, node_syntax)
 521             {
 522                 if let Some(text_range) = text_range_opt {
 523                     import_path_to_be_removed = Some(text_range);
 524                 }
 525                 use_tree_str_opt = Some(use_tree_str);
 526             } else if source_exists_outside_sel_in_same_mod {
 527                 self.make_use_stmt_of_node_with_super(node_syntax);
 528             }
 529         }
 530
 531         if let Some(use_tree_str) = use_tree_str_opt {
 532             let mut use_tree_str = use_tree_str;
 533             use_tree_str.reverse();
 534             if use_tree_str[0].to_string().contains("super") {
 535                 let super_path = make::ext::ident_path("super");
 536                 use_tree_str.insert(0, super_path)
 537             }
 538
 539             let use_ =
 540                 make::use_(None, make::use_tree(make::join_paths(use_tree_str), None, None, false));
 541             if let Some(item) = ast::Item::cast(use_.syntax().clone()) {
 542                 self.body_items.insert(0, item);
 543             }
 544         }
 545
 546         import_path_to_be_removed
 547     }
 548
 549     fn make_use_stmt_of_node_with_super(&mut self, node_syntax: &SyntaxNode) {
 550         let super_path = make::ext::ident_path("super");
 551         let node_path = make::ext::ident_path(&node_syntax.to_string());
 552         let use_ = make::use_(
 553             None,
 554             make::use_tree(make::join_paths(vec![super_path, node_path]), None, None, false),
 555         );
 556         if let Some(item) = ast::Item::cast(use_.syntax().clone()) {
 557             self.body_items.insert(0, item);
 558         }
 559     }
 560
 561     fn process_use_stmt_for_import_resolve(
 562         &self,
 563         use_stmt_opt: Option<ast::Use>,
 564         node_syntax: &SyntaxNode,
 565     ) -> Option<(Vec<ast::Path>, Option<TextRange>)> {
 566         if let Some(use_stmt) = use_stmt_opt {
 567             for desc in use_stmt.syntax().descendants() {
 568                 if let Some(path_seg) = ast::PathSegment::cast(desc) {
 569                     if path_seg.syntax().to_string() == node_syntax.to_string() {
 570                         let mut use_tree_str = vec![path_seg.parent_path()];
 571                         get_use_tree_paths_from_path(path_seg.parent_path(), &mut use_tree_str);
 572                         for ancs in path_seg.syntax().ancestors() {
 573                             //Here we are looking for use_tree with same string value as node
 574                             //passed above as the range_to_remove function looks for a comma and
 575                             //then includes it in the text range to remove it. But the comma only
 576                             //appears at the use_tree level
 577                             if let Some(use_tree) = ast::UseTree::cast(ancs) {
 578                                 if use_tree.syntax().to_string() == node_syntax.to_string() {
 579                                     return Some((
 580                                         use_tree_str,
 581                                         Some(range_to_remove(use_tree.syntax())),
 582                                     ));
 583                                 }
 584                             }
 585                         }
 586
 587                         return Some((use_tree_str, None));
 588                     }
 589                 }
 590             }
 591         }
 592
 593         None
 594     }
 595 }
 596
 597 fn does_source_exists_outside_sel_in_same_mod(
 598     def: Definition,
 599     ctx: &AssistContext,
 600     curr_parent_module: &Option<ast::Module>,
 601     selection_range: TextRange,
 602     curr_file_id: FileId,
 603 ) -> bool {
 604     let mut source_exists_outside_sel_in_same_mod = false;
 605     match def {
 606         Definition::Module(x) => {
 607             let source = x.definition_source(ctx.db());
 608             let have_same_parent;
 609             if let Some(ast_module) = &curr_parent_module {
 610                 if let Some(hir_module) = x.parent(ctx.db()) {
 611                     have_same_parent =
 612                         compare_hir_and_ast_module(&ast_module, hir_module, ctx).is_some();
 613                 } else {
 614                     let source_file_id = source.file_id.original_file(ctx.db());
 615                     have_same_parent = source_file_id == curr_file_id;
 616                 }
 617             } else {
 618                 let source_file_id = source.file_id.original_file(ctx.db());
 619                 have_same_parent = source_file_id == curr_file_id;
 620             }
 621
 622             if have_same_parent {
 623                 match source.value {
 624                     ModuleSource::Module(module_) => {
 625                         source_exists_outside_sel_in_same_mod =
 626                             !selection_range.contains_range(module_.syntax().text_range());
 627                     }
 628                     _ => {}
 629                 }
 630             }
 631         }
 632         Definition::Function(x) => {
 633             if let Some(source) = x.source(ctx.db()) {
 634                 let have_same_parent;
 635                 if let Some(ast_module) = &curr_parent_module {
 636                     have_same_parent =
 637                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 638                 } else {
 639                     let source_file_id = source.file_id.original_file(ctx.db());
 640                     have_same_parent = source_file_id == curr_file_id;
 641                 }
 642
 643                 if have_same_parent {
 644                     source_exists_outside_sel_in_same_mod =
 645                         !selection_range.contains_range(source.value.syntax().text_range());
 646                 }
 647             }
 648         }
 649         Definition::Adt(x) => {
 650             if let Some(source) = x.source(ctx.db()) {
 651                 let have_same_parent;
 652                 if let Some(ast_module) = &curr_parent_module {
 653                     have_same_parent =
 654                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 655                 } else {
 656                     let source_file_id = source.file_id.original_file(ctx.db());
 657                     have_same_parent = source_file_id == curr_file_id;
 658                 }
 659
 660                 if have_same_parent {
 661                     source_exists_outside_sel_in_same_mod =
 662                         !selection_range.contains_range(source.value.syntax().text_range());
 663                 }
 664             }
 665         }
 666         Definition::Variant(x) => {
 667             if let Some(source) = x.source(ctx.db()) {
 668                 let have_same_parent;
 669                 if let Some(ast_module) = &curr_parent_module {
 670                     have_same_parent =
 671                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 672                 } else {
 673                     let source_file_id = source.file_id.original_file(ctx.db());
 674                     have_same_parent = source_file_id == curr_file_id;
 675                 }
 676
 677                 if have_same_parent {
 678                     source_exists_outside_sel_in_same_mod =
 679                         !selection_range.contains_range(source.value.syntax().text_range());
 680                 }
 681             }
 682         }
 683         Definition::Const(x) => {
 684             if let Some(source) = x.source(ctx.db()) {
 685                 let have_same_parent;
 686                 if let Some(ast_module) = &curr_parent_module {
 687                     have_same_parent =
 688                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 689                 } else {
 690                     let source_file_id = source.file_id.original_file(ctx.db());
 691                     have_same_parent = source_file_id == curr_file_id;
 692                 }
 693
 694                 if have_same_parent {
 695                     source_exists_outside_sel_in_same_mod =
 696                         !selection_range.contains_range(source.value.syntax().text_range());
 697                 }
 698             }
 699         }
 700         Definition::Static(x) => {
 701             if let Some(source) = x.source(ctx.db()) {
 702                 let have_same_parent;
 703                 if let Some(ast_module) = &curr_parent_module {
 704                     have_same_parent =
 705                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 706                 } else {
 707                     let source_file_id = source.file_id.original_file(ctx.db());
 708                     have_same_parent = source_file_id == curr_file_id;
 709                 }
 710
 711                 if have_same_parent {
 712                     source_exists_outside_sel_in_same_mod =
 713                         !selection_range.contains_range(source.value.syntax().text_range());
 714                 }
 715             }
 716         }
 717         Definition::Trait(x) => {
 718             if let Some(source) = x.source(ctx.db()) {
 719                 let have_same_parent;
 720                 if let Some(ast_module) = &curr_parent_module {
 721                     have_same_parent =
 722                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 723                 } else {
 724                     let source_file_id = source.file_id.original_file(ctx.db());
 725                     have_same_parent = source_file_id == curr_file_id;
 726                 }
 727
 728                 if have_same_parent {
 729                     source_exists_outside_sel_in_same_mod =
 730                         !selection_range.contains_range(source.value.syntax().text_range());
 731                 }
 732             }
 733         }
 734         Definition::TypeAlias(x) => {
 735             if let Some(source) = x.source(ctx.db()) {
 736                 let have_same_parent;
 737                 if let Some(ast_module) = &curr_parent_module {
 738                     have_same_parent =
 739                         compare_hir_and_ast_module(&ast_module, x.module(ctx.db()), ctx).is_some();
 740                 } else {
 741                     let source_file_id = source.file_id.original_file(ctx.db());
 742                     have_same_parent = source_file_id == curr_file_id;
 743                 }
 744
 745                 if have_same_parent {
 746                     source_exists_outside_sel_in_same_mod =
 747                         !selection_range.contains_range(source.value.syntax().text_range());
 748                 }
 749             }
 750         }
 751         _ => {}
 752     }
 753
 754     return source_exists_outside_sel_in_same_mod;
 755 }
 756
 757 fn get_replacements_for_visibilty_change(
 758     items: Vec<ast::Item>,
 759     is_clone_for_updated: bool,
 760 ) -> (
 761     Vec<ast::Item>,
 762     Vec<(Option<ast::Visibility>, SyntaxNode)>,
 763     Vec<(Option<ast::Visibility>, SyntaxNode)>,
 764     Vec<ast::Impl>,
 765 ) {
 766     let mut replacements = Vec::new();
 767     let mut record_field_parents = Vec::new();
 768     let mut impls = Vec::new();
 769     let mut body_items = Vec::new();
 770
 771     items.into_iter().for_each(|item| {
 772         let mut item = item;
 773         if !is_clone_for_updated {
 774             item = item.clone_for_update();
 775         }
 776         body_items.push(item.clone());
 777         //Use stmts are ignored
 778         match item {
 779             ast::Item::Const(it) => replacements.push((it.visibility(), it.syntax().clone())),
 780             ast::Item::Enum(it) => replacements.push((it.visibility(), it.syntax().clone())),
 781             ast::Item::ExternCrate(it) => replacements.push((it.visibility(), it.syntax().clone())),
 782             ast::Item::Fn(it) => replacements.push((it.visibility(), it.syntax().clone())),
 783             ast::Item::Impl(it) => impls.push(it),
 784             ast::Item::MacroRules(it) => replacements.push((it.visibility(), it.syntax().clone())),
 785             ast::Item::MacroDef(it) => replacements.push((it.visibility(), it.syntax().clone())),
 786             ast::Item::Module(it) => replacements.push((it.visibility(), it.syntax().clone())),
 787             ast::Item::Static(it) => replacements.push((it.visibility(), it.syntax().clone())),
 788             ast::Item::Struct(it) => {
 789                 replacements.push((it.visibility(), it.syntax().clone()));
 790                 record_field_parents.push((it.visibility(), it.syntax().clone()));
 791             }
 792             ast::Item::Trait(it) => replacements.push((it.visibility(), it.syntax().clone())),
 793             ast::Item::TypeAlias(it) => replacements.push((it.visibility(), it.syntax().clone())),
 794             ast::Item::Union(it) => {
 795                 replacements.push((it.visibility(), it.syntax().clone()));
 796                 record_field_parents.push((it.visibility(), it.syntax().clone()));
 797             }
 798             _ => (),
 799         }
 800     });
 801
 802     return (body_items, replacements, record_field_parents, impls);
 803 }
 804
 805 fn get_use_tree_paths_from_path(
 806     path: ast::Path,
 807     use_tree_str: &mut Vec<ast::Path>,
 808 ) -> Option<&mut Vec<ast::Path>> {
 809     path.syntax().ancestors().filter(|x| x.to_string() != path.to_string()).find_map(|x| {
 810         if let Some(use_tree) = ast::UseTree::cast(x) {
 811             if let Some(upper_tree_path) = use_tree.path() {
 812                 if upper_tree_path.to_string() != path.to_string() {
 813                     use_tree_str.push(upper_tree_path.clone());
 814                     get_use_tree_paths_from_path(upper_tree_path, use_tree_str);
 815                     return Some(use_tree);
 816                 }
 817             }
 818         }
 819         None
 820     })?;
 821
 822     Some(use_tree_str)
 823 }
 824
 825 fn add_change_vis(
 826     vis: Option<ast::Visibility>,
 827     node_or_token_opt: Option<syntax::SyntaxElement>,
 828 ) -> Option<()> {
 829     if let Some(vis) = vis {
 830         if vis.syntax().text() == "pub" {
 831             ted::replace(vis.syntax(), make::visibility_pub_crate().syntax().clone_for_update());
 832         }
 833     } else {
 834         if let Some(node_or_token) = node_or_token_opt {
 835             let pub_crate_vis = make::visibility_pub_crate().clone_for_update();
 836             if let Some(node) = node_or_token.as_node() {
 837                 ted::insert(ted::Position::before(node), pub_crate_vis.syntax());
 838             }
 839             if let Some(token) = node_or_token.as_token() {
 840                 ted::insert(ted::Position::before(token), pub_crate_vis.syntax());
 841             }
 842         }
 843     }
 844
 845     Some(())
 846 }
 847
 848 fn compare_hir_and_ast_module(
 849     ast_module: &ast::Module,
 850     hir_module: hir::Module,
 851     ctx: &AssistContext,
 852 ) -> Option<()> {
 853     let hir_mod_name = hir_module.name(ctx.db())?;
 854     let ast_mod_name = ast_module.name()?;
 855     if hir_mod_name.to_string() != ast_mod_name.to_string() {
 856         return None;
 857     }
 858
 859     return Some(());
 860 }
 861
 862 #[cfg(test)]
 863 mod tests {
 864     use crate::tests::{check_assist, check_assist_not_applicable};
 865
 866     use super::*;
 867
 868     #[test]
 869     fn test_not_applicable_without_selection() {
 870         check_assist_not_applicable(
 871             extract_module,
 872             r"
 873 $0pub struct PublicStruct {
 874     field: i32,
 875 }
 876             ",
 877         )
 878     }
 879
 880     #[test]
 881     fn test_extract_module() {
 882         check_assist(
 883             extract_module,
 884             r"
 885             mod thirdpartycrate {
 886                 pub mod nest {
 887                     pub struct SomeType;
 888                     pub struct SomeType2;
 889                 }
 890                 pub struct SomeType1;
 891             }
 892
 893             mod bar {
 894                 use crate::thirdpartycrate::{nest::{SomeType, SomeType2}, SomeType1};
 895
 896                 pub struct PublicStruct {
 897                     field: PrivateStruct,
 898                     field1: SomeType1,
 899                 }
 900
 901                 impl PublicStruct {
 902                     pub fn new() -> Self {
 903                         Self { field: PrivateStruct::new(), field1: SomeType1 }
 904                     }
 905                 }
 906
 907                 fn foo() {
 908                     let _s = PrivateStruct::new();
 909                     let _a = bar();
 910                 }
 911
 912 $0struct PrivateStruct {
 913     inner: SomeType,
 914 }
 915
 916 pub struct PrivateStruct1 {
 917     pub inner: i32,
 918 }
 919
 920 impl PrivateStruct {
 921     fn new() -> Self {
 922          PrivateStruct { inner: SomeType }
 923     }
 924 }
 925
 926 fn bar() -> i32 {
 927     2
 928 }$0
 929             }
 930             ",
 931             r"
 932             mod thirdpartycrate {
 933                 pub mod nest {
 934                     pub struct SomeType;
 935                     pub struct SomeType2;
 936                 }
 937                 pub struct SomeType1;
 938             }
 939
 940             mod bar {
 941                 use crate::thirdpartycrate::{nest::{SomeType2}, SomeType1};
 942
 943                 pub struct PublicStruct {
 944                     field: modname::PrivateStruct,
 945                     field1: SomeType1,
 946                 }
 947
 948                 impl PublicStruct {
 949                     pub fn new() -> Self {
 950                         Self { field: modname::PrivateStruct::new(), field1: SomeType1 }
 951                     }
 952                 }
 953
 954                 fn foo() {
 955                     let _s = modname::PrivateStruct::new();
 956                     let _a = modname::bar();
 957                 }
 958
 959 mod modname {
 960     use crate::thirdpartycrate::nest::SomeType;
 961
 962     pub(crate) struct PrivateStruct {
 963         pub(crate) inner: SomeType,
 964     }
 965
 966     pub(crate) struct PrivateStruct1 {
 967         pub(crate) inner: i32,
 968     }
 969
 970     impl PrivateStruct {
 971         pub(crate) fn new() -> Self {
 972              PrivateStruct { inner: SomeType }
 973         }
 974     }
 975
 976     pub(crate) fn bar() -> i32 {
 977         2
 978     }
 979 }
 980             }
 981             ",
 982         );
 983     }
 984
 985     #[test]
 986     fn test_extract_module_for_function_only() {
 987         check_assist(
 988             extract_module,
 989             r"
 990 $0fn foo(name: i32) -> i32 {
 991     name + 1
 992 }$0
 993
 994                 fn bar(name: i32) -> i32 {
 995                     name + 2
 996                 }
 997             ",
 998             r"
 999 mod modname {
1000     pub(crate) fn foo(name: i32) -> i32 {
1001         name + 1
1002     }
1003 }
1004
1005                 fn bar(name: i32) -> i32 {
1006                     name + 2
1007                 }
1008             ",
1009         )
1010     }
1011
1012     #[test]
1013     fn test_extract_module_for_impl_having_corresponding_adt_in_selection() {
1014         check_assist(
1015             extract_module,
1016             r"
1017             mod impl_play {
1018 $0struct A {}
1019
1020 impl A {
1021     pub fn new_a() -> i32 {
1022         2
1023     }
1024 }$0
1025
1026                 fn a() {
1027                     let _a = A::new_a();
1028                 }
1029             }
1030             ",
1031             r"
1032             mod impl_play {
1033 mod modname {
1034     pub(crate) struct A {}
1035
1036     impl A {
1037         pub(crate) fn new_a() -> i32 {
1038             2
1039         }
1040     }
1041 }
1042
1043                 fn a() {
1044                     let _a = modname::A::new_a();
1045                 }
1046             }
1047             ",
1048         )
1049     }
1050
1051     #[test]
1052     fn test_import_resolve_when_its_only_inside_selection() {
1053         check_assist(
1054             extract_module,
1055             r"
1056             mod foo {
1057                 pub struct PrivateStruct;
1058                 pub struct PrivateStruct1;
1059             }
1060
1061             mod bar {
1062                 use super::foo::{PrivateStruct, PrivateStruct1};
1063
1064 $0struct Strukt {
1065     field: PrivateStruct,
1066 }$0
1067
1068                 struct Strukt1 {
1069                     field: PrivateStruct1,
1070                 }
1071             }
1072             ",
1073             r"
1074             mod foo {
1075                 pub struct PrivateStruct;
1076                 pub struct PrivateStruct1;
1077             }
1078
1079             mod bar {
1080                 use super::foo::{PrivateStruct1};
1081
1082 mod modname {
1083     use super::super::foo::PrivateStruct;
1084
1085     pub(crate) struct Strukt {
1086         pub(crate) field: PrivateStruct,
1087     }
1088 }
1089
1090                 struct Strukt1 {
1091                     field: PrivateStruct1,
1092                 }
1093             }
1094             ",
1095         )
1096     }
1097
1098     #[test]
1099     fn test_import_resolve_when_its_inside_and_outside_selection_and_source_not_in_same_mod() {
1100         check_assist(
1101             extract_module,
1102             r"
1103             mod foo {
1104                 pub struct PrivateStruct;
1105             }
1106
1107             mod bar {
1108                 use super::foo::PrivateStruct;
1109
1110 $0struct Strukt {
1111     field: PrivateStruct,
1112 }$0
1113
1114                 struct Strukt1 {
1115                     field: PrivateStruct,
1116                 }
1117             }
1118             ",
1119             r"
1120             mod foo {
1121                 pub struct PrivateStruct;
1122             }
1123
1124             mod bar {
1125                 use super::foo::PrivateStruct;
1126
1127 mod modname {
1128     use super::super::foo::PrivateStruct;
1129
1130     pub(crate) struct Strukt {
1131         pub(crate) field: PrivateStruct,
1132     }
1133 }
1134
1135                 struct Strukt1 {
1136                     field: PrivateStruct,
1137                 }
1138             }
1139             ",
1140         )
1141     }
1142
1143     #[test]
1144     fn test_import_resolve_when_its_inside_and_outside_selection_and_source_is_in_same_mod() {
1145         check_assist(
1146             extract_module,
1147             r"
1148             mod bar {
1149                 pub struct PrivateStruct;
1150
1151 $0struct Strukt {
1152     field: PrivateStruct,
1153 }$0
1154
1155                 struct Strukt1 {
1156                     field: PrivateStruct,
1157                 }
1158             }
1159             ",
1160             r"
1161             mod bar {
1162                 pub struct PrivateStruct;
1163
1164 mod modname {
1165     use super::PrivateStruct;
1166
1167     pub(crate) struct Strukt {
1168         pub(crate) field: PrivateStruct,
1169     }
1170 }
1171
1172                 struct Strukt1 {
1173                     field: PrivateStruct,
1174                 }
1175             }
1176             ",
1177         )
1178     }
1179
1180     #[test]
1181     fn test_extract_module_for_correspoding_adt_of_impl_present_in_same_mod_but_not_in_selection() {
1182         check_assist(
1183             extract_module,
1184             r"
1185             mod impl_play {
1186                 struct A {}
1187
1188 $0impl A {
1189     pub fn new_a() -> i32 {
1190         2
1191     }
1192 }$0
1193
1194                 fn a() {
1195                     let _a = A::new_a();
1196                 }
1197             }
1198             ",
1199             r"
1200             mod impl_play {
1201                 struct A {}
1202
1203 mod modname {
1204     use super::A;
1205
1206     impl A {
1207         pub(crate) fn new_a() -> i32 {
1208             2
1209         }
1210     }
1211 }
1212
1213                 fn a() {
1214                     let _a = A::new_a();
1215                 }
1216             }
1217             ",
1218         )
1219     }
1220
1221     #[test]
1222     fn test_extract_module_for_impl_not_having_corresponding_adt_in_selection_and_not_in_same_mod_but_with_super(
1223     ) {
1224         check_assist(
1225             extract_module,
1226             r"
1227             mod foo {
1228                 pub struct A {}
1229             }
1230             mod impl_play {
1231                 use super::foo::A;
1232
1233 $0impl A {
1234     pub fn new_a() -> i32 {
1235         2
1236     }
1237 }$0
1238
1239                 fn a() {
1240                     let _a = A::new_a();
1241                 }
1242             }
1243             ",
1244             r"
1245             mod foo {
1246                 pub struct A {}
1247             }
1248             mod impl_play {
1249                 use super::foo::A;
1250
1251 mod modname {
1252     use super::super::foo::A;
1253
1254     impl A {
1255         pub(crate) fn new_a() -> i32 {
1256             2
1257         }
1258     }
1259 }
1260
1261                 fn a() {
1262                     let _a = A::new_a();
1263                 }
1264             }
1265             ",
1266         )
1267     }
1268
1269     #[test]
1270     fn test_import_resolve_for_trait_bounds_on_function() {
1271         check_assist(
1272             extract_module,
1273             r"
1274             mod impl_play2 {
1275                 trait JustATrait {}
1276
1277 $0struct A {}
1278
1279 fn foo<T: JustATrait>(arg: T) -> T {
1280     arg
1281 }
1282
1283 impl JustATrait for A {}
1284
1285 fn bar() {
1286     let a = A {};
1287     foo(a);
1288 }$0
1289             }
1290             ",
1291             r"
1292             mod impl_play2 {
1293                 trait JustATrait {}
1294
1295 mod modname {
1296     use super::JustATrait;
1297
1298     pub(crate) struct A {}
1299
1300     pub(crate) fn foo<T: JustATrait>(arg: T) -> T {
1301         arg
1302     }
1303
1304     impl JustATrait for A {}
1305
1306     pub(crate) fn bar() {
1307         let a = A {};
1308         foo(a);
1309     }
1310 }
1311             }
1312             ",
1313         )
1314     }
1315
1316     #[test]
1317     fn test_extract_module_for_module() {
1318         check_assist(
1319             extract_module,
1320             r"
1321             mod impl_play2 {
1322 $0mod impl_play {
1323     pub struct A {}
1324 }$0
1325             }
1326             ",
1327             r"
1328             mod impl_play2 {
1329 mod modname {
1330     pub(crate) mod impl_play {
1331         pub struct A {}
1332     }
1333 }
1334             }
1335             ",
1336         )
1337     }
1338
1339     #[test]
1340     fn test_extract_module_with_multiple_files() {
1341         check_assist(
1342             extract_module,
1343             r"
1344             //- /main.rs
1345             mod foo;
1346
1347             use foo::PrivateStruct;
1348
1349             pub struct Strukt {
1350                 field: PrivateStruct,
1351             }
1352
1353             fn main() {
1354                 $0struct Strukt1 {
1355                     field: Strukt,
1356                 }$0
1357             }
1358             //- /foo.rs
1359             pub struct PrivateStruct;
1360             ",
1361             r"
1362             mod foo;
1363
1364             use foo::PrivateStruct;
1365
1366             pub struct Strukt {
1367                 field: PrivateStruct,
1368             }
1369
1370             fn main() {
1371                 mod modname {
1372                     use super::Strukt;
1373
1374                     pub(crate) struct Strukt1 {
1375                         pub(crate) field: Strukt,
1376                     }
1377                 }
1378             }
1379             ",
1380         )
1381     }
1382 }