Merge #7732

7732: Don't lower TypeBound::Lifetime as GenericPredicate::Error r=flodiebold a=Veykril

Basically we just discard the typebound for now instead when lowering to `GenericPredicate`. I think this shouldn't have any other side effects?

Fixes #7683(hopefully for real this time)

I also played around with introducing `GenericPredicate::LifetimeOutlives` and `GenericPredicate::TypeOutlives`(see https://github.com/Veykril/rust-analyzer/commit/b9d69048451a5f2e9c5a72c800369bbeef36fdcf) but that won't fix this issue(at least not for now) due to lifetime predicate mismatches when resolving methods so I figure this is a good way to fix it for now.

Co-authored-by: Lukas Wirth <[email protected]>

4 files changed, 41 insertions, 32 deletions

diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 38a043c48..271fcbfaf 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -467,8 +467,7 @@ impl HirDisplay for ApplicationTy {
                             .as_ref()
                             .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
                         let bounds = data.subst(&self.parameters);
-                        write!(f, "impl ")?;
-                        write_bounds_like_dyn_trait(&bounds.value, f)?;
+                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?;
                         // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
                     }
                     OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
@@ -548,10 +547,10 @@ impl HirDisplay for Ty {
                         write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
                     }
                     TypeParamProvenance::ArgumentImplTrait => {
-                        write!(f, "impl ")?;
                         let bounds = f.db.generic_predicates_for_param(*id);
                         let substs = Substs::type_params_for_generics(&generics);
-                        write_bounds_like_dyn_trait(
+                        write_bounds_like_dyn_trait_with_prefix(
+                            "impl",
                             &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
                             f,
                         )?;
@@ -560,8 +559,7 @@ impl HirDisplay for Ty {
             }
             Ty::Bound(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
             Ty::Dyn(predicates) => {
-                write!(f, "dyn ")?;
-                write_bounds_like_dyn_trait(predicates, f)?;
+                write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?;
             }
             Ty::Opaque(opaque_ty) => {
                 match opaque_ty.opaque_ty_id {
@@ -572,8 +570,7 @@ impl HirDisplay for Ty {
                             .as_ref()
                             .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
                         let bounds = data.subst(&opaque_ty.parameters);
-                        write!(f, "impl ")?;
-                        write_bounds_like_dyn_trait(&bounds.value, f)?;
+                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?;
                     }
                     OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
                         write!(f, "{{async block}}")?;
@@ -627,7 +624,21 @@ fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = Trai
     ArrayVec::from(fn_traits).into_iter().flatten().flat_map(|it| it.as_trait())
 }
 
-pub fn write_bounds_like_dyn_trait(
+pub fn write_bounds_like_dyn_trait_with_prefix(
+    prefix: &str,
+    predicates: &[GenericPredicate],
+    f: &mut HirFormatter,
+) -> Result<(), HirDisplayError> {
+    write!(f, "{}", prefix)?;
+    if !predicates.is_empty() {
+        write!(f, " ")?;
+        write_bounds_like_dyn_trait(predicates, f)
+    } else {
+        Ok(())
+    }
+}
+
+fn write_bounds_like_dyn_trait(
     predicates: &[GenericPredicate],
     f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index f9dc832bd..99b0ecf3b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -655,17 +655,6 @@ impl TraitRef {
     ) -> Substs {
         substs_from_path_segment(ctx, segment, Some(resolved.into()), false)
     }
-
-    pub(crate) fn from_type_bound(
-        ctx: &TyLoweringContext<'_>,
-        bound: &TypeBound,
-        self_ty: Ty,
-    ) -> Option<TraitRef> {
-        match bound {
-            TypeBound::Path(path) => TraitRef::from_path(ctx, path, Some(self_ty)),
-            TypeBound::Lifetime(_) | TypeBound::Error => None,
-        }
-    }
 }
 
 impl GenericPredicate {
@@ -705,13 +694,22 @@ impl GenericPredicate {
         bound: &'a TypeBound,
         self_ty: Ty,
     ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        let trait_ref = TraitRef::from_type_bound(ctx, bound, self_ty);
-        iter::once(trait_ref.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented))
-            .chain(
-                trait_ref
-                    .into_iter()
-                    .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)),
-            )
+        let mut bindings = None;
+        let trait_ref = match bound {
+            TypeBound::Path(path) => {
+                bindings = TraitRef::from_path(ctx, path, Some(self_ty));
+                Some(
+                    bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented),
+                )
+            }
+            TypeBound::Lifetime(_) => None,
+            TypeBound::Error => Some(GenericPredicate::Error),
+        };
+        trait_ref.into_iter().chain(
+            bindings
+                .into_iter()
+                .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)),
+        )
     }
 }
 
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 80e795fbf..659b8fce9 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1114,14 +1114,14 @@ fn method_on_dyn_impl() {
 trait Foo {}
 
 impl Foo for u32 {}
-impl dyn Foo {
+impl dyn Foo + '_ {
     pub fn dyn_foo(&self) -> u32 {
         0
     }
 }
 
 fn main() {
-    let f = &42u32 as &dyn Foo<u32>;
+    let f = &42u32 as &dyn Foo;
     f.dyn_foo();
   // ^u32
 }
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 7fce441f2..1298e5a88 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -1409,10 +1409,10 @@ fn weird_bounds() {
         fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {}
         "#,
         expect![[r#"
-            23..24 'a': impl Trait + {error}
-            50..51 'b': impl {error}
+            23..24 'a': impl Trait
+            50..51 'b': impl
             69..70 'c': impl Trait
-            86..87 'd': impl {error}
+            86..87 'd': impl
             107..108 'e': impl {error}
             123..124 'f': impl Trait + {error}
             147..149 '{}': ()