Use ConstArg for assoc item constraints

camelid · camelid · commit 8818708a317e · 2024-07-16T19:27:28.000-07:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1062,7 +1062,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_to_anon_const(c).into(),
+                    Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),
                 };
                 hir::AssocItemConstraintKind::Equality { term }
             }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -242,7 +242,7 @@ impl<'hir> ConstArg<'hir> {
         }
     }
 
-    pub fn hir_id(&self) -> HirId {
+    pub fn anon_const_hir_id(&self) -> HirId {
         match self.kind {
             ConstArgKind::Anon(anon) => anon.hir_id,
         }
@@ -288,7 +288,7 @@ impl GenericArg<'_> {
         match self {
             GenericArg::Lifetime(l) => l.hir_id,
             GenericArg::Type(t) => t.hir_id,
-            GenericArg::Const(c) => c.hir_id(),
+            GenericArg::Const(c) => c.anon_const_hir_id(), // FIXME
             GenericArg::Infer(i) => i.hir_id,
         }
     }
@@ -2453,7 +2453,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,
@@ -2464,7 +2464,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> {
@@ -2473,8 +2473,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)
     }
 }
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -1290,7 +1290,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)
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -224,7 +224,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
                             .iter()
                             .copied()
                             .filter_map(AssocItemConstraint::ct)
-                            .position(|ct| ct.hir_id == hir_id)
+                            .position(|ct| ct.anon_const_hir_id() == hir_id)
                             .map(|idx| (idx, seg))
                     })
             }) else {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -413,12 +413,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             });
 
             // Provide the resolved type of the associated constant to `type_of(AnonConst)`.
-            if let Some(anon_const) = constraint.ct() {
-                let ty = alias_term
-                    .map_bound(|alias| tcx.type_of(alias.def_id).instantiate(tcx, alias.args));
-                let ty =
-                    check_assoc_const_binding_type(self, constraint.ident, ty, constraint.hir_id);
-                tcx.feed_anon_const_type(anon_const.def_id, ty::EarlyBinder::bind(ty));
+            if let Some(const_arg) = constraint.ct() {
+                #[allow(irrefutable_let_patterns)] // FIXME
+                if let hir::ConstArgKind::Anon(anon_const) = const_arg.kind {
+                    let ty = alias_term
+                        .map_bound(|alias| tcx.type_of(alias.def_id).instantiate(tcx, alias.args));
+                    let ty = check_assoc_const_binding_type(
+                        self,
+                        constraint.ident,
+                        ty,
+                        constraint.hir_id,
+                    );
+                    tcx.feed_anon_const_type(anon_const.def_id, ty::EarlyBinder::bind(ty));
+                }
             }
 
             alias_term
@@ -435,7 +442,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, ty::FeedConstTy::No).into()
+                    }
                 };
 
                 // Find any late-bound regions declared in `ty` that are not
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/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 {
@@ -1296,8 +1296,7 @@ pub fn prohibit_assoc_item_constraint(
                     hir::AssocItemConstraintKind::Equality { term: hir::Term::Const(c) },
                     GenericParamDefKind::Const { .. },
                 ) => {
-                    let span = tcx.hir().span(c.hir_id);
-                    suggest_direct_use(&mut err, span);
+                    suggest_direct_use(&mut err, c.span());
                 }
                 (hir::AssocItemConstraintKind::Bound { bounds }, _) => {
                     // Suggest `impl<T: Bound> Trait<T> for Foo` when finding
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -911,7 +911,8 @@ 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, ty::FeedConstTy::No)
+                                            .into()
                                     }
                                 };
                                 // FIXME(#97583): This isn't syntactically well-formed!
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1726,7 +1726,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 } => {
diff --git a/src/librustdoc/clean/mod.rs b/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(cx.tcx, c, ty::FeedConstTy::No)),
             cx,
         )),
     }

Original file line number	Diff line number	Diff line change
`@@ -1062,7 +1062,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`1062`	`1062`	`AssocItemConstraintKind::Equality { term } => {`
`1063`	`1063`	`let term = match term {`
`1064`	`1064`	`Term::Ty(ty) => self.lower_ty(ty, itctx).into(),`
`1065`		`- Term::Const(c) => self.lower_anon_const_to_anon_const(c).into(),`
	`1065`	`+ Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),`
`1066`	`1066`	`};`
`1067`	`1067`	`hir::AssocItemConstraintKind::Equality { term }`
`1068`	`1068`	`}`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ impl<'hir> ConstArg<'hir> {`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`
`245`		`- pub fn hir_id(&self) -> HirId {`
	`245`	`+ pub fn anon_const_hir_id(&self) -> HirId {`
`246`	`246`	`match self.kind {`
`247`	`247`	`ConstArgKind::Anon(anon) => anon.hir_id,`
`248`	`248`	`}`
`@@ -288,7 +288,7 @@ impl GenericArg<'_> {`
`288`	`288`	`match self {`
`289`	`289`	`GenericArg::Lifetime(l) => l.hir_id,`
`290`	`290`	`GenericArg::Type(t) => t.hir_id,`
`291`		`- GenericArg::Const(c) => c.hir_id(),`
	`291`	`+ GenericArg::Const(c) => c.anon_const_hir_id(), // FIXME`
`292`	`292`	`GenericArg::Infer(i) => i.hir_id,`
`293`	`293`	`}`
`294`	`294`	`}`
`@@ -2453,7 +2453,7 @@ impl<'hir> AssocItemConstraint<'hir> {`
`2453`	`2453`	`}`
`2454`	`2454`
`2455`	`2455`	`/// Obtain the const on the RHS of an assoc const equality constraint if applicable.`
`2456`		`- pub fn ct(self) -> Option<&'hir AnonConst> {`
	`2456`	`+ pub fn ct(self) -> Option<&'hir ConstArg<'hir>> {`
`2457`	`2457`	`match self.kind {`
`2458`	`2458`	`AssocItemConstraintKind::Equality { term: Term::Const(ct) } => Some(ct),`
`2459`	`2459`	`_ => None,`
`@@ -2464,7 +2464,7 @@ impl<'hir> AssocItemConstraint<'hir> {`
`2464`	`2464`	`#[derive(Debug, Clone, Copy, HashStable_Generic)]`
`2465`	`2465`	`pub enum Term<'hir> {`
`2466`	`2466`	`Ty(&'hir Ty<'hir>),`
`2467`		`- Const(&'hir AnonConst),`
	`2467`	`+ Const(&'hir ConstArg<'hir>),`
`2468`	`2468`	`}`
`2469`	`2469`
`2470`	`2470`	`impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {`
`@@ -2473,8 +2473,8 @@ impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {`
`2473`	`2473`	`}`
`2474`	`2474`	`}`
`2475`	`2475`
`2476`		`-impl<'hir> From<&'hir AnonConst> for Term<'hir> {`
`2477`		`- fn from(c: &'hir AnonConst) -> Self {`
	`2476`	`+impl<'hir> From<&'hir ConstArg<'hir>> for Term<'hir> {`
	`2477`	`+ fn from(c: &'hir ConstArg<'hir>) -> Self {`
`2478`	`2478`	`Term::Const(c)`
`2479`	`2479`	`}`
`2480`	`2480`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1726,7 +1726,7 @@ impl<'a> State<'a> {`
`1726`	`1726`	`self.word_space("=");`
`1727`	`1727`	`match term {`
`1728`	`1728`	`Term::Ty(ty) => self.print_type(ty),`
`1729`		`- Term::Const(ref c) => self.print_anon_const(c),`
	`1729`	`+ Term::Const(ref c) => self.print_const_arg(c),`
`1730`	`1730`	`}`
`1731`	`1731`	`}`
`1732`	`1732`	`hir::AssocItemConstraintKind::Bound { bounds } => {`
Original file line number	Diff line number	Diff line change
`@@ -433,7 +433,7 @@ fn clean_hir_term<'tcx>(term: &hir::Term<'tcx>, cx: &mut DocContext<'tcx>) -> Te`
`433`	`433`	`match term {`
`434`	`434`	`hir::Term::Ty(ty) => Term::Type(clean_ty(ty, cx)),`
`435`	`435`	`hir::Term::Const(c) => Term::Constant(clean_middle_const(`
`436`		`- ty::Binder::dummy(ty::Const::from_anon_const(cx.tcx, c.def_id)),`
	`436`	`+ ty::Binder::dummy(ty::Const::from_const_arg(cx.tcx, c, ty::FeedConstTy::No)),`
`437`	`437`	`cx,`
`438`	`438`	`)),`
`439`	`439`	`}`