Address oli's comments

Author: camelid

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -372,7 +372,7 @@ where
             matches!(cx.tcx.def_kind(def), DefKind::Const | DefKind::AssocConst)
                 && find_attr!(cx.tcx.get_all_attrs(def), AttributeKind::TypeConst(_));
 
-        // Don't peak inside trait associated consatnts, also `#[type_const] const` items
+        // Don't peak inside trait associated constants, also `#[type_const] const` items
         // don't have bodies so there's nothing to look at
         if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !is_type_const_item {
             let qualifs = cx.tcx.at(constant.span).mir_const_qualif(def);

compiler/rustc_hir_analysis/src/collect.rs

@@ -1571,5 +1571,11 @@ fn const_of_item<'tcx>(
     let ct = icx
         .lowerer()
         .lower_const_arg(ct_arg, FeedConstTy::Param(def_id.to_def_id(), identity_args));
-    ty::EarlyBinder::bind(ct)
+    if let Err(e) = icx.check_tainted_by_errors()
+        && !ct.references_error()
+    {
+        ty::EarlyBinder::bind(Const::new_error(tcx, e))
+    } else {
+        ty::EarlyBinder::bind(ct)
+    }
 }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1383,6 +1383,21 @@ fn should_encode_const(def_kind: DefKind) -> bool {
     }
 }
 
+fn should_encode_const_of_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: DefKind) -> bool {
+    matches!(def_kind, DefKind::Const | DefKind::AssocConst)
+        && find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
+        // AssocConst ==> assoc item has value
+        && (!matches!(def_kind, DefKind::AssocConst) || assoc_item_has_value(tcx, def_id))
+}
+
+fn assoc_item_has_value<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
+    let assoc_item = tcx.associated_item(def_id);
+    match assoc_item.container {
+        ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
+        ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
+    }
+}
+
 impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     fn encode_attrs(&mut self, def_id: LocalDefId) {
         let tcx = self.tcx;
@@ -1604,23 +1619,9 @@ 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(_))
-            {
+            if should_encode_const_of_item(self.tcx, def_id, def_kind) {
                 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_middle/src/query/mod.rs

@@ -293,9 +293,15 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    /// Returns the const of the RHS of a const item.
+    /// Returns the const of the RHS of a (free or assoc) const item, if it is a `#[type_const]`.
+    ///
+    /// When a const item is used in a type-level expression, like in equality for an assoc const
+    /// projection, this allows us to retrieve the typesystem-appropriate representation of the
+    /// const value.
+    ///
+    /// This query will ICE if given a const that is not marked with `#[type_const]`.
     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)  }
+        desc { |tcx| "computing the type-level value for `{}`", tcx.def_path_str(def_id)  }
         cache_on_disk_if { def_id.is_local() }
         separate_provide_extern
     }

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -442,6 +442,13 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
             _ => return ct.super_fold_with(self),
         };
 
+        // Note that the AssocConst and Const cases are unreachable on stable,
+        // unless a `min_generic_const_args` feature gate error has already
+        // been emitted earlier in compilation.
+        //
+        // That's because we can only end up with an Unevaluated ty::Const for a const item
+        // if it was marked with `#[type_const]`. Using this attribute without the mgca
+        // 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(),

tests/crashes/mgca/type_const-only-in-trait.rs

@@ -0,0 +1,23 @@
+//@ known-bug: #132980
+// Move this test to tests/ui/const-generics/mgca/type_const-only-in-trait.rs
+// once fixed.
+
+#![expect(incomplete_features)]
+#![feature(associated_const_equality, min_generic_const_args)]
+
+trait GoodTr {
+    #[type_const]
+    const NUM: usize;
+}
+
+struct BadS;
+
+impl GoodTr for BadS {
+    const NUM: usize = 42;
+}
+
+fn accept_good_tr<const N: usize, T: GoodTr<NUM = { N }>>(_x: &T) {}
+
+fn main() {
+    accept_good_tr(&BadS);
+}

tests/ui/const-generics/mgca/type_const-only-in-impl.rs

@@ -0,0 +1,20 @@
+#![expect(incomplete_features)]
+#![feature(associated_const_equality, min_generic_const_args)]
+
+trait BadTr {
+    const NUM: usize;
+}
+
+struct GoodS;
+
+impl BadTr for GoodS {
+    #[type_const]
+    const NUM: usize = 84;
+}
+
+fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+//~^ ERROR use of trait associated const without `#[type_const]`
+
+fn main() {
+    accept_bad_tr::<84, _>(&GoodS);
+}

tests/ui/const-generics/mgca/type_const-only-in-impl.stderr

@@ -0,0 +1,10 @@
+error: use of trait associated const without `#[type_const]`
+  --> $DIR/type_const-only-in-impl.rs:15:43
+   |
+LL | fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+   |                                           ^^^^^^^^^^^
+   |
+   = note: the declaration in the trait must be marked with `#[type_const]`
+
+error: aborting due to 1 previous error
+