do not use associated types placeholder for inlay hint

Signed-off-by: Benjamin Coenen <[email protected]>

Author: bnjjj

crates/hir_ty/src/display.rs

@@ -84,26 +84,17 @@ pub trait HirDisplay {
     }
 
     /// Returns a String representation of `self` for test purposes
-    fn display_test<'a>(
-        &'a self,
-        db: &'a dyn HirDatabase,
-        module_id: ModuleId,
-    ) -> Result<String, DisplaySourceCodeError> {
-        let mut result = String::new();
-        match self.hir_fmt(&mut HirFormatter {
+    fn display_test<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self>
+    where
+        Self: Sized,
+    {
+        HirDisplayWrapper {
             db,
-            fmt: &mut result,
-            buf: String::with_capacity(20),
-            curr_size: 0,
+            t: self,
             max_size: None,
             omit_verbose_types: false,
-            display_target: DisplayTarget::Test { module_id },
-        }) {
-            Ok(()) => {}
-            Err(HirDisplayError::FmtError) => panic!("Writing to String can't fail!"),
-            Err(HirDisplayError::DisplaySourceCodeError(e)) => return Err(e),
-        };
-        Ok(result)
+            display_target: DisplayTarget::Test,
+        }
     }
 }
 
@@ -158,15 +149,15 @@ enum DisplayTarget {
     /// The generated code should compile, so paths need to be qualified.
     SourceCode { module_id: ModuleId },
     /// Only for test purpose to keep real types
-    Test { module_id: ModuleId },
+    Test,
 }
 
 impl DisplayTarget {
     fn is_source_code(&self) -> bool {
         matches!(self, Self::SourceCode {..})
     }
     fn is_test(&self) -> bool {
-        matches!(self, Self::Test {..})
+        matches!(self, Self::Test)
     }
 }
 
@@ -348,15 +339,15 @@ impl HirDisplay for ApplicationTy {
             }
             TypeCtor::Adt(def_id) => {
                 match f.display_target {
-                    DisplayTarget::Diagnostics => {
+                    DisplayTarget::Diagnostics | DisplayTarget::Test => {
                         let name = match def_id {
                             AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
                             AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
                             AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
                         };
                         write!(f, "{}", name)?;
                     }
-                    DisplayTarget::SourceCode { module_id } | DisplayTarget::Test { module_id } => {
+                    DisplayTarget::SourceCode { module_id } => {
                         if let Some(path) = find_path::find_path(
                             f.db.upcast(),
                             ItemInNs::Types(def_id.into()),
@@ -417,28 +408,23 @@ impl HirDisplay for ApplicationTy {
                     _ => panic!("not an associated type"),
                 };
                 let trait_ = f.db.trait_data(trait_);
-                let type_alias = f.db.type_alias_data(type_alias);
+                let type_alias_data = f.db.type_alias_data(type_alias);
 
                 // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
-                if f.display_target.is_test() || self.parameters.len() > 1 {
-                    write!(f, "{}::{}", trait_.name, type_alias.name)?;
+                if f.display_target.is_test() {
+                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
                     if self.parameters.len() > 0 {
                         write!(f, "<")?;
                         f.write_joined(&*self.parameters.0, ", ")?;
                         write!(f, ">")?;
                     }
                 } else {
-                    if self.parameters.len() == 1 {
-                        write!(
-                            f,
-                            "<{} as {}>::{}",
-                            self.parameters.as_single().display(f.db),
-                            trait_.name,
-                            type_alias.name
-                        )?;
-                    } else {
-                        write!(f, "{}::{}", trait_.name, type_alias.name)?;
-                    }
+                    let projection_ty = ProjectionTy {
+                        associated_ty: type_alias,
+                        parameters: self.parameters.clone(),
+                    };
+
+                    projection_ty.hir_fmt(f)?;
                 }
             }
             TypeCtor::ForeignType(type_alias) => {

crates/hir_ty/src/tests.rs

@@ -157,14 +157,13 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                 (node.value.text_range(), node.value.text().to_string().replace("\n", " "))
             };
             let macro_prefix = if node.file_id != file_id.into() { "!" } else { "" };
-            let module = db.module_for_file(node.file_id.original_file(&db));
             format_to!(
                 buf,
                 "{}{:?} '{}': {}\n",
                 macro_prefix,
                 range,
                 ellipsize(text, 15),
-                ty.display_test(&db, module).unwrap()
+                ty.display_test(&db)
             );
         }
         if include_mismatches {
@@ -175,14 +174,13 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             for (src_ptr, mismatch) in &mismatches {
                 let range = src_ptr.value.text_range();
                 let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" };
-                let module = db.module_for_file(src_ptr.file_id.original_file(&db));
                 format_to!(
                     buf,
                     "{}{:?}: expected {}, got {}\n",
                     macro_prefix,
                     range,
-                    mismatch.expected.display_test(&db, module).unwrap(),
-                    mismatch.actual.display_test(&db, module).unwrap(),
+                    mismatch.expected.display_test(&db),
+                    mismatch.actual.display_test(&db),
                 );
             }
         }

crates/hir_ty/src/tests/method_resolution.rs

@@ -108,16 +108,16 @@ fn infer_associated_method_with_modules() {
     check_infer(
         r#"
         mod a {
-            pub struct A;
+            struct A;
             impl A { pub fn thing() -> A { A {} }}
         }
 
         mod b {
-            pub struct B;
+            struct B;
             impl B { pub fn thing() -> u32 { 99 }}
 
-            pub mod c {
-                pub struct C;
+            mod c {
+                struct C;
                 impl C { pub fn thing() -> C { C {} }}
             }
         }
@@ -130,22 +130,22 @@ fn infer_associated_method_with_modules() {
         }
         "#,
         expect![[r#"
-            59..67 '{ A {} }': a::A
-            61..65 'A {}': a::A
-            133..139 '{ 99 }': u32
-            135..137 '99': u32
-            217..225 '{ C {} }': c::C
-            219..223 'C {}': c::C
-            256..340 '{     ...g(); }': ()
-            266..267 'x': a::A
-            270..281 'a::A::thing': fn thing() -> A
-            270..283 'a::A::thing()': a::A
-            293..294 'y': u32
-            297..308 'b::B::thing': fn thing() -> u32
-            297..310 'b::B::thing()': u32
-            320..321 'z': c::C
-            324..335 'c::C::thing': fn thing() -> C
-            324..337 'c::C::thing()': c::C
+            55..63 '{ A {} }': A
+            57..61 'A {}': A
+            125..131 '{ 99 }': u32
+            127..129 '99': u32
+            201..209 '{ C {} }': C
+            203..207 'C {}': C
+            240..324 '{     ...g(); }': ()
+            250..251 'x': A
+            254..265 'a::A::thing': fn thing() -> A
+            254..267 'a::A::thing()': A
+            277..278 'y': u32
+            281..292 'b::B::thing': fn thing() -> u32
+            281..294 'b::B::thing()': u32
+            304..305 'z': C
+            308..319 'c::C::thing': fn thing() -> C
+            308..321 'c::C::thing()': C
         "#]],
     );
 }