2 files changed, 85 insertions, 15 deletions

diff --git a/crates/completion/src/presentation.rs b/crates/completion/src/presentation.rs
index 2a19281cf..0a6f5a1ea 100644
--- a/crates/completion/src/presentation.rs
+++ b/crates/completion/src/presentation.rs
@@ -304,9 +304,14 @@ impl Completions {
     ) {
         let is_deprecated = is_deprecated(variant, ctx.db);
         let name = local_name.unwrap_or_else(|| variant.name(ctx.db).to_string());
-        let qualified_name = match &path {
-            Some(it) => it.to_string(),
-            None => name.to_string(),
+        let (qualified_name, short_qualified_name) = match &path {
+            Some(path) => {
+                let full = path.to_string();
+                let short =
+                    path.segments[path.segments.len().saturating_sub(2)..].iter().join("::");
+                (full, short)
+            }
+            None => (name.to_string(), name.to_string()),
         };
         let detail_types = variant
             .fields(ctx.db)
@@ -335,14 +340,12 @@ impl Completions {
         .set_deprecated(is_deprecated)
         .detail(detail);
 
-        if path.is_some() {
-            res = res.lookup_by(name);
-        }
-
         if variant_kind == StructKind::Tuple {
             mark::hit!(inserts_parens_for_tuple_enums);
             let params = Params::Anonymous(variant.fields(ctx.db).len());
-            res = res.add_call_parens(ctx, qualified_name, params)
+            res = res.add_call_parens(ctx, short_qualified_name, params)
+        } else if path.is_some() {
+            res = res.lookup_by(short_qualified_name);
         }
 
         res.add_to(self);
@@ -607,6 +610,57 @@ fn main() { Foo::Fo<|> }
     }
 
     #[test]
+    fn lookup_enums_by_two_qualifiers() {
+        check(
+            r#"
+mod m {
+    pub enum Spam { Foo, Bar(i32) }
+}
+fn main() { let _: m::Spam = S<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "Spam::Bar(…)",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "Spam::Bar($0)",
+                        kind: EnumVariant,
+                        lookup: "Spam::Bar",
+                        detail: "(i32)",
+                        trigger_call_info: true,
+                    },
+                    CompletionItem {
+                        label: "m",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "m",
+                        kind: Module,
+                    },
+                    CompletionItem {
+                        label: "m::Spam::Foo",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "m::Spam::Foo",
+                        kind: EnumVariant,
+                        lookup: "Spam::Foo",
+                        detail: "()",
+                    },
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "main()$0",
+                        kind: Function,
+                        lookup: "main",
+                        detail: "fn main()",
+                    },
+                ]
+            "#]],
+        )
+    }
+
+    #[test]
     fn sets_deprecated_flag_in_completion_items() {
         check(
             r#"
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 14cd3a2b4..ce1174cbe 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -5,6 +5,7 @@ use base_db::CrateId;
 use chalk_ir::cast::Cast;
 use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
 use hir_def::{lang_item::LangItemTarget, TraitId};
+use stdx::panic_context;
 
 use crate::{db::HirDatabase, DebruijnIndex, Substs};
 
@@ -168,14 +169,23 @@ fn solve(
     };
 
     let mut solve = || {
-        if is_chalk_print() {
-            let logging_db = LoggingRustIrDatabase::new(context);
-            let solution = solver.solve_limited(&logging_db, goal, &should_continue);
-            log::debug!("chalk program:\n{}", logging_db);
+        let _ctx = if is_chalk_debug() || is_chalk_print() {
+            Some(panic_context::enter(format!("solving {:?}", goal)))
+        } else {
+            None
+        };
+        let solution = if is_chalk_print() {
+            let logging_db =
+                LoggingRustIrDatabaseLoggingOnDrop(LoggingRustIrDatabase::new(context));
+            let solution = solver.solve_limited(&logging_db.0, goal, &should_continue);
             solution
         } else {
             solver.solve_limited(&context, goal, &should_continue)
-        }
+        };
+
+        log::debug!("solve({:?}) => {:?}", goal, solution);
+
+        solution
     };
 
     // don't set the TLS for Chalk unless Chalk debugging is active, to make
@@ -183,11 +193,17 @@ fn solve(
     let solution =
         if is_chalk_debug() { chalk::tls::set_current_program(db, solve) } else { solve() };
 
-    log::debug!("solve({:?}) => {:?}", goal, solution);
-
     solution
 }
 
+struct LoggingRustIrDatabaseLoggingOnDrop<'a>(LoggingRustIrDatabase<Interner, ChalkContext<'a>>);
+
+impl<'a> Drop for LoggingRustIrDatabaseLoggingOnDrop<'a> {
+    fn drop(&mut self) {
+        eprintln!("chalk program:\n{}", self.0);
+    }
+}
+
 fn is_chalk_debug() -> bool {
     std::env::var("CHALK_DEBUG").is_ok()
 }