[WIP]

Author: fmease

compiler/rustc_hir_analysis/src/collect.rs

@@ -33,8 +33,7 @@ use rustc_infer::traits::{DynCompatibilityViolation, ObligationCause};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::typeck_results::{
-    HasTypeDependentDefs, LocalTableInContext, LocalTableInContextMut, TypeDependentDef,
-    TypeDependentDefs,
+    HasTypeDependentDefs, LocalTableInContext, LocalTableInContextMut, TypeDependentDefs,
 };
 use rustc_middle::ty::util::{Discr, IntTypeExt};
 use rustc_middle::ty::{
@@ -547,12 +546,12 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         // There's no place to record types from signatures?
     }
 
-    fn record_res(&self, hir_id: hir::HirId, result: TypeDependentDef) {
+    fn record_res(&self, hir_id: hir::HirId, def_id: DefId) {
         LocalTableInContextMut::new(
             self.hir_id().owner,
             &mut self.type_dependent_defs.borrow_mut(),
         )
-        .insert(hir_id, result);
+        .insert(hir_id, Ok((self.tcx.def_kind(def_id), def_id)));
     }
 
     fn infcx(&self) -> Option<&InferCtxt<'tcx>> {

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -2121,6 +2121,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                     matches!(args.parenthesized, hir::GenericArgsParentheses::ReturnTypeNotation)
                 }) =>
             {
+                // FIXME(fmease): No longer true.
                 // First, ignore a qself that isn't a type or `Self` param. Those are the
                 // only ones that support `T::Assoc` anyways in HIR lowering.
                 let hir::TyKind::Path(hir::QPath::Resolved(None, path)) = qself.kind else {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -36,7 +36,7 @@ use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::DynCompatibilityViolation;
 use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::middle::stability::AllowUnstable;
-use rustc_middle::ty::typeck_results::{HasTypeDependentDefs, TypeDependentDef};
+use rustc_middle::ty::typeck_results::HasTypeDependentDefs;
 use rustc_middle::ty::{
     self, Const, FnSigKind, GenericArgKind, GenericArgsRef, GenericParamDefKind, LitToConstInput,
     Ty, TyCtxt, TypeSuperFoldable, TypeVisitableExt, TypingMode, Unnormalized, Upcast,
@@ -220,7 +220,7 @@ pub trait HirTyLowerer<'tcx>: HasTypeDependentDefs {
     fn record_ty(&self, hir_id: HirId, ty: Ty<'tcx>, span: Span);
 
     /// Record the resolution of a HIR node corresponding to a type-dependent definition in this context.
-    fn record_res(&self, hir_id: hir::HirId, result: TypeDependentDef);
+    fn record_res(&self, hir_id: hir::HirId, result: DefId);
 
     /// The inference context of the lowering context if applicable.
     fn infcx(&self) -> Option<&InferCtxt<'tcx>>;
@@ -1320,28 +1320,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// Lower a [type-relative](hir::QPath::TypeRelative) path in type position to a type.
     ///
     /// If the path refers to an enum variant and `permit_variants` holds,
-    /// the returned type is simply the provided self type `qself_ty`.
+    /// the returned type is simply the provided self type `self_ty`.
     ///
-    /// A path like `A::B::C::D` is understood as `<A::B::C>::D`. I.e.,
-    /// `qself_ty` / `qself` is `A::B::C` and `assoc_segment` is `D`.
-    /// We return the lowered type and the `DefId` for the whole path.
-    ///
-    /// We only support associated type paths whose self type is a type parameter or a `Self`
-    /// type alias (in a trait impl) like `T::Ty` (where `T` is a ty param) or `Self::Ty`.
-    /// We **don't** support paths whose self type is an arbitrary type like `Struct::Ty` where
-    /// struct `Struct` impls an in-scope trait that defines an associated type called `Ty`.
-    /// For the latter case, we report ambiguity.
-    /// While desirable to support, the implementation would be non-trivial. Tracked in [#22519].
-    ///
-    /// At the time of writing, *inherent associated types* are also resolved here. This however
-    /// is [problematic][iat]. A proper implementation would be as non-trivial as the one
-    /// described in the previous paragraph and their modeling of projections would likely be
-    /// very similar in nature.
-    ///
-    /// [#22519]: https://github.com/rust-lang/rust/issues/22519
-    /// [iat]: https://github.com/rust-lang/rust/issues/8995#issuecomment-1569208403
-    // FIXME(fmease): Update docs
-    //
     // NOTE: When this function starts resolving `Trait::AssocTy` successfully
     // it should also start reporting the `BARE_TRAIT_OBJECTS` lint.
     #[instrument(level = "debug", skip_all, ret)]
@@ -1353,7 +1333,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         qpath_hir_id: HirId,
         span: Span,
         permit_variants: PermitVariants,
-    ) -> Result<(Ty<'tcx>, DefKind, DefId), ErrorGuaranteed> {
+    ) -> Result<(Ty<'tcx>, DefId), ErrorGuaranteed> {
         let tcx = self.tcx();
         match self.lower_type_relative_path(
             self_ty,
@@ -1371,13 +1351,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
                 let ty = Ty::new_alias(tcx, alias_ty);
                 let ty = self.check_param_uses_if_mcg(ty, span, false);
-                let kind = tcx.def_kind(def_id);
-                self.record_res(qpath_hir_id, Ok((kind, def_id)));
-                Ok((ty, kind, def_id))
+                Ok((ty, def_id))
             }
             TypeRelativePath::Variant { adt, variant_did } => {
                 let adt = self.check_param_uses_if_mcg(adt, span, false);
-                Ok((adt, DefKind::Variant, variant_did))
+                Ok((adt, variant_did))
             }
             TypeRelativePath::Ctor { .. } => {
                 let e = tcx.dcx().span_err(span, "expected type, found tuple constructor");
@@ -1436,6 +1414,27 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     }
 
     /// Lower a [type-relative][hir::QPath::TypeRelative] (and type-level) path.
+    ///
+    /// A path like `A::B::C::D` is understood as `<A::B::C>::D`. I.e., the self type is `A::B::C`
+    /// and the `segment` is `D`.
+    ///
+    /// <!-- FIXME(fmease): No longer accurate -->
+    ///
+    /// We only support associated item paths whose self type is a type parameter or a `Self`
+    /// type alias (in a trait impl) like `T::Ty` (where `T` is a ty param) or `Self::Ty`.
+    /// We **don't** support paths whose self type is an arbitrary type like `Struct::Ty` where
+    /// struct `Struct` impls an in-scope trait that defines an associated type called `Ty`.
+    /// For the latter case, we report ambiguity.
+    /// While desirable to support, the implementation would be non-trivial. Tracked in [#22519].
+    ///
+    /// <!-- FIXME(fmease): Slightly outdated, too -->
+    ///
+    /// At the time of writing, *inherent associated types* are also resolved here. This however
+    /// is problematic. A proper implementation would be as non-trivial as the one
+    /// described in the previous paragraph and their modeling of projections would likely be
+    /// very similar in nature.
+    ///
+    /// [#22519]: https://github.com/rust-lang/rust/issues/22519
     #[instrument(level = "debug", skip_all, ret)]
     fn lower_type_relative_path(
         &self,
@@ -1485,6 +1484,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                 adt_def,
                             },
                         );
+                        self.record_res(qpath_hir_id, variant_def.def_id);
                         return Ok(TypeRelativePath::Variant {
                             adt: self_ty,
                             variant_did: variant_def.def_id,
@@ -1496,15 +1496,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
 
             // FIXME(inherent_associated_types, #106719): Support self types other than ADTs.
-            if let Some((did, args)) = self.probe_inherent_assoc_item(
+            if let Some((def_id, args)) = self.probe_inherent_assoc_item(
                 segment,
                 adt_def.did(),
                 self_ty,
                 qpath_hir_id,
                 span,
                 mode.assoc_tag(),
             )? {
-                return Ok(TypeRelativePath::AssocItem(did, args));
+                self.record_res(qpath_hir_id, def_id);
+                return Ok(TypeRelativePath::AssocItem(def_id, args));
             }
         }
 
@@ -1633,6 +1634,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             .probe_assoc_item(segment.ident, assoc_tag, qpath_hir_id, span, bound.def_id())
             .expect("failed to find associated item");
 
+        self.record_res(qpath_hir_id, assoc_item.def_id);
+
         Ok((assoc_item.def_id, bound))
     }
 
@@ -2700,12 +2703,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     path_span,
                     PermitVariants::Yes,
                 );
-                let ty = result
-                    .map(|(ty, _, _)| ty)
-                    .unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar));
+                let ty =
+                    result.map(|(ty, _)| ty).unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar));
 
                 ResolvedStructPath {
-                    res: result.map(|(_, kind, def_id)| Res::Def(kind, def_id)),
+                    res: result.map(|(_, def_id)| Res::Def(self.tcx().def_kind(def_id), def_id)),
                     ty,
                 }
             }
@@ -3210,7 +3212,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     hir_ty.span,
                     PermitVariants::No,
                 )
-                .map(|(ty, _, _)| ty)
+                .map(|(ty, _)| ty)
                 .unwrap_or_else(|guar| Ty::new_error(tcx, guar))
             }
             hir::TyKind::Array(ty, length) => {

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -18,7 +18,7 @@ use rustc_hir_analysis::hir_ty_lowering::{
 };
 use rustc_infer::infer::{self, RegionVariableOrigin};
 use rustc_infer::traits::{DynCompatibilityViolation, Obligation};
-use rustc_middle::ty::typeck_results::{HasTypeDependentDefs, TypeDependentDef};
+use rustc_middle::ty::typeck_results::HasTypeDependentDefs;
 use rustc_middle::ty::{
     self, CantBeErased, Const, Flags, Ty, TyCtxt, TypeVisitableExt, TypingMode, Unnormalized,
 };
@@ -450,8 +450,8 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         self.write_ty(hir_id, ty)
     }
 
-    fn record_res(&self, hir_id: HirId, result: TypeDependentDef) {
-        self.write_resolution(hir_id, result);
+    fn record_res(&self, hir_id: HirId, def_id: DefId) {
+        self.write_resolution(hir_id, Ok((self.tcx.def_kind(def_id), def_id)));
     }
 
     fn infcx(&self) -> Option<&infer::InferCtxt<'tcx>> {

tests/ui/associated-type-bounds/return-type-notation/consecutive-type-relative-path.rs

@@ -0,0 +1,16 @@
+// FIXME(fmease): Description.
+//@ check-pass
+
+#![feature(return_type_notation)]
+
+trait TraitA { type Assoc: TraitB; }
+trait TraitB { fn assoc() -> impl Sized; }
+
+fn scope<T: TraitA>()
+where
+    T::Assoc::assoc(..): Iterator<Item = u8>,
+{
+    let _: Vec<u8> = T::Assoc::assoc().collect();
+}
+
+fn main() {}

tests/ui/const-generics/mgca/consecutive-type-relative-path.rs

@@ -0,0 +1,14 @@
+// FIXME(fmease): Description.
+//@ check-pass
+
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+trait TraitA { type Assoc: TraitB; }
+trait TraitB { #[type_const] const ASSOC: usize; }
+
+fn scope<T: TraitA>() -> [u8; T::Assoc::ASSOC] {
+    [0; T::Assoc::ASSOC]
+}
+
+fn main() {}