fix: Implement default member to resolve IdentPat

Author: sgasho

crates/ide-assists/src/handlers/add_missing_impl_members.rs

@@ -2418,6 +2418,53 @@ pub struct MyStruct;
 
 impl other_file_2::Trait for MyStruct {
     $0type Iter;
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_ident_pat_in_default_members() {
+        check_assist(
+            add_missing_default_members,
+            r#"
+//- /lib.rs crate:b new_source_root:library
+pub enum State {
+    Active,
+    Inactive,
+}
+
+pub trait Checker {
+    fn check(&self) -> State;
+
+    fn is_active(&self) -> bool {
+        match self.check() {
+            State::Active => true,
+            State::Inactive => false,
+        }
+    }
+}
+//- /main.rs crate:a deps:b
+struct MyChecker;
+
+impl b::Checker for MyChecker {
+    fn check(&self) -> lib::State {
+        todo!();
+    }$0
+}"#,
+            r#"
+struct MyChecker;
+
+impl b::Checker for MyChecker {
+    fn check(&self) -> lib::State {
+        todo!();
+    }
+
+    $0fn is_active(&self) -> bool {
+        match self.check() {
+            b::State::Active => true,
+            b::State::Inactive => false,
+        }
+    }
 }"#,
         );
     }

crates/ide-db/src/path_transform.rs

@@ -11,7 +11,7 @@ use rustc_hash::FxHashMap;
 use span::Edition;
 use syntax::{
     NodeOrToken, SyntaxNode,
-    ast::{self, AstNode, HasGenericArgs, make},
+    ast::{self, AstNode, HasGenericArgs, HasName, make},
     syntax_editor::{self, SyntaxEditor},
 };
 
@@ -326,13 +326,34 @@ impl Ctx<'_> {
             }
             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
+        }
+
         let root_path = path.clone_subtree();
+
         let result = find_child_paths(&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 mut editor = SyntaxEditor::new(update_sub_item);
@@ -515,6 +536,29 @@ impl Ctx<'_> {
         }
         Some(())
     }
+
+    fn transform_ident_pat(&self, ident_pat: &ast::IdentPat) -> Option<ast::Path> {
+        let name = ident_pat.name()?;
+
+        let temp_path = make::path_from_text(&name.text());
+
+        let resolution = self.source_scope.speculative_resolve(&temp_path)?;
+
+        match resolution {
+            hir::PathResolution::Def(def) if def.as_assoc_item(self.source_scope.db).is_none() => {
+                let cfg = ImportPathConfig {
+                    prefer_no_std: false,
+                    prefer_prelude: true,
+                    prefer_absolute: false,
+                    allow_unstable: true,
+                };
+                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)
+            }
+            _ => None,
+        }
+    }
 }
 
 // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the