fix: avoid shadow local symbol from completions

Author: CubeSugarCheese

crates/ide-completion/src/tests/flyimport.rs

@@ -1458,6 +1458,28 @@ enum Foo {
     )
 }
 
+#[test]
+fn flyimport_enum_variant_not_shadow_by_fn() {
+    check(r#"
+//- /std.rs crate:std
+pub enum Result<T, E> {
+    Ok(T),
+    Err(E)
+}
+
+//- /dep.rs crate:dep deps:std
+use std::Result;
+pub fn Ok<T>(t: T) -> Result<T, ()> {}
+
+//- /main.rs crate:main deps:std,dep
+use std::{Result, Result::Ok};
+fn main() -> Result<(), ()> {
+    Ok$0
+}
+"#,
+    expect![[r#""#]])
+}
+
 #[test]
 fn flyimport_attribute() {
     check(

crates/ide-db/src/imports/import_assets.rs

@@ -281,7 +281,35 @@ impl ImportAssets {
         match &self.import_candidate {
             ImportCandidate::Path(path_candidate) => {
                 path_applicable_imports(sema, krate, path_candidate, mod_path, |item_to_import| {
+                    let import_def = match item_to_import {
+                        ItemInNs::Types(def) => def,
+                        ItemInNs::Values(def) => def,
+                        ItemInNs::Macros(def) => ModuleDef::Macro(def),
+                    };
+                    fn will_shadow(db: &dyn HirDatabase, cur: ModuleDef, other: ModuleDef) -> bool {
+                        match (cur, other) {
+                            (ModuleDef::Module(a), ModuleDef::Module(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Function(a), ModuleDef::Function(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Adt(a), ModuleDef::Adt(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Variant(a), ModuleDef::Variant(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Variant(a), ModuleDef::Function(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Const(a), ModuleDef::Const(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Static(a), ModuleDef::Static(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Trait(a), ModuleDef::Trait(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::TraitAlias(a), ModuleDef::TraitAlias(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::TypeAlias(a), ModuleDef::TypeAlias(b)) => a.name(db) == b.name(db),
+                            (ModuleDef::Macro(a), ModuleDef::Macro(b)) => a.name(db) == b.name(db),
+                            (_, _) => false,
+                        }
+                    }
+
                     !scope_definitions.contains(&ScopeDef::from(item_to_import))
+                        && scope_definitions.iter().find(|&&scope_def| match scope_def {
+                            ScopeDef::ModuleDef(module_def) => {
+                                will_shadow(sema.db, module_def, import_def)
+                            },
+                            _ => false
+                    }).is_none()
                 })
             }
             ImportCandidate::TraitAssocItem(trait_candidate)