Introduce a new kind of associated types, RPITIT associated types

They don't exist in hir-def, only hir-ty. The idea is that the trait/impl datum query will compute and intern them, then other queries can treat them as (partially) normal associated types.

(Lowering RPITIT to synthesized associated types, like rustc does, is required to properly support Return Type Notation).

Author: ChayimFriedman2

crates/base-db/src/lib.rs

@@ -24,6 +24,7 @@ use syntax::{Parse, SyntaxError, ast};
 use triomphe::Arc;
 pub use vfs::{AnchoredPath, AnchoredPathBuf, FileId, VfsPath, file_set::FileSet};
 
+/// Prefer to use `impl_intern_key_ref!()`, which will not clone the value.
 #[macro_export]
 macro_rules! impl_intern_key {
     ($id:ident, $loc:ident) => {
@@ -43,6 +44,26 @@ macro_rules! impl_intern_key {
     };
 }
 
+#[macro_export]
+macro_rules! impl_intern_key_ref {
+    ($id:ident, $loc:ident) => {
+        #[salsa::interned(no_debug, no_lifetime)]
+        pub struct $id {
+            #[return_ref]
+            pub loc: $loc,
+        }
+
+        // If we derive this salsa prints the values recursively, and this causes us to blow.
+        impl ::std::fmt::Debug for $id {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                f.debug_tuple(stringify!($id))
+                    .field(&format_args!("{:04x}", self.0.as_u32()))
+                    .finish()
+            }
+        }
+    };
+}
+
 pub trait Upcast<T: ?Sized> {
     fn upcast(&self) -> &T;
 }

crates/hir-ty/src/chalk_db.rs

@@ -9,7 +9,7 @@ use span::Edition;
 use tracing::debug;
 
 use chalk_ir::{CanonicalVarKinds, cast::Caster, fold::shift::Shift};
-use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
+use chalk_solve::rust_ir::{self, AssociatedTyDatumBound, OpaqueTyDatumBound, WellKnownTrait};
 
 use base_db::Crate;
 use hir_def::{
@@ -28,7 +28,10 @@ use crate::{
     from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
     generics::generics,
     make_binders, make_single_type_binders,
-    mapping::{ToChalk, TypeAliasAsValue, from_chalk},
+    mapping::{
+        AnyImplAssocType, AnyTraitAssocType, ToChalk, from_assoc_type_value_id, from_chalk,
+        to_assoc_type_id_rpitit, to_assoc_type_value_id,
+    },
     method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TraitImpls, TyFingerprint},
     to_assoc_type_id, to_chalk_trait_id,
     traits::ChalkContext,
@@ -448,8 +451,7 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
         Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false))
     }
     fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
-        let id = self.db.associated_ty_data(assoc_ty_id).name;
-        self.db.type_alias_data(id).name.display(self.db.upcast(), self.edition()).to_string()
+        self.db.associated_ty_data(assoc_ty_id).name.as_str().to_owned()
     }
     fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
         format!("Opaque_{:?}", opaque_ty_id.0)
@@ -606,7 +608,23 @@ pub(crate) fn associated_ty_data_query(
     id: AssocTypeId,
 ) -> Arc<AssociatedTyDatum> {
     debug!("associated_ty_data {:?}", id);
-    let type_alias: TypeAliasId = from_assoc_type_id(id);
+
+    let type_alias = match from_assoc_type_id(db, id) {
+        AnyTraitAssocType::Normal(type_alias) => type_alias,
+        AnyTraitAssocType::Rpitit(assoc_type_id) => {
+            let assoc_type = assoc_type_id.loc(db);
+            return Arc::new(AssociatedTyDatum {
+                id,
+                trait_id: to_chalk_trait_id(assoc_type.trait_id),
+                name: sym::consts::synthesized_rpitit_assoc,
+                binders: assoc_type
+                    .bounds
+                    .clone()
+                    .map(|bounds| AssociatedTyDatumBound { bounds, where_clauses: Vec::new() }),
+            });
+        }
+    };
+
     let trait_ = match type_alias.lookup(db.upcast()).container {
         ItemContainerId::TraitId(t) => t,
         _ => panic!("associated type not in trait"),
@@ -658,7 +676,7 @@ pub(crate) fn associated_ty_data_query(
     let datum = AssociatedTyDatum {
         trait_id: to_chalk_trait_id(trait_),
         id,
-        name: type_alias,
+        name: type_alias_data.name.symbol().clone(),
         binders: make_binders(db, &generic_params, bound_data),
     };
     Arc::new(datum)
@@ -872,7 +890,7 @@ fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId)
             let name = &db.type_alias_data(type_alias).name;
             trait_data.associated_type_by_name(name).is_some()
         })
-        .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
+        .map(|type_alias| to_assoc_type_value_id(type_alias))
         .collect();
     debug!("impl_datum: {:?}", impl_datum_bound);
     let impl_datum = ImplDatum {
@@ -889,8 +907,19 @@ pub(crate) fn associated_ty_value_query(
     krate: Crate,
     id: AssociatedTyValueId,
 ) -> Arc<AssociatedTyValue> {
-    let type_alias: TypeAliasAsValue = from_chalk(db, id);
-    type_alias_associated_ty_value(db, krate, type_alias.0)
+    match from_assoc_type_value_id(db, id) {
+        AnyImplAssocType::Normal(type_alias) => {
+            type_alias_associated_ty_value(db, krate, type_alias)
+        }
+        AnyImplAssocType::Rpitit(assoc_type_id) => {
+            let assoc_type = assoc_type_id.loc(db);
+            Arc::new(AssociatedTyValue {
+                impl_id: assoc_type.impl_id.to_chalk(db),
+                associated_ty_id: to_assoc_type_id_rpitit(assoc_type.trait_assoc),
+                value: assoc_type.value.clone(),
+            })
+        }
+    }
 }
 
 fn type_alias_associated_ty_value(
@@ -1025,8 +1054,16 @@ pub(super) fn generic_predicate_to_inline_bound(
             Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
         }
         WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            let generics =
-                generics(db.upcast(), from_assoc_type_id(projection_ty.associated_ty_id).into());
+            let generic_def = match from_assoc_type_id(db, projection_ty.associated_ty_id) {
+                AnyTraitAssocType::Normal(type_alias) => type_alias.into(),
+                AnyTraitAssocType::Rpitit(_) => {
+                    unreachable!(
+                        "there is no way to refer to a RPITIT synthesized \
+                        associated type on associated type's self bounds (`type Assoc: Bound`)"
+                    )
+                }
+            };
+            let generics = generics(db.upcast(), generic_def);
             let (assoc_args, trait_args) =
                 projection_ty.substitution.as_slice(Interner).split_at(generics.len_self());
             let (self_ty, args_no_self) =

crates/hir-ty/src/chalk_ext.rs

@@ -4,19 +4,19 @@ use chalk_ir::{
     FloatTy, IntTy, Mutability, Scalar, TyVariableKind, TypeOutlives, UintTy, cast::Cast,
 };
 use hir_def::{
-    DefWithBodyId, FunctionId, GenericDefId, HasModule, ItemContainerId, Lookup, TraitId,
+    DefWithBodyId, FunctionId, HasModule, ItemContainerId, Lookup, TraitId,
     builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType, BuiltinUint},
     generics::TypeOrConstParamData,
     lang_item::LangItem,
     type_ref::Rawness,
 };
 
 use crate::{
-    AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Canonical, CanonicalVarKinds,
-    ClosureId, DynTy, FnPointer, ImplTraitId, InEnvironment, Interner, Lifetime, ProjectionTy,
-    QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeFlags, WhereClause,
-    db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
-    from_placeholder_idx, generics::generics, to_chalk_trait_id, utils::ClosureSubst,
+    AdtId, AliasEq, AliasTy, AssocTypeId, Binders, CallableDefId, CallableSig, Canonical,
+    CanonicalVarKinds, ClosureId, DynTy, FnPointer, ImplTraitId, InEnvironment, Interner, Lifetime,
+    ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeFlags,
+    WhereClause, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,
+    generics::generics, mapping::AnyTraitAssocType, to_chalk_trait_id, utils::ClosureSubst,
 };
 
 pub trait TyExt {
@@ -39,7 +39,6 @@ pub trait TyExt {
     fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>;
     fn as_raw_ptr(&self) -> Option<(&Ty, Mutability)>;
     fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)>;
-    fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId>;
 
     fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId>;
     fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig>;
@@ -187,19 +186,6 @@ impl TyExt for Ty {
         }
     }
 
-    fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> {
-        match *self.kind(Interner) {
-            TyKind::Adt(AdtId(adt), ..) => Some(adt.into()),
-            TyKind::FnDef(callable, ..) => Some(GenericDefId::from_callable(
-                db.upcast(),
-                db.lookup_intern_callable_def(callable.into()),
-            )),
-            TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()),
-            TyKind::Foreign(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()),
-            _ => None,
-        }
-    }
-
     fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> {
         match self.kind(Interner) {
             &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())),
@@ -348,20 +334,9 @@ impl TyExt for Ty {
 
     fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
         match self.kind(Interner) {
-            TyKind::AssociatedType(id, ..) => {
-                match from_assoc_type_id(*id).lookup(db.upcast()).container {
-                    ItemContainerId::TraitId(trait_id) => Some(trait_id),
-                    _ => None,
-                }
-            }
+            TyKind::AssociatedType(id, ..) => Some(assoc_type_parent_trait(db, *id)),
             TyKind::Alias(AliasTy::Projection(projection_ty)) => {
-                match from_assoc_type_id(projection_ty.associated_ty_id)
-                    .lookup(db.upcast())
-                    .container
-                {
-                    ItemContainerId::TraitId(trait_id) => Some(trait_id),
-                    _ => None,
-                }
+                Some(assoc_type_parent_trait(db, projection_ty.associated_ty_id))
             }
             _ => None,
         }
@@ -413,6 +388,16 @@ impl TyExt for Ty {
     }
 }
 
+fn assoc_type_parent_trait(db: &dyn HirDatabase, id: AssocTypeId) -> TraitId {
+    match from_assoc_type_id(db, id) {
+        AnyTraitAssocType::Normal(type_alias) => match type_alias.lookup(db.upcast()).container {
+            ItemContainerId::TraitId(trait_id) => trait_id,
+            _ => panic!("`AssocTypeId` without parent trait"),
+        },
+        AnyTraitAssocType::Rpitit(assoc_type) => assoc_type.loc(db).trait_id,
+    }
+}
+
 pub trait ProjectionTyExt {
     fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef;
     fn trait_(&self, db: &dyn HirDatabase) -> TraitId;
@@ -422,7 +407,15 @@ pub trait ProjectionTyExt {
 impl ProjectionTyExt for ProjectionTy {
     fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef {
         // FIXME: something like `Split` trait from chalk-solve might be nice.
-        let generics = generics(db.upcast(), from_assoc_type_id(self.associated_ty_id).into());
+        let generic_def = match from_assoc_type_id(db, self.associated_ty_id) {
+            AnyTraitAssocType::Normal(type_alias) => type_alias.into(),
+            // FIXME: This isn't entirely correct, the generics of the RPITIT assoc type may differ from its method
+            // wrt. lifetimes, but we don't handle that currently. See https://rustc-dev-guide.rust-lang.org/return-position-impl-trait-in-trait.html.
+            AnyTraitAssocType::Rpitit(assoc_type) => {
+                assoc_type.loc(db).synthesized_from_method.into()
+            }
+        };
+        let generics = generics(db.upcast(), generic_def);
         let substitution = Substitution::from_iter(
             Interner,
             self.substitution.iter(Interner).skip(generics.len_self()),
@@ -431,10 +424,7 @@ impl ProjectionTyExt for ProjectionTy {
     }
 
     fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
-        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
-            ItemContainerId::TraitId(it) => it,
-            _ => panic!("projection ty without parent trait"),
-        }
+        assoc_type_parent_trait(db, self.associated_ty_id)
     }
 
     fn self_type_parameter(&self, db: &dyn HirDatabase) -> Ty {

crates/hir-ty/src/db.rs

@@ -3,7 +3,7 @@
 
 use std::sync;
 
-use base_db::{Crate, Upcast, impl_intern_key};
+use base_db::{Crate, Upcast, impl_intern_key, impl_intern_key_ref};
 use hir_def::{
     AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
     GeneralConstId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId,
@@ -337,3 +337,35 @@ impl_intern_key!(InternedCoroutineId, InternedCoroutine);
 // This exists just for Chalk, because Chalk just has a single `FnDefId` where
 // we have different IDs for struct and enum variant constructors.
 impl_intern_key!(InternedCallableDefId, CallableDefId);
+
+/// An associated type synthesized from a Return Position Impl Trait In Trait
+/// of the trait (not the impls).
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RpititTraitAssocTy {
+    pub trait_id: TraitId,
+    /// The method that contains this RPITIT.
+    pub synthesized_from_method: FunctionId,
+    /// The bounds of this associated type (coming from the `impl Bounds`).
+    ///
+    /// The generics are the generics of the method (with some modifications that we
+    /// don't currently implement, see https://rustc-dev-guide.rust-lang.org/return-position-impl-trait-in-trait.html).
+    pub bounds: Binders<Vec<chalk_solve::rust_ir::QuantifiedInlineBound<Interner>>>,
+}
+
+impl_intern_key_ref!(RpititTraitAssocTyId, RpititTraitAssocTy);
+
+/// An associated type synthesized from a Return Position Impl Trait In Trait
+/// of the impl (not the trait).
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RpititImplAssocTy {
+    pub impl_id: ImplId,
+    /// The definition of this associated type in the trait.
+    pub trait_assoc: RpititTraitAssocTyId,
+    /// The bounds of this associated type (coming from the `impl Bounds`).
+    ///
+    /// The generics are the generics of the method (with some modifications that we
+    /// don't currently implement, see https://rustc-dev-guide.rust-lang.org/return-position-impl-trait-in-trait.html).
+    pub value: Binders<chalk_solve::rust_ir::AssociatedTyValueBound<Interner>>,
+}
+
+impl_intern_key_ref!(RpititImplAssocTyId, RpititImplAssocTy);