Use ConstArg for assoc item constraints

Author: camelid

compiler/rustc_ast_lowering/src/lib.rs

@@ -1041,7 +1041,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             AssocItemConstraintKind::Equality { term } => {
                 let term = match term {
                     Term::Ty(ty) => self.lower_ty(ty, itctx).into(),
-                    Term::Const(c) => self.lower_anon_const(c).into(),
+                    Term::Const(c) => self.lower_anon_const_as_const_arg(c).into(),
                 };
                 hir::AssocItemConstraintKind::Equality { term }
             }
@@ -1155,11 +1155,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                     ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                                     None,
                                 );
-                                return GenericArg::Const(ConstArg {
+                                let const_arg = ConstArg {
                                     hir_id: self.next_id(),
                                     kind: ConstArgKind::Path(qpath),
                                     is_desugared_from_effects: false,
-                                });
+                                };
+                                return GenericArg::Const(self.arena.alloc(const_arg));
                             }
                         }
                     }
@@ -1171,7 +1172,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn lower_anon_const_as_const_arg(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
+    fn lower_anon_const_as_const_arg(&mut self, anon: &AnonConst) -> &'hir hir::ConstArg<'hir> {
+        self.arena.alloc(self.lower_anon_const_as_const_arg_direct(anon))
+    }
+
+    fn lower_anon_const_as_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
         if let ExprKind::Path(qself, path) = &anon.value.kind
             && let Some(res) = self
                 .resolver
@@ -2654,11 +2659,11 @@ impl<'hir> GenericArgsCtor<'hir> {
             }
         };
 
-        self.args.push(hir::GenericArg::Const(hir::ConstArg {
+        self.args.push(hir::GenericArg::Const(lcx.arena.alloc(hir::ConstArg {
             hir_id: lcx.next_id(),
             kind: const_arg_kind,
             is_desugared_from_effects: true,
-        }))
+        })))
     }
 
     fn is_empty(&self) -> bool {

compiler/rustc_hir/src/hir.rs

@@ -268,7 +268,7 @@ impl InferArg {
 pub enum GenericArg<'hir> {
     Lifetime(&'hir Lifetime),
     Type(&'hir Ty<'hir>),
-    Const(ConstArg<'hir>),
+    Const(&'hir ConstArg<'hir>),
     Infer(InferArg),
 }
 
@@ -2440,7 +2440,7 @@ impl<'hir> AssocItemConstraint<'hir> {
     }
 
     /// Obtain the const on the RHS of an assoc const equality constraint if applicable.
-    pub fn ct(self) -> Option<&'hir AnonConst> {
+    pub fn ct(self) -> Option<&'hir ConstArg<'hir>> {
         match self.kind {
             AssocItemConstraintKind::Equality { term: Term::Const(ct) } => Some(ct),
             _ => None,
@@ -2451,7 +2451,7 @@ impl<'hir> AssocItemConstraint<'hir> {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum Term<'hir> {
     Ty(&'hir Ty<'hir>),
-    Const(&'hir AnonConst),
+    Const(&'hir ConstArg<'hir>),
 }
 
 impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {
@@ -2460,8 +2460,8 @@ impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {
     }
 }
 
-impl<'hir> From<&'hir AnonConst> for Term<'hir> {
-    fn from(c: &'hir AnonConst) -> Self {
+impl<'hir> From<&'hir ConstArg<'hir>> for Term<'hir> {
+    fn from(c: &'hir ConstArg<'hir>) -> Self {
         Term::Const(c)
     }
 }
@@ -3937,7 +3937,7 @@ mod size_asserts {
     static_assert_size!(FnDecl<'_>, 40);
     static_assert_size!(ForeignItem<'_>, 72);
     static_assert_size!(ForeignItemKind<'_>, 40);
-    static_assert_size!(GenericArg<'_>, 40);
+    static_assert_size!(GenericArg<'_>, 16);
     static_assert_size!(GenericBound<'_>, 48);
     static_assert_size!(Generics<'_>, 56);
     static_assert_size!(Impl<'_>, 80);

compiler/rustc_hir/src/intravisit.rs

@@ -1292,7 +1292,7 @@ pub fn walk_assoc_item_constraint<'v, V: Visitor<'v>>(
     match constraint.kind {
         AssocItemConstraintKind::Equality { ref term } => match term {
             Term::Ty(ref ty) => try_visit!(visitor.visit_ty(ty)),
-            Term::Const(ref c) => try_visit!(visitor.visit_anon_const(c)),
+            Term::Const(ref c) => try_visit!(visitor.visit_const_arg(c)),
         },
         AssocItemConstraintKind::Bound { bounds } => {
             walk_list!(visitor, visit_param_bound, bounds)

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -426,12 +426,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             });
 
             // Provide the resolved type of the associated constant to `type_of(AnonConst)`.
-            if let hir::AssocItemConstraintKind::Equality { term: hir::Term::Const(anon_const) } =
+            if let hir::AssocItemConstraintKind::Equality { term: hir::Term::Const(const_arg) } =
                 constraint.kind
             {
-                let ty = alias_ty.map_bound(|ty| tcx.type_of(ty.def_id).instantiate(tcx, ty.args));
-                let ty = check_assoc_const_binding_type(tcx, assoc_ident, ty, constraint.hir_id);
-                tcx.feed_anon_const_type(anon_const.def_id, ty::EarlyBinder::bind(ty));
+                if let hir::ConstArgKind::Anon(anon_const) = const_arg.kind {
+                    let ty =
+                        alias_ty.map_bound(|ty| tcx.type_of(ty.def_id).instantiate(tcx, ty.args));
+                    let ty =
+                        check_assoc_const_binding_type(tcx, assoc_ident, ty, constraint.hir_id);
+                    tcx.feed_anon_const_type(anon_const.def_id, ty::EarlyBinder::bind(ty));
+                }
             }
 
             alias_ty
@@ -448,7 +452,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             hir::AssocItemConstraintKind::Equality { term } => {
                 let term = match term {
                     hir::Term::Ty(ty) => self.lower_ty(ty).into(),
-                    hir::Term::Const(ct) => ty::Const::from_anon_const(tcx, ct.def_id).into(),
+                    hir::Term::Const(ct) => {
+                        ty::Const::from_const_arg(tcx, ct, assoc_item.def_id).into()
+                    }
                 };
 
                 // Find any late-bound regions declared in `ty` that are not

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -340,7 +340,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         {
             let span = match term {
                 hir::Term::Ty(ty) => ty.span,
-                hir::Term::Const(ct) => tcx.def_span(ct.def_id),
+                hir::Term::Const(ct) => ct.span(),
             };
             (span, Some(ident.span), assoc_item.kind, assoc_kind)
         } else {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -476,18 +476,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     (&GenericParamDefKind::Type { has_default, .. }, GenericArg::Infer(inf)) => {
                         handle_ty_args(has_default, &inf.to_ty())
                     }
-                    (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => match ct.kind {
-                        hir::ConstArgKind::Path(qpath) => {
-                            // FIXME(min_generic_const_exprs): for now only params are lowered to ConstArgKind::Path
-                            ty::Const::from_param(tcx, qpath, ct.hir_id).into()
-                        }
-                        hir::ConstArgKind::Anon(anon) => {
-                            let did = anon.def_id;
-                            tcx.feed_anon_const_type(did, tcx.type_of(param.def_id));
-                            ty::Const::from_anon_const(tcx, did).into()
-                        }
-                    },
-                    (&GenericParamDefKind::Const { .. }, hir::GenericArg::Infer(inf)) => {
+                    (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => {
+                        ty::Const::from_const_arg(tcx, ct, param.def_id).into()
+                    }
+                    (&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
                         self.lowerer.ct_infer(Some(param), inf.span).into()
                     }
                     (kind, arg) => span_bug!(
@@ -907,12 +899,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             let mut where_bounds = vec![];
             for bound in [bound, bound2].into_iter().chain(matching_candidates) {
                 let bound_id = bound.def_id();
-                let bound_span = tcx
+                let assoc_item = tcx
                     .associated_items(bound_id)
-                    .find_by_name_and_kind(tcx, assoc_name, assoc_kind, bound_id)
-                    .and_then(|item| tcx.hir().span_if_local(item.def_id));
+                    .find_by_name_and_kind(tcx, assoc_name, assoc_kind, bound_id);
+                let bound_span = assoc_item.and_then(|item| tcx.hir().span_if_local(item.def_id));
 
-                if let Some(bound_span) = bound_span {
+                if let Some(assoc_item) = assoc_item
+                    && let Some(bound_span) = bound_span
+                {
                     err.span_label(
                         bound_span,
                         format!("ambiguous `{assoc_name}` from `{}`", bound.print_trait_sugared(),),
@@ -923,7 +917,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                 let term: ty::Term<'_> = match term {
                                     hir::Term::Ty(ty) => self.lower_ty(ty).into(),
                                     hir::Term::Const(ct) => {
-                                        ty::Const::from_anon_const(tcx, ct.def_id).into()
+                                        ty::Const::from_const_arg(tcx, ct, assoc_item.def_id).into()
                                     }
                                 };
                                 // FIXME(#97583): This isn't syntactically well-formed!

compiler/rustc_hir_pretty/src/lib.rs

@@ -1721,7 +1721,7 @@ impl<'a> State<'a> {
                 self.word_space("=");
                 match term {
                     Term::Ty(ty) => self.print_type(ty),
-                    Term::Const(ref c) => self.print_anon_const(c),
+                    Term::Const(ref c) => self.print_const_arg(c),
                 }
             }
             hir::AssocItemConstraintKind::Bound { bounds } => {

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -8,7 +8,7 @@ use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan, StashKey};
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
-use rustc_hir::{self as hir, ConstArg, ConstArgKind};
+use rustc_hir::{self as hir};
 use rustc_hir::{ExprKind, GenericArg, HirId, Node, QPath};
 use rustc_hir_analysis::hir_ty_lowering::errors::GenericsArgsErrExtend;
 use rustc_hir_analysis::hir_ty_lowering::generics::{
@@ -468,20 +468,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     pub fn lower_const_arg(
         &self,
-        const_arg: &ConstArg<'tcx>,
+        const_arg: &'tcx hir::ConstArg<'tcx>,
         param_def_id: DefId,
     ) -> ty::Const<'tcx> {
-        let ct = match const_arg.kind {
-            ConstArgKind::Path(qpath) => {
-                // FIXME(min_generic_const_exprs): for now only params are lowered to ConstArgKind::Path
-                ty::Const::from_param(self.tcx, qpath, const_arg.hir_id)
-            }
-            ConstArgKind::Anon(anon) => {
-                let did = anon.def_id;
-                self.tcx.feed_anon_const_type(did, self.tcx.type_of(param_def_id));
-                ty::Const::from_anon_const(self.tcx, did)
-            }
-        };
+        let ct = ty::Const::from_const_arg(self.tcx, const_arg, param_def_id);
         self.register_wf_obligation(
             ct.into(),
             self.tcx.hir().span(const_arg.hir_id),

compiler/rustc_middle/src/ty/consts.rs

@@ -4,7 +4,7 @@ use crate::ty::{self, GenericArgs, ParamEnv, ParamEnvAnd, Ty, TyCtxt, TypeVisita
 use rustc_data_structures::intern::Interned;
 use rustc_error_messages::MultiSpan;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::LocalDefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, HirId};
 use rustc_macros::HashStable;
 use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
@@ -179,6 +179,39 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
 }
 
 impl<'tcx> Const<'tcx> {
+    /// Convert a [`hir::ConstArg`] to a [`ty::Const`](Self).
+    ///
+    /// `param_def_id` is the [`DefId`] of the declared param that this [`ConstArg`] is being
+    /// supplied to. We need this in case this `ConstArg` is a [`ConstArgKind::Anon`]
+    /// so we can tell the [`AnonConst`] what type it should be.
+    pub fn from_const_arg(
+        tcx: TyCtxt<'tcx>,
+        const_arg: &'tcx hir::ConstArg<'tcx>,
+        param_def_id: DefId,
+    ) -> Self {
+        if let hir::ConstArgKind::Anon(anon) = &const_arg.kind {
+            tcx.feed_anon_const_type(anon.def_id, tcx.type_of(param_def_id));
+        }
+        Self::from_const_arg_without_feeding(tcx, const_arg)
+    }
+
+    /// Convert a [`hir::ConstArg`] to a [`ty::Const`](Self), without feeding it its expected type.
+    ///
+    /// This distinction is only relevant for [`hir::ConstArgKind::Anon`];
+    /// see [`Self::from_const_arg_without_feeding`].
+    pub fn from_const_arg_without_feeding(
+        tcx: TyCtxt<'tcx>,
+        const_arg: &'tcx hir::ConstArg<'tcx>,
+    ) -> Self {
+        match const_arg.kind {
+            hir::ConstArgKind::Path(qpath) => {
+                // FIXME(min_generic_const_exprs): for now only params are lowered to ConstArgKind::Path
+                Self::from_param(tcx, qpath, const_arg.hir_id)
+            }
+            hir::ConstArgKind::Anon(anon) => Self::from_anon_const(tcx, anon.def_id),
+        }
+    }
+
     /// Literals and const generic parameters are eagerly converted to a constant, everything else
     /// becomes `Unevaluated`.
     #[instrument(skip(tcx), level = "debug")]
@@ -212,7 +245,7 @@ impl<'tcx> Const<'tcx> {
     /// Lower a const param to a [`Const`].
     ///
     /// IMPORTANT: `qpath` must be a const param, otherwise this will panic
-    pub fn from_param(tcx: TyCtxt<'tcx>, qpath: hir::QPath<'tcx>, hir_id: HirId) -> Self {
+    fn from_param(tcx: TyCtxt<'tcx>, qpath: hir::QPath<'tcx>, hir_id: HirId) -> Self {
         // FIXME(const_generics): We currently have to special case parameters because `min_const_generics`
         // does not provide the parents generics to anonymous constants. We still allow generic const
         // parameters by themselves however, e.g. `N`. These constants would cause an ICE if we were to
@@ -274,6 +307,21 @@ impl<'tcx> Const<'tcx> {
                 }
             }
         }
+
+        // FIXME: this shouldn't panic, it's just temporary code
+        match expr.kind {
+            hir::ExprKind::Path(hir::QPath::Resolved(
+                _,
+                &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
+            )) => {
+                span_bug!(
+                    expr.span,
+                    "try_from_lit: received const param which shouldn't be possible"
+                )
+            }
+            _ => {}
+        }
+
         None
     }
 

src/librustdoc/clean/mod.rs

@@ -433,7 +433,7 @@ fn clean_hir_term<'tcx>(term: &hir::Term<'tcx>, cx: &mut DocContext<'tcx>) -> Te
     match term {
         hir::Term::Ty(ty) => Term::Type(clean_ty(ty, cx)),
         hir::Term::Const(c) => Term::Constant(clean_middle_const(
-            ty::Binder::dummy(ty::Const::from_anon_const(cx.tcx, c.def_id)),
+            ty::Binder::dummy(ty::Const::from_const_arg_without_feeding(cx.tcx, c)),
             cx,
         )),
     }