fix ty::UnevaluatedConst<I>>->AliasTerm<I> conversion

WaffleLapkin · WaffleLapkin · commit e8b6c9737e91 · 2026-04-21T12:28:25.000+02:00
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -184,7 +184,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
                 relation.register_predicates([ty::PredicateKind::AliasRelate(lhs, rhs, direction)]);
             } else {
-                let Some(source_alias) = source_term.to_alias_term() else {
+                let Some(source_alias) = source_term.to_alias_term(self.tcx) else {
                     bug!("generalized `{source_term:?} to infer, not an alias");
                 };
                 match source_alias.kind(self.tcx) {
@@ -756,7 +756,8 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                 // path), as doing this new No path breaks some GCE things. I expect GCE to be
                 // ripped out soon so this shouldn't matter soon.
                 StructurallyRelateAliases::No if !self.cx().features().generic_const_exprs() => {
-                    self.generalize_alias_term(uv.into()).map(|v| v.expect_const())
+                    self.generalize_alias_term(ty::AliasTerm::from_unevaluated_const(self.cx(), uv))
+                        .map(|v| v.expect_const())
                 }
                 _ => {
                     let ty::UnevaluatedConst { def, args } = uv;
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -607,14 +607,14 @@ impl<'tcx> Term<'tcx> {
         }
     }
 
-    pub fn to_alias_term(self) -> Option<AliasTerm<'tcx>> {
+    pub fn to_alias_term(self, tcx: TyCtxt<'tcx>) -> Option<AliasTerm<'tcx>> {
         match self.kind() {
             TermKind::Ty(ty) => match *ty.kind() {
                 ty::Alias(alias_ty) => Some(alias_ty.into()),
                 _ => None,
             },
             TermKind::Const(ct) => match ct.kind() {
-                ConstKind::Unevaluated(uv) => Some(uv.into()),
+                ConstKind::Unevaluated(uv) => Some(AliasTerm::from_unevaluated_const(tcx, uv)),
                 _ => None,
             },
         }
diff --git a/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs b/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs
@@ -41,14 +41,14 @@ where
         // `{type error}` if the alias still contains infer vars, so we also
         // accept alias-relate goals where one of the terms is an error.
         debug_assert!(
-            lhs.to_alias_term().is_some()
-                || rhs.to_alias_term().is_some()
+            lhs.to_alias_term(self.cx()).is_some()
+                || rhs.to_alias_term(self.cx()).is_some()
                 || lhs.is_error()
                 || rhs.is_error()
         );
 
         // Structurally normalize the lhs.
-        let lhs = if let Some(alias) = lhs.to_alias_term() {
+        let lhs = if let Some(alias) = lhs.to_alias_term(self.cx()) {
             let term = self.next_term_infer_of_kind(lhs);
             self.add_goal(
                 GoalSource::TypeRelating,
@@ -60,7 +60,7 @@ where
         };
 
         // Structurally normalize the rhs.
-        let rhs = if let Some(alias) = rhs.to_alias_term() {
+        let rhs = if let Some(alias) = rhs.to_alias_term(self.cx()) {
             let term = self.next_term_infer_of_kind(rhs);
             self.add_goal(
                 GoalSource::TypeRelating,
@@ -87,7 +87,7 @@ where
             ty::AliasRelationDirection::Equate => ty::Invariant,
             ty::AliasRelationDirection::Subtype => ty::Covariant,
         };
-        match (lhs.to_alias_term(), rhs.to_alias_term()) {
+        match (lhs.to_alias_term(self.cx()), rhs.to_alias_term(self.cx())) {
             (None, None) => {
                 self.relate(param_env, lhs, variance, rhs)?;
                 self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -344,7 +344,7 @@ where
         param_env: I::ParamEnv,
         term: I::Term,
     ) -> Result<I::Term, NoSolution> {
-        if let Some(_) = term.to_alias_term() {
+        if let Some(_) = term.to_alias_term(self.cx()) {
             let normalized_term = self.next_term_infer_of_kind(term);
             let alias_relate_goal = Goal::new(
                 self.cx(),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1586,7 +1586,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             }
                         };
 
-                    if let Some(lhs) = lhs.to_alias_term()
+                    if let Some(lhs) = lhs.to_alias_term(self.tcx)
                         && let ty::AliasTermKind::ProjectionTy { .. }
                         | ty::AliasTermKind::ProjectionConst { .. } = lhs.kind(self.tcx)
                         && let Some((better_type_err, expected_term)) =
@@ -1596,7 +1596,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             Some((lhs, self.resolve_vars_if_possible(expected_term), rhs)),
                             better_type_err,
                         )
-                    } else if let Some(rhs) = rhs.to_alias_term()
+                    } else if let Some(rhs) = rhs.to_alias_term(self.tcx)
                         && let ty::AliasTermKind::ProjectionTy { .. }
                         | ty::AliasTermKind::ProjectionConst { .. } = rhs.kind(self.tcx)
                         && let Some((better_type_err, expected_term)) =
diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs
@@ -107,7 +107,7 @@ where
         let tcx = infcx.tcx;
         let recursion_limit = tcx.recursion_limit();
         if !recursion_limit.value_within_limit(self.depth) {
-            let term = alias_term.to_alias_term().unwrap();
+            let term = alias_term.to_alias_term(tcx).unwrap();
 
             self.at.infcx.err_ctxt().report_overflow_error(
                 OverflowCause::DeeplyNormalize(term),
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -699,8 +699,8 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                     // `generic_const_exprs`
                                     .eq(
                                         DefineOpaqueTypes::Yes,
-                                        ty::AliasTerm::from(a),
-                                        ty::AliasTerm::from(b),
+                                        ty::AliasTerm::from_unevaluated_const(tcx, a),
+                                        ty::AliasTerm::from_unevaluated_const(tcx, b),
                                     )
                                 {
                                     return ProcessResult::Changed(mk_pending(
diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs
@@ -469,16 +469,20 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
         // feature gate causes a parse error.
         let ct = match tcx.def_kind(uv.def) {
             DefKind::AssocConst { .. } => match tcx.def_kind(tcx.parent(uv.def)) {
-                DefKind::Trait => self.normalize_trait_projection(uv.into()).expect_const(),
-                DefKind::Impl { of_trait: false } => {
-                    self.normalize_inherent_projection(uv.into()).expect_const()
-                }
+                DefKind::Trait => self
+                    .normalize_trait_projection(ty::AliasTerm::from_unevaluated_const(tcx, uv))
+                    .expect_const(),
+                DefKind::Impl { of_trait: false } => self
+                    .normalize_inherent_projection(ty::AliasTerm::from_unevaluated_const(tcx, uv))
+                    .expect_const(),
                 kind => unreachable!(
                     "unexpected `DefKind` for const alias' resolution's parent def: {:?}",
                     kind
                 ),
             },
-            DefKind::Const { .. } => self.normalize_free_alias(uv.into()).expect_const(),
+            DefKind::Const { .. } => self
+                .normalize_free_alias(ty::AliasTerm::from_unevaluated_const(tcx, uv))
+                .expect_const(),
             DefKind::AnonConst => {
                 let ct = ct.super_fold_with(self);
                 super::with_replaced_escaping_bound_vars(
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -285,7 +285,9 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
                 constant,
                 |constant| crate::traits::evaluate_const(&self.infcx, constant, self.param_env),
             ),
-            _ => self.try_fold_free_or_assoc(ty::AliasTerm::from(uv))?.expect_const(),
+            _ => self
+                .try_fold_free_or_assoc(ty::AliasTerm::from_unevaluated_const(self.cx(), uv))?
+                .expect_const(),
         };
         debug!(?constant, ?self.param_env);
         constant.try_super_fold_with(self)
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -891,8 +891,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                     // `generic_const_exprs`
                                     .eq(
                                         DefineOpaqueTypes::Yes,
-                                        ty::AliasTerm::from(a),
-                                        ty::AliasTerm::from(b),
+                                        ty::AliasTerm::from_unevaluated_const(tcx, a),
+                                        ty::AliasTerm::from_unevaluated_const(tcx, b),
                                     )
                                 {
                                     return self.evaluate_predicates_recursively(
diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
@@ -41,7 +41,7 @@ impl<'tcx> At<'_, 'tcx> {
 
         if self.infcx.next_trait_solver() {
             let term = term.skip_normalization();
-            if let None = term.to_alias_term() {
+            if let None = term.to_alias_term(self.infcx.tcx) {
                 return Ok(term);
             }
 
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -1077,7 +1077,9 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                     if matches!(tcx.def_kind(uv.def), DefKind::AssocConst { .. })
                         && tcx.def_kind(tcx.parent(uv.def)) == (DefKind::Impl { of_trait: false })
                     {
-                        self.add_wf_preds_for_inherent_projection(uv.into());
+                        self.add_wf_preds_for_inherent_projection(
+                            ty::AliasTerm::from_unevaluated_const(tcx, uv),
+                        );
                         return; // Subtree is handled by above function
                     } else {
                         let obligations = self.nominal_obligations(uv.def, uv.args);
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
@@ -432,14 +432,16 @@ pub trait Term<I: Interner<Term = Self>>:
         }
     }
 
-    fn to_alias_term(self) -> Option<ty::AliasTerm<I>> {
+    fn to_alias_term(self, interner: I) -> Option<ty::AliasTerm<I>> {
         match self.kind() {
             ty::TermKind::Ty(ty) => match ty.kind() {
                 ty::Alias(alias_ty) => Some(alias_ty.into()),
                 _ => None,
             },
             ty::TermKind::Const(ct) => match ct.kind() {
-                ty::ConstKind::Unevaluated(uv) => Some(uv.into()),
+                ty::ConstKind::Unevaluated(uv) => {
+                    Some(ty::AliasTerm::from_unevaluated_const(interner, uv))
+                }
                 _ => None,
             },
         }
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
@@ -721,6 +721,11 @@ impl<I: Interner> AliasTerm<I> {
         Self::new_from_args(interner, kind, args)
     }
 
+    pub fn from_unevaluated_const(interner: I, ct: ty::UnevaluatedConst<I>) -> Self {
+        let kind = interner.alias_term_kind_from_def_id(ct.def.into());
+        AliasTerm::new_from_args(interner, kind, ct.args)
+    }
+
     pub fn expect_ty(self, interner: I) -> ty::AliasTy<I> {
         let kind = match self.kind(interner) {
             AliasTermKind::ProjectionTy { def_id } => AliasTyKind::Projection { def_id },
@@ -862,16 +867,6 @@ impl<I: Interner> From<ty::AliasTy<I>> for AliasTerm<I> {
     }
 }
 
-impl<I: Interner> From<ty::UnevaluatedConst<I>> for AliasTerm<I> {
-    fn from(ct: ty::UnevaluatedConst<I>) -> Self {
-        AliasTerm {
-            args: ct.args,
-            kind: AliasTermKind::UnevaluatedConst { def_id: ct.def.into() },
-            _use_alias_term_new_instead: (),
-        }
-    }
-}
-
 /// This kind of predicate has no *direct* correspondent in the
 /// syntax, but it roughly corresponds to the syntactic forms:
 ///

Original file line number	Diff line number	Diff line change
`@@ -607,14 +607,14 @@ impl<'tcx> Term<'tcx> {`
`607`	`607`	`}`
`608`	`608`	`}`
`609`	`609`
`610`		`- pub fn to_alias_term(self) -> Option<AliasTerm<'tcx>> {`
	`610`	`+ pub fn to_alias_term(self, tcx: TyCtxt<'tcx>) -> Option<AliasTerm<'tcx>> {`
`611`	`611`	`match self.kind() {`
`612`	`612`	`TermKind::Ty(ty) => match *ty.kind() {`
`613`	`613`	`ty::Alias(alias_ty) => Some(alias_ty.into()),`
`614`	`614`	`_ => None,`
`615`	`615`	`},`
`616`	`616`	`TermKind::Const(ct) => match ct.kind() {`
`617`		`- ConstKind::Unevaluated(uv) => Some(uv.into()),`
	`617`	`+ ConstKind::Unevaluated(uv) => Some(AliasTerm::from_unevaluated_const(tcx, uv)),`
`618`	`618`	`_ => None,`
`619`	`619`	`},`
`620`	`620`	`}`
Original file line number	Diff line number	Diff line change
`@@ -699,8 +699,8 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {`
`699`	`699`	// `generic_const_exprs`
`700`	`700`	`.eq(`
`701`	`701`	`DefineOpaqueTypes::Yes,`
`702`		`- ty::AliasTerm::from(a),`
`703`		`- ty::AliasTerm::from(b),`
	`702`	`+ ty::AliasTerm::from_unevaluated_const(tcx, a),`
	`703`	`+ ty::AliasTerm::from_unevaluated_const(tcx, b),`
`704`	`704`	`)`
`705`	`705`	`{`
`706`	`706`	`return ProcessResult::Changed(mk_pending(`
Original file line number	Diff line number	Diff line change
`@@ -891,8 +891,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`891`	`891`	// `generic_const_exprs`
`892`	`892`	`.eq(`
`893`	`893`	`DefineOpaqueTypes::Yes,`
`894`		`- ty::AliasTerm::from(a),`
`895`		`- ty::AliasTerm::from(b),`
	`894`	`+ ty::AliasTerm::from_unevaluated_const(tcx, a),`
	`895`	`+ ty::AliasTerm::from_unevaluated_const(tcx, b),`
`896`	`896`	`)`
`897`	`897`	`{`
`898`	`898`	`return self.evaluate_predicates_recursively(`