conflict with type name and module name

Signed-off-by: Hayashi Mikihiro <[email protected]>

Author: Hmikihiro

crates/hir/src/source_analyzer.rs

@@ -866,7 +866,8 @@ impl SourceAnalyzer {
 
         // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we are
         // trying to resolve foo::bar.
-        if path.parent_path().is_some() {
+        if let Some(parent_path) = path.parent_path() {
+            let parent_hir_path = Path::from_src(&mut ctx, parent_path);
             return match resolve_hir_path_qualifier(db, &self.resolver, &hir_path, &types_map) {
                 None if meta_path.is_some() => path
                     .first_segment()
@@ -876,6 +877,47 @@ impl SourceAnalyzer {
                             .map(PathResolution::ToolModule)
                     })
                     .map(|it| (it, None)),
+                // Case the type name conflict with use module,
+                // e.g.
+                // ```
+                // use std::str;
+                // fn main() {
+                //     str::from_utf8();  // as module std::str
+                //     str::len();        // as primitive type str
+                //     str::no_exist_item(); // as primitive type str
+                // }
+                // ```
+                Some(it)
+                    if matches!(
+                        it,
+                        PathResolution::Def(ModuleDef::Adt(_) | ModuleDef::BuiltinType(_))
+                    ) =>
+                {
+                    if let (Some(mod_path), Some(parent_hir_path)) =
+                        (hir_path.mod_path(), parent_hir_path)
+                    {
+                        if let Some(ModuleDefId::ModuleId(id)) = self
+                            .resolver
+                            .resolve_module_path_in_items(db.upcast(), mod_path)
+                            .take_types()
+                        {
+                            let parent_hir_name =
+                                parent_hir_path.segments().get(1).map(|it| it.name);
+                            let module = crate::Module { id };
+                            if module
+                                .scope(db, None)
+                                .into_iter()
+                                .any(|(name, _)| Some(&name) == parent_hir_name)
+                            {
+                                return Some((
+                                    PathResolution::Def(ModuleDef::Module(module)),
+                                    None,
+                                ));
+                            };
+                        }
+                    }
+                    Some((it, None))
+                }
                 // FIXME: We do not show substitutions for parts of path, because this is really complex
                 // due to the interactions with associated items of `impl`s and associated items of associated
                 // types.

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

@@ -1009,6 +1009,42 @@ fn test(_: Bar) {
     let a = ();
     a.quxx();
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn duplicate_struct_module_in_use() {
+        check_assist(
+            remove_unused_imports,
+            r#"
+//- /main.rs
+struct sub2;
+
+mod sub1;
+
+fn main() {
+    use $0{sub1, sub1::sub2};$0
+    sub2::fn_sub2();
+}
+//- /sub1.rs
+pub mod sub2;
+
+//- /sub1/sub2.rs
+pub mod sample {
+    pub fn fn_sub2() {}
+}
+pub use sample::fn_sub2;
+"#,
+            r#"
+struct sub2;
+
+mod sub1;
+
+fn main() {
+    use sub1::sub2;
+    sub2::fn_sub2();
+}
 "#,
         );
     }