internal: Add a database lifetime to InternedOpaqueTyId

crates/hir-ty/src/db.rs

@@ -346,7 +346,7 @@ fn hir_database_is_dyn_compatible() {
     fn _assert_dyn_compatible(_: &dyn HirDatabase) {}
 }
 
-#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
+#[salsa_macros::interned(debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedOpaqueTyId {
     pub loc: ImplTraitId,

crates/hir-ty/src/dyn_compatibility.rs

@@ -498,9 +498,9 @@ fn contains_illegal_impl_trait_in_trait<'db>(
     db: &'db dyn HirDatabase,
     sig: &EarlyBinder<'db, Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>>,
 ) -> Option<MethodViolationCode> {
-    struct OpaqueTypeCollector(FxHashSet<InternedOpaqueTyId>);
+    struct OpaqueTypeCollector<'db>(FxHashSet<InternedOpaqueTyId<'db>>);
 
-    impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for OpaqueTypeCollector {
+    impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for OpaqueTypeCollector<'db> {
         type Result = ControlFlow<()>;
 
         fn visit_ty(

crates/hir-ty/src/infer.rs

@@ -767,7 +767,7 @@ pub struct InferenceResult<'db> {
     pub(crate) type_of_pat: ArenaMap<PatId, StoredTy>,
     pub(crate) type_of_binding: ArenaMap<BindingId, StoredTy>,
     pub(crate) type_of_type_placeholder: FxHashMap<TypeRefId, StoredTy>,
-    pub(crate) type_of_opaque: FxHashMap<InternedOpaqueTyId, StoredTy>,
+    pub(crate) type_of_opaque: FxHashMap<InternedOpaqueTyId<'db>, StoredTy>,
 
     /// Whether there are any type-mismatching errors in the result.
     // FIXME: This isn't as useful as initially thought due to us falling back placeholders to

crates/hir-ty/src/lower.rs

@@ -1267,7 +1267,11 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         }
     }
 
-    fn lower_impl_trait(&mut self, def_id: InternedOpaqueTyId, bounds: &[TypeBound]) -> ImplTrait {
+    fn lower_impl_trait(
+        &mut self,
+        def_id: InternedOpaqueTyId<'db>,
+        bounds: &[TypeBound],
+    ) -> ImplTrait {
         let interner = self.interner;
         cov_mark::hit!(lower_rpit);
         let args = GenericArgs::identity_for_item(interner, def_id.into());
@@ -1526,7 +1530,7 @@ impl ImplTraitId {
     }
 }
 
-impl InternedOpaqueTyId {
+impl InternedOpaqueTyId<'_> {
     #[inline]
     pub fn predicates<'db>(self, db: &'db dyn HirDatabase) -> EarlyBinder<'db, &'db [Clause<'db>]> {
         self.loc(db).predicates(db)

crates/hir-ty/src/next_solver/def_id.rs

@@ -43,7 +43,7 @@ pub enum SolverDefId<'db> {
     InternedClosureId(InternedClosureId<'db>),
     InternedCoroutineId(InternedCoroutineId<'db>),
     InternedCoroutineClosureId(InternedCoroutineClosureId<'db>),
-    InternedOpaqueTyId(InternedOpaqueTyId),
+    InternedOpaqueTyId(InternedOpaqueTyId<'db>),
     EnumVariantId(EnumVariantId),
     Ctor(Ctor),
 }
@@ -136,7 +136,7 @@ impl_from!(
     InternedClosureId<'db>,
     InternedCoroutineId<'db>,
     InternedCoroutineClosureId<'db>,
-    InternedOpaqueTyId,
+    InternedOpaqueTyId<'db>,
     EnumVariantId,
     Ctor
     for SolverDefId<'db>
@@ -387,162 +387,77 @@ macro_rules! declare_id_wrapper {
     };
 }
 
-declare_id_wrapper!(TraitIdWrapper, TraitId);
-declare_id_wrapper!(TypeAliasIdWrapper, TypeAliasId);
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ClosureIdWrapper<'db>(pub InternedClosureId<'db>);
-
-impl std::fmt::Debug for ClosureIdWrapper<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&SolverDefId::from(self.0), f)
-    }
-}
-
-impl<'db> From<ClosureIdWrapper<'db>> for InternedClosureId<'db> {
-    #[inline]
-    fn from(value: ClosureIdWrapper<'db>) -> InternedClosureId<'db> {
-        value.0
-    }
-}
-
-impl<'db> From<InternedClosureId<'db>> for ClosureIdWrapper<'db> {
-    #[inline]
-    fn from(value: InternedClosureId<'db>) -> ClosureIdWrapper<'db> {
-        Self(value)
-    }
-}
+/// This is similar to [`declare_id_wrapper`], but handles ids which have the `'db` lifetime.
+macro_rules! declare_id_wrapper_with_lt {
+    ($name:ident, $wraps:ident) => {
+        declare_id_wrapper_with_lt!($name, $wraps, SolverDefId<'db>);
+    };
 
-impl<'db> From<ClosureIdWrapper<'db>> for SolverDefId<'db> {
-    #[inline]
-    fn from(value: ClosureIdWrapper<'db>) -> SolverDefId<'db> {
-        value.0.into()
-    }
-}
+    ($name:ident, $wraps:ident, $local:ty) => {
+        declare_id_wrapper_with_lt!($name, $wraps, $local, no_try_from);
 
-impl<'db> TryFrom<SolverDefId<'db>> for ClosureIdWrapper<'db> {
-    type Error = ();
+        impl<'db> TryFrom<SolverDefId<'db>> for $name<'db> {
+            type Error = ();
 
-    #[inline]
-    fn try_from(value: SolverDefId<'db>) -> Result<Self, Self::Error> {
-        match value {
-            SolverDefId::InternedClosureId(it) => Ok(Self(it)),
-            _ => Err(()),
+            #[inline]
+            fn try_from(value: SolverDefId<'db>) -> Result<Self, Self::Error> {
+                match value {
+                    SolverDefId::$wraps(it) => Ok(Self(it)),
+                    _ => Err(()),
+                }
+            }
         }
-    }
-}
-
-impl<'db> inherent::DefId<DbInterner<'db>, SolverDefId<'db>> for ClosureIdWrapper<'db> {
-    fn as_local(self) -> Option<SolverDefId<'db>> {
-        Some(self.into())
-    }
-    fn is_local(self) -> bool {
-        true
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct CoroutineIdWrapper<'db>(pub InternedCoroutineId<'db>);
-
-impl std::fmt::Debug for CoroutineIdWrapper<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&SolverDefId::from(self.0), f)
-    }
-}
-
-impl<'db> From<CoroutineIdWrapper<'db>> for InternedCoroutineId<'db> {
-    #[inline]
-    fn from(value: CoroutineIdWrapper<'db>) -> InternedCoroutineId<'db> {
-        value.0
-    }
-}
-
-impl<'db> From<InternedCoroutineId<'db>> for CoroutineIdWrapper<'db> {
-    #[inline]
-    fn from(value: InternedCoroutineId<'db>) -> CoroutineIdWrapper<'db> {
-        Self(value)
-    }
-}
-
-impl<'db> From<CoroutineIdWrapper<'db>> for SolverDefId<'db> {
-    #[inline]
-    fn from(value: CoroutineIdWrapper<'db>) -> SolverDefId<'db> {
-        value.0.into()
-    }
-}
+    };
 
-impl<'db> TryFrom<SolverDefId<'db>> for CoroutineIdWrapper<'db> {
-    type Error = ();
+    ($name:ident, $wraps:ident, $local:ty, no_try_from) => {
+        #[derive(Clone, Copy, PartialEq, Eq, Hash)]
+        pub struct $name<'db>(pub $wraps<'db>);
 
-    #[inline]
-    fn try_from(value: SolverDefId<'db>) -> Result<Self, Self::Error> {
-        match value {
-            SolverDefId::InternedCoroutineId(it) => Ok(Self(it)),
-            _ => Err(()),
+        impl std::fmt::Debug for $name<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                std::fmt::Debug::fmt(&SolverDefId::from(self.0), f)
+            }
         }
-    }
-}
 
-impl<'db> inherent::DefId<DbInterner<'db>, SolverDefId<'db>> for CoroutineIdWrapper<'db> {
-    fn as_local(self) -> Option<SolverDefId<'db>> {
-        Some(self.into())
-    }
-    fn is_local(self) -> bool {
-        true
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct CoroutineClosureIdWrapper<'db>(pub InternedCoroutineClosureId<'db>);
-
-impl std::fmt::Debug for CoroutineClosureIdWrapper<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&SolverDefId::from(self.0), f)
-    }
-}
-
-impl<'db> From<CoroutineClosureIdWrapper<'db>> for InternedCoroutineClosureId<'db> {
-    #[inline]
-    fn from(value: CoroutineClosureIdWrapper<'db>) -> InternedCoroutineClosureId<'db> {
-        value.0
-    }
-}
-
-impl<'db> From<InternedCoroutineClosureId<'db>> for CoroutineClosureIdWrapper<'db> {
-    #[inline]
-    fn from(value: InternedCoroutineClosureId<'db>) -> CoroutineClosureIdWrapper<'db> {
-        Self(value)
-    }
-}
+        impl<'db> From<$name<'db>> for $wraps<'db> {
+            #[inline]
+            fn from(value: $name<'db>) -> $wraps<'db> {
+                value.0
+            }
+        }
 
-impl<'db> From<CoroutineClosureIdWrapper<'db>> for SolverDefId<'db> {
-    #[inline]
-    fn from(value: CoroutineClosureIdWrapper<'db>) -> SolverDefId<'db> {
-        value.0.into()
-    }
-}
+        impl<'db> From<$wraps<'db>> for $name<'db> {
+            #[inline]
+            fn from(value: $wraps<'db>) -> $name<'db> {
+                Self(value)
+            }
+        }
 
-impl<'db> TryFrom<SolverDefId<'db>> for CoroutineClosureIdWrapper<'db> {
-    type Error = ();
+        impl<'db> From<$name<'db>> for SolverDefId<'db> {
+            #[inline]
+            fn from(value: $name<'db>) -> SolverDefId<'db> {
+                value.0.into()
+            }
+        }
 
-    #[inline]
-    fn try_from(value: SolverDefId<'db>) -> Result<Self, Self::Error> {
-        match value {
-            SolverDefId::InternedCoroutineClosureId(it) => Ok(Self(it)),
-            _ => Err(()),
+        impl<'db> inherent::DefId<DbInterner<'db>, $local> for $name<'db> {
+            fn as_local(self) -> Option<$local> {
+                Some(self.into())
+            }
+            fn is_local(self) -> bool {
+                true
+            }
         }
-    }
+    };
 }
 
-impl<'db> inherent::DefId<DbInterner<'db>, SolverDefId<'db>> for CoroutineClosureIdWrapper<'db> {
-    fn as_local(self) -> Option<SolverDefId<'db>> {
-        Some(self.into())
-    }
-    fn is_local(self) -> bool {
-        true
-    }
-}
+declare_id_wrapper!(TraitIdWrapper, TraitId);
+declare_id_wrapper!(TypeAliasIdWrapper, TypeAliasId);
+declare_id_wrapper_with_lt!(ClosureIdWrapper, InternedClosureId);
+declare_id_wrapper_with_lt!(CoroutineIdWrapper, InternedCoroutineId);
+declare_id_wrapper_with_lt!(CoroutineClosureIdWrapper, InternedCoroutineClosureId);
 declare_id_wrapper!(AdtIdWrapper, AdtId);
-declare_id_wrapper!(OpaqueTyIdWrapper, InternedOpaqueTyId, OpaqueTyIdWrapper);
+declare_id_wrapper_with_lt!(OpaqueTyIdWrapper, InternedOpaqueTyId, OpaqueTyIdWrapper<'db>);
 
 macro_rules! declare_ty_const_pair {
     ( $ty_id_name:ident, $const_id_name:ident, $term_id_name:ident ) => {

crates/hir-ty/src/next_solver/infer/select.rs

@@ -40,7 +40,7 @@ pub enum SelectionError<'db> {
     /// Computing an opaque type's hidden type caused an error (e.g. a cycle error).
     /// We can thus not know whether the hidden type implements an auto trait, so
     /// we should not presume anything about it.
-    OpaqueTypeAutoTraitLeakageUnknown(InternedOpaqueTyId),
+    OpaqueTypeAutoTraitLeakageUnknown(InternedOpaqueTyId<'db>),
     /// Error for a `ConstArgHasType` goal
     ConstArgHasWrongType { ct: Const<'db>, ct_ty: Ty<'db>, expected_ty: Ty<'db> },
 }

crates/hir-ty/src/next_solver/interner.rs

@@ -894,8 +894,8 @@ impl<'db> Interner for DbInterner<'db> {
     type TraitAssocTyId = TraitAssocTyId;
     type TraitAssocConstId = TraitAssocConstId;
     type TraitAssocTermId = TraitAssocTermId;
-    type OpaqueTyId = OpaqueTyIdWrapper;
-    type LocalOpaqueTyId = OpaqueTyIdWrapper;
+    type OpaqueTyId = OpaqueTyIdWrapper<'db>;
+    type LocalOpaqueTyId = OpaqueTyIdWrapper<'db>;
     type FreeTyAliasId = FreeTyAliasId;
     type FreeConstAliasId = FreeConstAliasId;
     type FreeTermAliasId = FreeTermAliasId;
@@ -2345,7 +2345,7 @@ TrivialTypeTraversalImpls! {
     InherentAssocTyId,
     InherentAssocConstId,
     InherentAssocTermId,
-    OpaqueTyIdWrapper,
+    OpaqueTyIdWrapper<'_>,
     AnyImplId,
     GeneralConstIdWrapper<'_>,
     Safety,

crates/hir-ty/src/next_solver/solver.rs

@@ -130,7 +130,7 @@ impl<'db> SolverDelegate for SolverContext<'db> {
 
     fn add_item_bounds_for_hidden_type(
         &self,
-        opaque_id: OpaqueTyIdWrapper,
+        opaque_id: OpaqueTyIdWrapper<'_>,
         args: GenericArgs<'db>,
         param_env: ParamEnv<'db>,
         hidden_ty: Ty<'db>,

crates/hir-ty/src/next_solver/ty.rs

@@ -176,7 +176,7 @@ impl<'db> Ty<'db> {
 
     pub fn new_opaque(
         interner: DbInterner<'db>,
-        def_id: InternedOpaqueTyId,
+        def_id: InternedOpaqueTyId<'db>,
         args: GenericArgs<'db>,
     ) -> Self {
         Ty::new_alias(

crates/hir-ty/src/opaques.rs

@@ -20,10 +20,10 @@ use crate::{
     },
 };
 
-pub(crate) fn opaque_types_defined_by(
-    db: &dyn HirDatabase,
+pub(crate) fn opaque_types_defined_by<'db>(
+    db: &'db dyn HirDatabase,
     def_id: InferBodyId<'_>,
-    result: &mut Vec<SolverDefId<'_>>,
+    result: &mut Vec<SolverDefId<'db>>,
 ) {
     if let Some(func) = def_id.as_function() {
         // A function may define its own RPITs.
@@ -79,11 +79,11 @@ pub(crate) fn opaque_types_defined_by(
 
     // FIXME: Collect opaques from `#[define_opaque]`.
 
-    fn extend_with_opaques(
-        db: &dyn HirDatabase,
+    fn extend_with_opaques<'db>(
+        db: &'db dyn HirDatabase,
         opaques: &Option<Box<StoredEarlyBinder<ImplTraits>>>,
         mut make_impl_trait: impl FnMut(ImplTraitIdx) -> ImplTraitId,
-        result: &mut Vec<SolverDefId<'_>>,
+        result: &mut Vec<SolverDefId<'db>>,
     ) {
         if let Some(opaques) = opaques {
             for (opaque_idx, _) in (**opaques).as_ref().skip_binder().impl_traits.iter() {