Properly lower assoc consts from traits

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -532,6 +532,95 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         }
     }
 
+    fn lower_assoc_const(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+    ) -> Const<'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,
+            );
+            let uv = ty::UnevaluatedConst::new(item_def_id, item_args);
+            Const::new_unevaluated(self.tcx(), uv)
+        } 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(),
+                    );
+                }
+                _ => {}
+            }
+            Const::new_error(
+                self.tcx(),
+                self.tcx().dcx().emit_err(errors::AssociatedItemTraitUninferredGenericParams {
+                    span,
+                    inferred_sugg,
+                    bound,
+                    mpart_sugg,
+                    what: "const",
+                }),
+            )
+        }
+    }
+
     fn probe_adt(&self, _span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>> {
         // FIXME(#103640): Should we handle the case where `ty` is a projection?
         ty.ty_adt_def()

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -150,7 +150,7 @@ pub trait HirTyLowerer<'tcx> {
         assoc_name: Ident,
     ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]>;
 
-    /// Lower an associated type to a projection.
+    /// Lower an associated type (from a trait) to a projection.
     ///
     /// This method has to be defined by the concrete lowering context because
     /// dealing with higher-ranked trait references depends on its capabilities:
@@ -170,6 +170,15 @@ pub trait HirTyLowerer<'tcx> {
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Ty<'tcx>;
 
+    /// Lower an associated constant (from a trait) to a [`ty::Const`].
+    fn lower_assoc_const(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+    ) -> Const<'tcx>;
+
     fn lower_fn_sig(
         &self,
         decl: &hir::FnDecl<'tcx>,
@@ -2254,16 +2263,22 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         span,
                         impl_,
                     )
+                    .map(|assoc| (impl_, assoc))
                 })
                 .collect::<Vec<_>>();
             match &candidates[..] {
                 [] => {}
-                [assoc] => {
-                    // FIXME: this is not necessarily correct.
-                    // adapted from other code that also had a fixme about it being temporary.
-                    let parent_args =
-                        ty::GenericArgs::identity_for_item(tcx, tcx.parent(assoc.def_id));
-                    return self.lower_assoc_const(span, assoc.def_id, assoc_segment, parent_args);
+                &[(impl_, assoc)] => {
+                    // FIXME(min_generic_const_args): adapted from temporary inherent assoc ty code that may be incorrect
+                    let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
+                    let args = self.lower_generic_args_of_assoc_item(
+                        span,
+                        assoc.def_id,
+                        assoc_segment,
+                        parent_args,
+                    );
+                    let uv = ty::UnevaluatedConst::new(assoc.def_id, args);
+                    return Const::new_unevaluated(tcx, uv);
                 }
                 [..] => {
                     return Const::new_error_with_message(tcx, span, "ambiguous assoc const path");
@@ -2323,23 +2338,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let assoc_const = self
             .probe_assoc_item(assoc_ident, ty::AssocKind::Const, hir_ref_id, span, trait_did)
             .expect("failed to find associated const");
-        // FIXME: don't use no_bound_vars probably
-        let trait_ref_args = bound.no_bound_vars().unwrap().args;
-        self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, trait_ref_args)
-    }
-
-    fn lower_assoc_const(
-        &self,
-        span: Span,
-        item_def_id: DefId,
-        item_segment: &hir::PathSegment<'tcx>,
-        parent_args: GenericArgsRef<'tcx>,
-    ) -> Const<'tcx> {
-        let tcx = self.tcx();
-        let args =
-            self.lower_generic_args_of_assoc_item(span, item_def_id, item_segment, parent_args);
-        let uv = ty::UnevaluatedConst::new(item_def_id, args);
-        Const::new_unevaluated(tcx, uv)
+        self.lower_assoc_const(span, assoc_const.def_id, assoc_segment, bound)
     }
 
     /// Literals are eagerly converted to a constant, everything else becomes `Unevaluated`.

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -331,6 +331,30 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         Ty::new_projection_from_args(self.tcx(), item_def_id, item_args)
     }
 
+    fn lower_assoc_const(
+        &self,
+        span: Span,
+        item_def_id: DefId,
+        item_segment: &hir::PathSegment<'tcx>,
+        poly_trait_ref: ty::PolyTraitRef<'tcx>,
+    ) -> Const<'tcx> {
+        let trait_ref = self.instantiate_binder_with_fresh_vars(
+            span,
+            // FIXME(min_generic_const_args): this should be assoc const not assoc type
+            infer::BoundRegionConversionTime::AssocTypeProjection(item_def_id),
+            poly_trait_ref,
+        );
+
+        let item_args = self.lowerer().lower_generic_args_of_assoc_item(
+            span,
+            item_def_id,
+            item_segment,
+            trait_ref.args,
+        );
+
+        Const::new_unevaluated(self.tcx(), ty::UnevaluatedConst::new(item_def_id, item_args))
+    }
+
     fn probe_adt(&self, span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>> {
         match ty.kind() {
             ty::Adt(adt_def, _) => Some(*adt_def),