add const_of_item query and use it in normalization

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -96,6 +96,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         rendered_precise_capturing_args,
         const_param_default,
         anon_const_kind,
+        const_of_item,
         ..*providers
     };
 }
@@ -1543,3 +1544,32 @@ fn anon_const_kind<'tcx>(tcx: TyCtxt<'tcx>, def: LocalDefId) -> ty::AnonConstKin
         _ => ty::AnonConstKind::NonTypeSystem,
     }
 }
+
+#[instrument(level = "debug", skip(tcx), ret)]
+fn const_of_item<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: LocalDefId,
+) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
+    let ct_rhs = 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 ct_arg = match ct_rhs {
+        hir::ConstItemRhs::TypeConst(ct_arg) => ct_arg,
+        hir::ConstItemRhs::Body(body_id) => {
+            bug!("cannot call const_of_item on a non-type_const {body_id:?}")
+        }
+    };
+    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_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -403,6 +403,7 @@ provide! { tcx, def_id, other, cdata,
         tcx.arena.alloc_from_iter(cdata.get_doc_link_traits_in_scope(def_id.index))
     }
     anon_const_kind => { table }
+    const_of_item => { table }
 }
 
 pub(in crate::rmeta) fn provide(providers: &mut Providers) {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1604,6 +1604,23 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if let DefKind::AnonConst = def_kind {
                 record!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id));
             }
+            if let DefKind::Const = def_kind
+                && find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
+            {
+                record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
+            }
+            if let DefKind::AssocConst = def_kind
+                && find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
+            {
+                let assoc_item = tcx.associated_item(def_id);
+                let should_encode = match assoc_item.container {
+                    ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
+                    ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
+                };
+                if should_encode {
+                    record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
+                }
+            }
             if tcx.impl_method_has_trait_impl_trait_tys(def_id)
                 && let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id)
             {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -471,6 +471,7 @@ define_tables! {
     assumed_wf_types_for_rpitit: Table<DefIndex, LazyArray<(Ty<'static>, Span)>>,
     opaque_ty_origin: Table<DefIndex, LazyValue<hir::OpaqueTyOrigin<DefId>>>,
     anon_const_kind: Table<DefIndex, LazyValue<ty::AnonConstKind>>,
+    const_of_item: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, ty::Const<'static>>>>,
     associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<DefIdMap<Vec<DefId>>>>,
 }
 

compiler/rustc_middle/src/query/mod.rs

@@ -293,6 +293,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

@@ -242,6 +242,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

@@ -54,8 +54,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

@@ -366,19 +366,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

@@ -333,10 +333,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 +437,40 @@ 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),
+        };
+
+        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.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.
-        }
+        // 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]