wip on fixing const normalization ICEs

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -89,6 +89,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         rendered_precise_capturing_args,
         const_param_default,
         anon_const_kind,
+        const_of_item,
         ..*providers
     };
 }
@@ -1851,3 +1852,25 @@ fn anon_const_kind<'tcx>(tcx: TyCtxt<'tcx>, def: LocalDefId) -> ty::AnonConstKin
         _ => ty::AnonConstKind::NonTypeSystem,
     }
 }
+
+fn const_of_item<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: LocalDefId,
+) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
+    let ct_arg = match tcx.hir_node_by_def_id(def_id) {
+        hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(.., ct), .. }) => ct,
+        hir::Node::TraitItem(hir::TraitItem {
+            kind: hir::TraitItemKind::Const(.., ct), ..
+        }) => ct.expect("no default value for trait assoc const"),
+        hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(.., ct), .. }) => ct,
+        _ => {
+            span_bug!(tcx.def_span(def_id), "`const_of_item` expected a const or assoc const item")
+        }
+    };
+    let icx = ItemCtxt::new(tcx, def_id);
+    let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
+    let ct = icx
+        .lowerer()
+        .lower_const_arg(ct_arg, FeedConstTy::Param(def_id.to_def_id(), identity_args));
+    ty::EarlyBinder::bind(ct)
+}

compiler/rustc_middle/src/mir/consts.rs

@@ -362,7 +362,19 @@ impl<'tcx> Const<'tcx> {
             }
             Const::Unevaluated(uneval, _) => {
                 // FIXME: We might want to have a `try_eval`-like function on `Unevaluated`
-                tcx.const_eval_resolve(typing_env, uneval, span)
+                let uneval_ty_ct = ty::Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(uneval.def, uneval.args));
+                let mir_ct = tcx.normalize_erasing_regions(typing_env, uneval_ty_ct);
+                // FIXME: duplicated with above match arm
+                match mir_ct.kind() {
+                    ConstKind::Value(cv) => Ok(tcx.valtree_to_const_val(cv)),
+                    ConstKind::Expr(_) => {
+                        bug!("Normalization of `ty::ConstKind::Expr` is unimplemented")
+                    }
+                    _ => Err(ReportedErrorInfo::non_const_eval_error(
+                        tcx.dcx().delayed_bug("Unevaluated `ty::Const` in MIR body"),
+                    )
+                    .into()),
+                }
             }
             Const::Val(val, _) => Ok(val),
         }

compiler/rustc_middle/src/query/mod.rs

@@ -230,6 +230,13 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    /// Returns the const of the RHS of a const item.
+    query const_of_item(def_id: DefId) -> ty::EarlyBinder<'tcx, ty::Const<'tcx>> {
+        desc { |tcx| "computing the value for `{}`", tcx.def_path_str(def_id)  }
+        cache_on_disk_if { def_id.is_local() }
+        separate_provide_extern
+    }
+
     /// Returns the *type* of the definition given by `DefId`.
     ///
     /// For type aliases (whether eager or lazy) and associated types, this returns

compiler/rustc_middle/src/ty/context.rs

@@ -213,6 +213,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     fn type_of_opaque_hir_typeck(self, def_id: LocalDefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         self.type_of_opaque_hir_typeck(def_id)
     }
+    fn const_of_item(self, def_id: DefId) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
+        self.const_of_item(def_id)
+    }
 
     type AdtDef = ty::AdtDef<'tcx>;
     fn adt_def(self, adt_def_id: DefId) -> Self::AdtDef {

compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs

@@ -30,14 +30,12 @@ where
         );
 
         let actual = if free_alias.kind(cx).is_type() {
-            cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args)
+            cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args).into()
         } else {
-            // FIXME(mgca): once const items are actual aliases defined as equal to type system consts
-            // this should instead return that.
-            panic!("normalizing free const aliases in the type system is unsupported");
+            cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
         };
 
-        self.instantiate_normalizes_to_term(goal, actual.into());
+        self.instantiate_normalizes_to_term(goal, actual);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs

@@ -51,8 +51,7 @@ where
         let normalized = if inherent.kind(cx).is_type() {
             cx.type_of(inherent.def_id).instantiate(cx, inherent_args).into()
         } else {
-            // FIXME(mgca): Properly handle IACs in the type system
-            panic!("normalizing inherent associated consts in the type system is unsupported");
+            cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()
         };
         self.instantiate_normalizes_to_term(goal, normalized);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -367,19 +367,7 @@ where
                     cx.type_of(target_item_def_id).map_bound(|ty| ty.into())
                 }
                 ty::AliasTermKind::ProjectionConst => {
-                    // FIXME(mgca): once const items are actual aliases defined as equal to type system consts
-                    // this should instead return that.
-                    if cx.features().associated_const_equality() {
-                        panic!("associated const projection is not supported yet")
-                    } else {
-                        ty::EarlyBinder::bind(
-                            Const::new_error_with_message(
-                                cx,
-                                "associated const projection is not supported yet",
-                            )
-                            .into(),
-                        )
-                    }
+                    cx.const_of_item(target_item_def_id).map_bound(|ct| ct.into())
                 }
                 kind => panic!("expected projection, found {kind:?}"),
             };

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -284,7 +284,6 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
         }
     }
 
-    // FIXME(mgca): While this supports constants, it is only used for types by default right now
     #[instrument(level = "debug", skip(self), ret)]
     fn normalize_free_alias(&mut self, free: AliasTerm<'tcx>) -> Term<'tcx> {
         let recursion_limit = self.cx().recursion_limit();
@@ -333,10 +332,11 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
         let res = if free.kind(infcx.tcx).is_type() {
             infcx.tcx.type_of(free.def_id).instantiate(infcx.tcx, free.args).fold_with(self).into()
         } else {
-            // FIXME(mgca): once const items are actual aliases defined as equal to type system consts
-            // this should instead use that rather than evaluating.
-            super::evaluate_const(infcx, free.to_term(infcx.tcx).expect_const(), self.param_env)
-                .super_fold_with(self)
+            infcx
+                .tcx
+                .const_of_item(free.def_id)
+                .instantiate(infcx.tcx, free.args)
+                .fold_with(self)
                 .into()
         };
         self.depth -= 1;
@@ -436,51 +436,38 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
             return ct;
         }
 
-        // Doing "proper" normalization of const aliases is inherently cyclic until const items
-        // are real aliases instead of having bodies. We gate proper const alias handling behind
-        // mgca to avoid breaking stable code, though this should become the "main" codepath long
-        // before mgca is stabilized.
-        //
-        // FIXME(BoxyUwU): Enabling this by default is blocked on a refactoring to how const items
-        // are represented.
-        if tcx.features().min_generic_const_args() {
-            let uv = match ct.kind() {
-                ty::ConstKind::Unevaluated(uv) => uv,
-                _ => return ct.super_fold_with(self),
-            };
-
-            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()),
-                    DefKind::Impl { of_trait: false } => {
-                        self.normalize_inherent_projection(uv.into())
-                    }
-                    kind => unreachable!(
-                        "unexpected `DefKind` for const alias' resolution's parent def: {:?}",
-                        kind
-                    ),
-                },
-                DefKind::Const | DefKind::AnonConst => self.normalize_free_alias(uv.into()),
-                kind => {
-                    unreachable!("unexpected `DefKind` for const alias to resolve to: {:?}", kind)
-                }
-            };
+        let uv = match ct.kind() {
+            ty::ConstKind::Unevaluated(uv) => uv,
+            _ => return ct.super_fold_with(self),
+        };
 
-            // We re-fold the normalized const as the `ty` field on `ConstKind::Value` may be
-            // unnormalized after const evaluation returns.
-            ct.expect_const().super_fold_with(self)
-        } else {
-            let ct = ct.super_fold_with(self);
-            return super::with_replaced_escaping_bound_vars(
-                self.selcx.infcx,
-                &mut self.universes,
-                ct,
-                |ct| super::evaluate_const(self.selcx.infcx, ct, self.param_env),
-            )
-            .super_fold_with(self);
-            // We re-fold the normalized const as the `ty` field on `ConstKind::Value` may be
-            // unnormalized after const evaluation returns.
-        }
+        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(),
+                kind => unreachable!(
+                    "unexpected `DefKind` for const alias' resolution's parent def: {:?}",
+                    kind
+                ),
+            },
+            DefKind::Const => self.normalize_free_alias(uv.into()).expect_const(),
+            DefKind::AnonConst => {
+                let ct = ct.super_fold_with(self);
+                super::with_replaced_escaping_bound_vars(
+                    self.selcx.infcx,
+                    &mut self.universes,
+                    ct,
+                    |ct| super::evaluate_const(self.selcx.infcx, ct, self.param_env),
+                )
+            }
+            kind => {
+                unreachable!("unexpected `DefKind` for const alias to resolve to: {:?}", kind)
+            }
+        };
+
+        // We re-fold the normalized const as the `ty` field on `ConstKind::Value` may be
+        // unnormalized after const evaluation returns.
+        ct.super_fold_with(self)
     }
 
     #[inline]

compiler/rustc_trait_selection/src/traits/project.rs

@@ -547,7 +547,7 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
     let term: Term<'tcx> = if alias_term.kind(tcx).is_type() {
         tcx.type_of(alias_term.def_id).instantiate(tcx, args).into()
     } else {
-        get_associated_const_value(selcx, alias_term.to_term(tcx).expect_const(), param_env).into()
+        tcx.const_of_item(alias_term.def_id).instantiate(tcx, args).into()
     };
 
     let mut term = selcx.infcx.resolve_vars_if_possible(term);
@@ -2030,14 +2030,7 @@ fn confirm_impl_candidate<'cx, 'tcx>(
     let term = if obligation.predicate.kind(tcx).is_type() {
         tcx.type_of(assoc_term.item.def_id).map_bound(|ty| ty.into())
     } else {
-        ty::EarlyBinder::bind(
-            get_associated_const_value(
-                selcx,
-                obligation.predicate.to_term(tcx).expect_const(),
-                param_env,
-            )
-            .into(),
-        )
+        tcx.const_of_item(assoc_term.item.def_id).map_bound(|ct| ct.into())
     };
 
     let progress = if !tcx.check_args_compatible(assoc_term.item.def_id, args) {
@@ -2129,15 +2122,3 @@ impl<'cx, 'tcx> ProjectionCacheKeyExt<'cx, 'tcx> for ProjectionCacheKey<'tcx> {
         })
     }
 }
-
-fn get_associated_const_value<'tcx>(
-    selcx: &mut SelectionContext<'_, 'tcx>,
-    alias_ct: ty::Const<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-) -> ty::Const<'tcx> {
-    // FIXME(mgca): We shouldn't be invoking ctfe here, instead const items should be aliases to type
-    // system consts that we can retrieve with some `query const_arg_of_alias` query. Evaluating the
-    // constant is "close enough" to getting the actual rhs of the const item for now even if it might
-    // lead to some cycles
-    super::evaluate_const(selcx.infcx, alias_ct, param_env)
-}

compiler/rustc_type_ir/src/interner.rs

@@ -169,6 +169,7 @@ pub trait Interner:
     fn type_of(self, def_id: Self::DefId) -> ty::EarlyBinder<Self, Self::Ty>;
     fn type_of_opaque_hir_typeck(self, def_id: Self::LocalDefId)
     -> ty::EarlyBinder<Self, Self::Ty>;
+    fn const_of_item(self, def_id: Self::DefId) -> ty::EarlyBinder<Self, Self::Const>;
 
     type AdtDef: AdtDef<Self>;
     fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef;