refactor: use Vec of Either<ast::Path, ast::IdentPat> to reduce complexity

Author: sgasho

crates/ide-db/src/path_transform.rs

@@ -315,53 +315,44 @@ impl Ctx<'_> {
     }
 
     fn transform_path(&self, path: &SyntaxNode) -> SyntaxNode {
-        fn find_child_paths(root_path: &SyntaxNode) -> Vec<ast::Path> {
-            let mut result = Vec::new();
+        fn find_child_paths_and_ident_pats(root_path: &SyntaxNode) -> Vec<Either<ast::Path, ast::IdentPat>> {
+            let mut result: Vec<Either<ast::Path, ast::IdentPat>> = Vec::new();
             for child in root_path.children() {
                 if let Some(child_path) = ast::Path::cast(child.clone()) {
-                    result.push(child_path);
+                    result.push(either::Left(child_path));
+                } else if let Some(child_ident_pat) = ast::IdentPat::cast(child.clone()) {
+                    result.push(either::Right(child_ident_pat));
                 } else {
-                    result.extend(find_child_paths(&child));
-                }
-            }
-            result
-        }
-        fn find_child_ident_pats(root_path: &SyntaxNode) -> Vec<ast::IdentPat> {
-            let mut result = Vec::new();
-            for child in root_path.children() {
-                if let Some(child_ident_pat) = ast::IdentPat::cast(child.clone()) {
-                    result.push(child_ident_pat);
-                } else {
-                    result.extend(find_child_ident_pats(&child));
+                    result.extend(find_child_paths_and_ident_pats(&child));
                 }
             }
             result
         }
 
         let root_path = path.clone_subtree();
 
-        let result = find_child_paths(&root_path);
+        let result = find_child_paths_and_ident_pats(&root_path);
         let mut editor = SyntaxEditor::new(root_path.clone());
         for sub_path in result {
             let new = self.transform_path(sub_path.syntax());
             editor.replace(sub_path.syntax(), new);
         }
 
-        let ident_result = find_child_ident_pats(&root_path);
-        for ident_pat in ident_result {
-            if let Some(new) = self.transform_ident_pat(&ident_pat) {
-                editor.replace(ident_pat.syntax(), new.syntax());
-            }
-        }
-
         let update_sub_item = editor.finish().new_root().clone().clone_subtree();
-        let item = find_child_paths(&update_sub_item);
+        let item = find_child_paths_and_ident_pats(&update_sub_item);
         let mut editor = SyntaxEditor::new(update_sub_item);
         for sub_path in item {
-            self.transform_path_(&mut editor, &sub_path);
+            self.transform_path_or_ident_pat(&mut editor, &sub_path);
         }
         editor.finish().new_root().clone()
     }
+    
+    fn transform_path_or_ident_pat(&self, editor: &mut SyntaxEditor, item: &Either<ast::Path, ast::IdentPat>) -> Option<()> {
+        match item {
+            Either::Left(path) => self.transform_path_(editor, path),
+            Either::Right(ident_pat) => self.transform_ident_pat(editor, ident_pat)
+        }
+    }
 
     fn transform_path_(&self, editor: &mut SyntaxEditor, path: &ast::Path) -> Option<()> {
         if path.qualifier().is_some() {
@@ -537,7 +528,7 @@ impl Ctx<'_> {
         Some(())
     }
 
-    fn transform_ident_pat(&self, ident_pat: &ast::IdentPat) -> Option<ast::Path> {
+    fn transform_ident_pat(&self, editor: &mut SyntaxEditor, ident_pat: &ast::IdentPat) -> Option<()> {
         let name = ident_pat.name()?;
 
         let temp_path = make::path_from_text(&name.text());
@@ -554,7 +545,8 @@ impl Ctx<'_> {
                 };
                 let found_path = self.target_module.find_path(self.source_scope.db, def, cfg)?;
                 let res = mod_path_to_ast(&found_path, self.target_edition).clone_for_update();
-                Some(res)
+                editor.replace(ident_pat.syntax(), res.syntax());
+                Some(())
             }
             _ => None,
         }