Handle impl ?Sized. Fix tests.

Author: iDawer

crates/hir/src/display.rs

@@ -239,7 +239,8 @@ impl HirDisplay for TypeParam {
         let predicates =
             bounds.iter().cloned().map(|b| b.substitute(&Interner, &substs)).collect::<Vec<_>>();
         if !(predicates.is_empty() || f.omit_verbose_types()) {
-            write_bounds_like_dyn_trait_with_prefix(":", &predicates, SizedByDefault::Sized, f)?;
+            let default_sized = SizedByDefault::Sized { anchor: self.module(f.db).krate().id };
+            write_bounds_like_dyn_trait_with_prefix(":", &predicates, default_sized, f)?;
         }
         Ok(())
     }

crates/hir_ty/src/display.rs

@@ -4,6 +4,7 @@
 
 use std::fmt::{self, Debug};
 
+use base_db::CrateId;
 use chalk_ir::BoundVar;
 use hir_def::{
     body,
@@ -15,7 +16,7 @@ use hir_def::{
     path::{Path, PathKind},
     type_ref::{TraitBoundModifier, TypeBound, TypeRef},
     visibility::Visibility,
-    AssocContainerId, Lookup, ModuleId, TraitId,
+    AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
 };
 use hir_expand::{hygiene::Hygiene, name::Name};
 use itertools::Itertools;
@@ -582,10 +583,11 @@ impl HirDisplay for Ty {
                             .as_ref()
                             .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
                         let bounds = data.substitute(&Interner, &parameters);
+                        let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate();
                         write_bounds_like_dyn_trait_with_prefix(
                             "impl",
                             bounds.skip_binders(),
-                            SizedByDefault::Sized,
+                            SizedByDefault::Sized { anchor: krate },
                             f,
                         )?;
                         // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
@@ -646,10 +648,11 @@ impl HirDisplay for Ty {
                                     _ => false,
                                 })
                                 .collect::<Vec<_>>();
+                        let krate = id.parent.module(f.db.upcast()).krate();
                         write_bounds_like_dyn_trait_with_prefix(
                             "impl",
                             &bounds,
-                            SizedByDefault::Sized,
+                            SizedByDefault::Sized { anchor: krate },
                             f,
                         )?;
                     }
@@ -675,10 +678,11 @@ impl HirDisplay for Ty {
                             .as_ref()
                             .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
                         let bounds = data.substitute(&Interner, &opaque_ty.substitution);
+                        let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate();
                         write_bounds_like_dyn_trait_with_prefix(
                             "impl",
                             bounds.skip_binders(),
-                            SizedByDefault::Sized,
+                            SizedByDefault::Sized { anchor: krate },
                             f,
                         )?;
                     }
@@ -729,17 +733,23 @@ fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = Trai
     utils::fn_traits(db, krate)
 }
 
-fn is_sized_trait(db: &dyn DefDatabase, trait_: TraitId) -> Option<bool> {
-    let krate = trait_.lookup(db).container.krate();
-    let sized_trait =
-        db.lang_item(krate, "sized".into()).and_then(|lang_item| lang_item.as_trait())?;
-    Some(trait_ == sized_trait)
-}
-
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum SizedByDefault {
     NotSized,
-    Sized,
+    Sized { anchor: CrateId },
+}
+
+impl SizedByDefault {
+    fn is_sized_trait(self, trait_: TraitId, db: &dyn DefDatabase) -> bool {
+        match self {
+            Self::NotSized => false,
+            Self::Sized { anchor } => {
+                let sized_trait =
+                    db.lang_item(anchor, "sized".into()).and_then(|lang_item| lang_item.as_trait());
+                Some(trait_) == sized_trait
+            }
+        }
+    }
 }
 
 pub fn write_bounds_like_dyn_trait_with_prefix(
@@ -749,7 +759,9 @@ pub fn write_bounds_like_dyn_trait_with_prefix(
     f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
     write!(f, "{}", prefix)?;
-    if !predicates.is_empty() {
+    if !predicates.is_empty()
+        || predicates.is_empty() && matches!(default_sized, SizedByDefault::Sized { .. })
+    {
         write!(f, " ")?;
         write_bounds_like_dyn_trait(predicates, default_sized, f)
     } else {
@@ -771,22 +783,18 @@ fn write_bounds_like_dyn_trait(
     let mut first = true;
     let mut angle_open = false;
     let mut is_fn_trait = false;
-    let mut is_sized = None;
+    let mut is_sized = false;
     for p in predicates.iter() {
         match p.skip_binders() {
             WhereClause::Implemented(trait_ref) => {
                 let trait_ = trait_ref.hir_trait_id();
-                match is_sized_trait(f.db.upcast(), trait_) {
-                    Some(true) => {
-                        is_sized = Some(true);
-                        if default_sized == SizedByDefault::Sized {
+                if default_sized.is_sized_trait(trait_, f.db.upcast()) {
+                    is_sized = true;
+                    if matches!(default_sized, SizedByDefault::Sized { .. }) {
                             // Don't print +Sized, but rather +?Sized if absent.
                             continue;
                         }
                     }
-                    Some(false) => is_sized = is_sized.or(Some(false)),
-                    None => (),
-                }
                 if !is_fn_trait {
                     is_fn_trait = fn_traits(f.db.upcast(), trait_).any(|it| it == trait_);
                 }
@@ -851,8 +859,8 @@ fn write_bounds_like_dyn_trait(
     if angle_open {
         write!(f, ">")?;
     }
-    if default_sized == SizedByDefault::Sized && is_sized.is_some() {
-        if is_sized == Some(false) {
+    if matches!(default_sized, SizedByDefault::Sized { .. }) {
+        if !is_sized {
             write!(f, "{}?Sized", if first { "" } else { " + " })?;
         } else if first {
             write!(f, "Sized")?;

crates/hir_ty/src/tests/display_source_code.rs

@@ -42,15 +42,16 @@ fn main() {
 
 #[test]
 fn render_raw_ptr_impl_ty() {
+    // FIXME: remove parens, they apper because there is an implicit Sized bound
     check_types_source_code(
         r#"
-trait Sized {}
+#[lang = "sized"] trait Sized {}
 trait Unpin {}
-fn foo() -> *const (impl Unpin + Sized) { loop {} }
+fn foo() -> *const impl Unpin { loop {} }
 fn main() {
     let foo = foo();
     foo;
-} //^^^ *const (impl Unpin + Sized)
+} //^^^ *const (impl Unpin)
 "#,
     );
 }
@@ -72,8 +73,7 @@ fn foo(foo: &dyn for<'a> Foo<'a>) {}
 fn sized_bounds_apit() {
     check_types_source_code(
         r#"
-#[lang = "sized"]
-pub trait Sized {}
+#[lang = "sized"] trait Sized {}
 
 trait Foo {}
 trait Bar<T> {}
@@ -83,7 +83,7 @@ fn test(
     b: impl Foo + Sized,
     c: &(impl Foo + ?Sized),
     d: S<impl Foo>,
-    e: impl Bar<impl Foo>,
+    ref_any: &impl ?Sized,
     empty: impl,
 ) {
     a;
@@ -94,8 +94,8 @@ fn test(
   //^ &impl Foo + ?Sized
     d;
   //^ S<impl Foo>
-    e;
-  //^ impl Bar<impl Foo>
+    ref_any;
+  //^ &impl ?Sized
     empty;
 } //^ impl Sized
 "#,
@@ -106,8 +106,7 @@ fn test(
 fn sized_bounds_rpit() {
     check_types_source_code(
         r#"
-#[lang = "sized"]
-pub trait Sized {}
+#[lang = "sized"] trait Sized {}
 
 trait Foo {}
 fn foo() -> impl Foo { loop {} }
@@ -123,8 +122,7 @@ fn test<T: Foo>() {
 fn sized_bounds_impl_traits_in_fn_signature() {
     check_types_source_code(
         r#"
-#[lang = "sized"]
-pub trait Sized {}
+#[lang = "sized"] trait Sized {}
 
 trait Foo {}
 fn test(

crates/hir_ty/src/tests/method_resolution.rs

@@ -922,6 +922,7 @@ fn test() { foo.call(); }
 fn super_trait_impl_return_trait_method_resolution() {
     check_infer(
         r#"
+        #[lang = "sized"] trait Sized {}
         trait Base {
             fn foo(self) -> usize;
         }
@@ -939,26 +940,26 @@ fn super_trait_impl_return_trait_method_resolution() {
         }
         "#,
         expect![[r#"
-            24..28 'self': Self
-            90..101 '{ loop {} }': !
-            92..99 'loop {}': !
-            97..99 '{}': ()
-            128..139 '{ loop {} }': !
-            130..137 'loop {}': !
-            135..137 '{}': ()
-            149..154 'base2': impl Base
-            167..173 'super2': impl Super
-            187..264 '{     ...o(); }': ()
-            193..198 'base1': fn base1() -> impl Base
-            193..200 'base1()': impl Base
-            193..206 'base1().foo()': usize
-            212..218 'super1': fn super1() -> impl Super
-            212..220 'super1()': impl Super
-            212..226 'super1().foo()': usize
-            232..237 'base2': impl Base
-            232..243 'base2.foo()': usize
-            249..255 'super2': impl Super
-            249..261 'super2.foo()': usize
+            57..61 'self': Self
+            123..134 '{ loop {} }': !
+            125..132 'loop {}': !
+            130..132 '{}': ()
+            161..172 '{ loop {} }': !
+            163..170 'loop {}': !
+            168..170 '{}': ()
+            182..187 'base2': impl Base
+            200..206 'super2': impl Super
+            220..297 '{     ...o(); }': ()
+            226..231 'base1': fn base1() -> impl Base
+            226..233 'base1()': impl Base
+            226..239 'base1().foo()': usize
+            245..251 'super1': fn super1() -> impl Super
+            245..253 'super1()': impl Super
+            245..259 'super1().foo()': usize
+            265..270 'base2': impl Base
+            265..276 'base2.foo()': usize
+            282..288 'super2': impl Super
+            282..294 'super2.foo()': usize
         "#]],
     );
 }