Implement type_const impl validity check; fix bug in generics_of

Author: camelid

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -18,7 +18,7 @@ use rustc_middle::ty::{
     TypeSuperFoldable, TypeVisitableExt, TypingMode, Upcast,
 };
 use rustc_middle::{bug, span_bug};
-use rustc_span::Span;
+use rustc_span::{Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
@@ -46,7 +46,9 @@ pub(super) fn compare_impl_item(
     match impl_item.kind {
         ty::AssocKind::Fn => compare_impl_method(tcx, impl_item, trait_item, impl_trait_ref),
         ty::AssocKind::Type => compare_impl_ty(tcx, impl_item, trait_item, impl_trait_ref),
-        ty::AssocKind::Const => compare_impl_const(tcx, impl_item, trait_item, impl_trait_ref),
+        ty::AssocKind::Const => {
+            compare_impl_const(tcx, impl_item_def_id, impl_item, trait_item, impl_trait_ref)
+        }
     }
 }
 
@@ -1769,14 +1771,59 @@ fn compare_generic_param_kinds<'tcx>(
 
 fn compare_impl_const<'tcx>(
     tcx: TyCtxt<'tcx>,
+    impl_item_def_id: LocalDefId,
     impl_const_item: ty::AssocItem,
     trait_const_item: ty::AssocItem,
     impl_trait_ref: ty::TraitRef<'tcx>,
 ) -> Result<(), ErrorGuaranteed> {
     compare_number_of_generics(tcx, impl_const_item, trait_const_item, false)?;
     compare_generic_param_kinds(tcx, impl_const_item, trait_const_item, false)?;
     check_region_bounds_on_impl_item(tcx, impl_const_item, trait_const_item, false)?;
-    compare_const_predicate_entailment(tcx, impl_const_item, trait_const_item, impl_trait_ref)
+    compare_const_predicate_entailment(tcx, impl_const_item, trait_const_item, impl_trait_ref)?;
+    check_type_const_satisfied(tcx, impl_item_def_id, trait_const_item)
+}
+
+fn check_type_const_satisfied<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    impl_item_def_id: LocalDefId,
+    trait_ct: ty::AssocItem,
+) -> Result<(), ErrorGuaranteed> {
+    // Only need to check if mgca is enabled.
+    // Only need to check it if the trait const was actually marked with the attr.
+    if !tcx.features().min_generic_const_args() || !tcx.has_attr(trait_ct.def_id, sym::type_const) {
+        return Ok(());
+    }
+
+    let (_, ct_body, ct_arg) =
+        tcx.hir_node_by_def_id(impl_item_def_id).expect_impl_item().expect_const();
+    if let Some(ct_arg) = ct_arg {
+        match ct_arg {
+            hir::ConstArg { kind: hir::ConstArgKind::Path(..), .. } => return Ok(()),
+            _ => unreachable!("only const paths are created here currently"),
+        }
+    }
+
+    let body = tcx.hir_body(ct_body);
+    let hir::ExprKind::ConstBlock(ct_block) = body.value.kind else {
+        unreachable!("always lowered to const block")
+    };
+    let generics = tcx.generics_of(ct_block.def_id);
+    // FIXME(mgca): we exclude own params since they include synthetic params created for the const's type
+    // but are there cases where own params could exist that would be a problem?
+    if generics.parent_count == 0 {
+        return Ok(());
+    }
+
+    let mut diag = tcx.dcx().struct_span_err(
+        tcx.def_span(ct_block.def_id),
+        "assoc const body is not safe for type system usage",
+    );
+    diag.note(format!("the body uses generic parameters in nontrivial computations"));
+    diag.span_note(
+        tcx.def_span(trait_ct.def_id),
+        "the `#[type_const]` declaration in the trait required this",
+    );
+    Err(diag.emit())
 }
 
 /// The equivalent of [compare_method_predicate_entailment], but for associated constants

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -204,7 +204,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             // HACK(mgca): we lower non-path const item bodies as const blocks
             // so we can control use of generics independently from the const item's type etc
             if tcx.features().min_generic_const_args()
-                && is_const_item(tcx.parent_hir_node(hir_id))
+                && is_const_item(tcx.parent_hir_node(tcx.parent_hir_id(hir_id)))
                 && !does_body_reference_generics(tcx, *body)
             {
                 // If the body doesn't reference any generic params, we don't inherit from the parent.

tests/ui/const-generics/mgca/assoc-const.rs

@@ -8,6 +8,10 @@ pub trait Tr<X> {
     const SIZE: usize;
 }
 
+impl<X> Tr<X> for () {
+    const SIZE: usize = 42;
+}
+
 fn mk_array<T: Tr<bool>>(_x: T) -> [(); <T as Tr<bool>>::SIZE] {
     [(); T::SIZE]
 }

tests/ui/const-generics/mgca/bad-assoc-const.rs

@@ -0,0 +1,18 @@
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+
+pub trait Tr<X> {
+    #[type_const]
+    const SIZE: usize;
+}
+
+impl<X> Tr<X> for () {
+    const SIZE: usize = 42;
+}
+
+impl<const N: usize> Tr<[(); N]> for i32 {
+    const SIZE: usize = 42 + N;
+    //~^ ERROR assoc const body is not safe for type system usage
+}
+
+fn main() {}

tests/ui/const-generics/mgca/bad-assoc-const.stderr

@@ -0,0 +1,15 @@
+error: assoc const body is not safe for type system usage
+  --> $DIR/bad-assoc-const.rs:14:25
+   |
+LL |     const SIZE: usize = 42 + N;
+   |                         ^^^^^^
+   |
+   = note: the body uses generic parameters in nontrivial computations
+note: the `#[type_const]` declaration in the trait required this
+  --> $DIR/bad-assoc-const.rs:6:5
+   |
+LL |     const SIZE: usize;
+   |     ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+