Factor out shared code for lowering assoc item paths

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -46,6 +46,7 @@ use tracing::{debug, instrument};
 
 use crate::check::intrinsic::intrinsic_operation_unsafety;
 use crate::errors;
+use crate::hir_ty_lowering::errors::assoc_kind_str;
 use crate::hir_ty_lowering::{FeedConstTy, HirTyLowerer, RegionInferReason};
 
 pub(crate) mod dump;
@@ -468,84 +469,15 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         item_segment: &hir::PathSegment<'tcx>,
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Ty<'tcx> {
-        if let Some(trait_ref) = poly_trait_ref.no_bound_vars() {
-            let item_args = self.lowerer().lower_generic_args_of_assoc_item(
-                span,
-                item_def_id,
-                item_segment,
-                trait_ref.args,
-            );
-            Ty::new_projection_from_args(self.tcx(), item_def_id, item_args)
-        } else {
-            // There are no late-bound regions; we can just ignore the binder.
-            let (mut mpart_sugg, mut inferred_sugg) = (None, None);
-            let mut bound = String::new();
-
-            match self.node() {
-                hir::Node::Field(_) | hir::Node::Ctor(_) | hir::Node::Variant(_) => {
-                    let item = self
-                        .tcx
-                        .hir()
-                        .expect_item(self.tcx.hir().get_parent_item(self.hir_id()).def_id);
-                    match &item.kind {
-                        hir::ItemKind::Enum(_, generics)
-                        | hir::ItemKind::Struct(_, generics)
-                        | hir::ItemKind::Union(_, generics) => {
-                            let lt_name = get_new_lifetime_name(self.tcx, poly_trait_ref, generics);
-                            let (lt_sp, sugg) = match generics.params {
-                                [] => (generics.span, format!("<{lt_name}>")),
-                                [bound, ..] => (bound.span.shrink_to_lo(), format!("{lt_name}, ")),
-                            };
-                            mpart_sugg = Some(errors::AssociatedItemTraitUninferredGenericParamsMultipartSuggestion {
-                                fspan: lt_sp,
-                                first: sugg,
-                                sspan: span.with_hi(item_segment.ident.span.lo()),
-                                second: format!(
-                                    "{}::",
-                                    // Replace the existing lifetimes with a new named lifetime.
-                                    self.tcx.instantiate_bound_regions_uncached(
-                                        poly_trait_ref,
-                                        |_| {
-                                            ty::Region::new_early_param(self.tcx, ty::EarlyParamRegion {
-                                                index: 0,
-                                                name: Symbol::intern(&lt_name),
-                                            })
-                                        }
-                                    ),
-                                ),
-                            });
-                        }
-                        _ => {}
-                    }
-                }
-                hir::Node::Item(hir::Item {
-                    kind:
-                        hir::ItemKind::Struct(..) | hir::ItemKind::Enum(..) | hir::ItemKind::Union(..),
-                    ..
-                }) => {}
-                hir::Node::Item(_)
-                | hir::Node::ForeignItem(_)
-                | hir::Node::TraitItem(_)
-                | hir::Node::ImplItem(_) => {
-                    inferred_sugg = Some(span.with_hi(item_segment.ident.span.lo()));
-                    bound = format!(
-                        "{}::",
-                        // Erase named lt, we want `<A as B<'_>::C`, not `<A as B<'a>::C`.
-                        self.tcx.anonymize_bound_vars(poly_trait_ref).skip_binder(),
-                    );
-                }
-                _ => {}
-            }
-            Ty::new_error(
-                self.tcx(),
-                self.tcx().dcx().emit_err(errors::AssociatedItemTraitUninferredGenericParams {
-                    span,
-                    inferred_sugg,
-                    bound,
-                    mpart_sugg,
-                    what: "type",
-                }),
-            )
+        match self.lower_assoc_shared(
+            span,
+            item_def_id,
+            item_segment,
+            poly_trait_ref,
+            ty::AssocKind::Type,
+        ) {
+            Ok((def_id, args)) => Ty::new_projection_from_args(self.tcx(), def_id, args),
+            Err(witness) => Ty::new_error(self.tcx(), witness),
         }
     }
 
@@ -556,15 +488,37 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         item_segment: &hir::PathSegment<'tcx>,
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Const<'tcx> {
+        match self.lower_assoc_shared(
+            span,
+            item_def_id,
+            item_segment,
+            poly_trait_ref,
+            ty::AssocKind::Const,
+        ) {
+            Ok((def_id, args)) => {
+                let uv = ty::UnevaluatedConst::new(def_id, args);
+                Const::new_unevaluated(self.tcx(), uv)
+            }
+            Err(witness) => Const::new_error(self.tcx(), witness),
+        }
+    }
+
+    fn lower_assoc_shared(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &rustc_hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+        kind: ty::AssocKind,
+    ) -> Result<(DefId, ty::GenericArgsRef<'tcx>), ErrorGuaranteed> {
         if let Some(trait_ref) = poly_trait_ref.no_bound_vars() {
             let item_args = self.lowerer().lower_generic_args_of_assoc_item(
                 span,
                 item_def_id,
                 item_segment,
                 trait_ref.args,
             );
-            let uv = ty::UnevaluatedConst::new(item_def_id, item_args);
-            Const::new_unevaluated(self.tcx(), uv)
+            Ok((item_def_id, item_args))
         } else {
             // There are no late-bound regions; we can just ignore the binder.
             let (mut mpart_sugg, mut inferred_sugg) = (None, None);
@@ -625,16 +579,14 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
                 }
                 _ => {}
             }
-            Const::new_error(
-                self.tcx(),
-                self.tcx().dcx().emit_err(errors::AssociatedItemTraitUninferredGenericParams {
-                    span,
-                    inferred_sugg,
-                    bound,
-                    mpart_sugg,
-                    what: "const",
-                }),
-            )
+
+            Err(self.tcx().dcx().emit_err(errors::AssociatedItemTraitUninferredGenericParams {
+                span,
+                inferred_sugg,
+                bound,
+                mpart_sugg,
+                what: assoc_kind_str(kind),
+            }))
         }
     }
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -1608,7 +1608,7 @@ fn generics_args_err_extend<'a>(
     }
 }
 
-pub(super) fn assoc_kind_str(kind: ty::AssocKind) -> &'static str {
+pub(crate) fn assoc_kind_str(kind: ty::AssocKind) -> &'static str {
     match kind {
         ty::AssocKind::Fn => "function",
         ty::AssocKind::Const => "constant",

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -179,6 +179,18 @@ pub trait HirTyLowerer<'tcx> {
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Const<'tcx>;
 
+    /// Helper function; use [`Self::lower_assoc_ty`] or [`Self::lower_assoc_const`] instead.
+    ///
+    /// The logic for lowering associated items that is the same between types and consts.
+    fn lower_assoc_shared(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+        kind: ty::AssocKind,
+    ) -> Result<(DefId, GenericArgsRef<'tcx>), ErrorGuaranteed>;
+
     fn lower_fn_sig(
         &self,
         decl: &hir::FnDecl<'tcx>,

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -17,7 +17,7 @@ use rustc_infer::infer;
 use rustc_infer::traits::Obligation;
 use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::Session;
-use rustc_span::{self, DUMMY_SP, Ident, Span, sym};
+use rustc_span::{self, DUMMY_SP, ErrorGuaranteed, Ident, Span, sym};
 use rustc_trait_selection::error_reporting::TypeErrCtxt;
 use rustc_trait_selection::error_reporting::infer::sub_relations::SubRelations;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode, ObligationCtxt};
@@ -315,20 +315,16 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         item_segment: &hir::PathSegment<'tcx>,
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Ty<'tcx> {
-        let trait_ref = self.instantiate_binder_with_fresh_vars(
-            span,
-            infer::BoundRegionConversionTime::AssocTypeProjection(item_def_id),
-            poly_trait_ref,
-        );
-
-        let item_args = self.lowerer().lower_generic_args_of_assoc_item(
+        match self.lower_assoc_shared(
             span,
             item_def_id,
             item_segment,
-            trait_ref.args,
-        );
-
-        Ty::new_projection_from_args(self.tcx(), item_def_id, item_args)
+            poly_trait_ref,
+            ty::AssocKind::Type,
+        ) {
+            Ok((def_id, args)) => Ty::new_projection_from_args(self.tcx(), def_id, args),
+            Err(witness) => Ty::new_error(self.tcx(), witness),
+        }
     }
 
     fn lower_assoc_const(
@@ -338,9 +334,32 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         item_segment: &hir::PathSegment<'tcx>,
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Const<'tcx> {
+        match self.lower_assoc_shared(
+            span,
+            item_def_id,
+            item_segment,
+            poly_trait_ref,
+            ty::AssocKind::Const,
+        ) {
+            Ok((def_id, args)) => {
+                let uv = ty::UnevaluatedConst::new(def_id, args);
+                Const::new_unevaluated(self.tcx(), uv)
+            }
+            Err(witness) => Const::new_error(self.tcx(), witness),
+        }
+    }
+
+    fn lower_assoc_shared(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &rustc_hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+        _kind: ty::AssocKind,
+    ) -> Result<(DefId, ty::GenericArgsRef<'tcx>), ErrorGuaranteed> {
         let trait_ref = self.instantiate_binder_with_fresh_vars(
             span,
-            // FIXME(mgca): this should be assoc const not assoc type
+            // FIXME(mgca): this should be assoc const if that is the `kind`
             infer::BoundRegionConversionTime::AssocTypeProjection(item_def_id),
             poly_trait_ref,
         );
@@ -352,7 +371,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
             trait_ref.args,
         );
 
-        Const::new_unevaluated(self.tcx(), ty::UnevaluatedConst::new(item_def_id, item_args))
+        Ok((item_def_id, item_args))
     }
 
     fn probe_adt(&self, span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>> {