GCI: Imply outlives-bounds on free (generic) const items

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -137,8 +137,10 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                     }
                 }
             }
-            ItemKind::Const(ident, _, ty, rhs) => {
-                if ty.is_suggestable_infer_ty() {
+            ItemKind::Const(ident, generics, ty, rhs) => {
+                // We can't infer the type of parameterized const items without causing a query
+                // cycle (typeck -..> inferred_outlives_of -..> type_of -> typeck), so let's not.
+                if generics.params.is_empty() && ty.is_suggestable_infer_ty() {
                     infer_placeholder_type(
                         icx.lowerer(),
                         def_id,

compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs

@@ -8,18 +8,13 @@ use tracing::debug;
 use super::explicit::ExplicitPredicatesMap;
 use super::utils::*;
 
-/// Infer predicates for the items in the crate.
-///
-/// `global_inferred_outlives`: this is initially the empty map that
-///     was generated by walking the items in the crate. This will
-///     now be filled with inferred predicates.
+/// Infer outlives-predicates for the items in the local crate.
 pub(super) fn infer_predicates(
     tcx: TyCtxt<'_>,
 ) -> FxIndexMap<DefId, ty::EarlyBinder<'_, RequiredPredicates<'_>>> {
     debug!("infer_predicates");
 
     let mut explicit_map = ExplicitPredicatesMap::new();
-
     let mut global_inferred_outlives = FxIndexMap::default();
 
     // If new predicates were added then we need to re-calculate
@@ -58,7 +53,6 @@ pub(super) fn infer_predicates(
                         );
                     }
                 }
-
                 DefKind::TyAlias if tcx.type_alias_is_lazy(item_did) => {
                     insert_required_predicates_to_be_wf(
                         tcx,
@@ -69,7 +63,23 @@ pub(super) fn infer_predicates(
                         &mut explicit_map,
                     );
                 }
-
+                // HACK(generic_const_items): We have to explicitly disqualify const items that do
+                // not have any parameters to break certain query cycles that would otherwise occur
+                // when `typeck`'ing const items which we would only do if its type signature was
+                // ill-formed due to it missing or containing inferred types `_`.
+                //
+                // This is correct as we only ever imply outlives-predicates where the outlived
+                // region is early-bound ... for which the item must have generic parameters.
+                DefKind::Const { .. } if !tcx.generics_of(item_did).is_empty() => {
+                    insert_required_predicates_to_be_wf(
+                        tcx,
+                        tcx.type_of(item_did).instantiate_identity(),
+                        tcx.def_span(item_did),
+                        &global_inferred_outlives,
+                        &mut item_required_predicates,
+                        &mut explicit_map,
+                    );
+                }
                 _ => {}
             };
 
@@ -312,7 +322,7 @@ fn check_explicit_predicates<'tcx>(
     }
 }
 
-/// Check the inferred predicates declared on the type.
+/// Check the inferred predicates of the type.
 ///
 /// ### Example
 ///

compiler/rustc_hir_analysis/src/outlives/mod.rs

@@ -13,17 +13,11 @@ pub(super) fn inferred_outlives_of(
     item_def_id: LocalDefId,
 ) -> &[(ty::Clause<'_>, Span)] {
     match tcx.def_kind(item_def_id) {
-        DefKind::Struct | DefKind::Enum | DefKind::Union => {
-            let crate_map = tcx.inferred_outlives_crate(());
-            crate_map.predicates.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
-        }
-        DefKind::TyAlias if tcx.type_alias_is_lazy(item_def_id) => {
-            let crate_map = tcx.inferred_outlives_crate(());
-            crate_map.predicates.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
-        }
+        DefKind::Struct | DefKind::Enum | DefKind::Union | DefKind::Const { .. } => {}
+        DefKind::TyAlias if tcx.type_alias_is_lazy(item_def_id) => {}
         DefKind::AnonConst if tcx.features().generic_const_exprs() => {
             let id = tcx.local_def_id_to_hir_id(item_def_id);
-            if tcx.hir_opt_const_param_default_param_def_id(id).is_some() {
+            return if tcx.hir_opt_const_param_default_param_def_id(id).is_some() {
                 // In `generics_of` we set the generics' parent to be our parent's parent which means that
                 // we lose out on the predicates of our actual parent if we dont return those predicates here.
                 // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
@@ -40,21 +34,23 @@ pub(super) fn inferred_outlives_of(
                 tcx.inferred_outlives_of(item_def_id)
             } else {
                 &[]
-            }
+            };
         }
-        _ => &[],
+        _ => return &[],
+    }
+
+    if tcx.generics_of(item_def_id).is_empty() {
+        // Fast path.
+        return &[];
     }
+
+    let crate_map = tcx.inferred_outlives_crate(());
+    crate_map.predicates.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
 }
 
+/// Compute a map from each applicable item in the local crate to its
+/// inferred / implied outlives-predicates.
 pub(super) fn inferred_outlives_crate(tcx: TyCtxt<'_>, (): ()) -> CratePredicatesMap<'_> {
-    // Compute a map from each ADT (struct/enum/union) and lazy type alias to
-    // the **explicit** outlives predicates (`T: 'a`, `'a: 'b`) that the user wrote.
-    // Typically there won't be many of these, except in older code where
-    // they were mandatory. Nonetheless, we have to ensure that every such
-    // predicate is satisfied, so they form a kind of base set of requirements
-    // for the type.
-
-    // Compute the inferred predicates
     let global_inferred_outlives = implicit_infer::infer_predicates(tcx);
 
     // Convert the inferred predicates into the "collected" form the

src/doc/rustc-dev-guide/src/traits/implied-bounds.md

@@ -9,9 +9,9 @@ handled... well... implicitly.
 
 ## explicit implied bounds
 
-The explicit implied bounds are computed in [`fn inferred_outlives_of`]. Only ADTs and
-lazy type aliases have explicit implied bounds which are computed via a fixpoint algorithm
-in the [`fn inferred_outlives_crate`] query.
+The explicit implied bounds are computed in [`fn inferred_outlives_of`]. Only ADTs,
+[lazy type aliases][lta] and [free (generic) const items][gci] have explicit implied bounds
+which are computed via a fixpoint algorithm in the [`fn inferred_outlives_crate`] query.
 
 We use [`fn insert_required_predicates_to_be_wf`] on all fields of all ADTs in the crate.
 This function computes the outlives bounds for each component of the field using a
@@ -31,6 +31,8 @@ if the outlived region is a region parameter. [It does not add `'static` require
  [`fn check_explicit_predicates`]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs#L238
  [`fn insert_outlives_predicate`]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_hir_analysis/src/outlives/utils.rs#L15
  [nostatic]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_hir_analysis/src/outlives/utils.rs#L159-L165
+ [lta]: https://github.com/rust-lang/rust/issues/112792
+ [gci]: https://github.com/rust-lang/rust/issues/113521
 
 ## implicit implied bounds
 

tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr

@@ -1,21 +1,3 @@
-error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:41:48
-   |
-LL |     u128: extern "cmse-nonsecure-call" fn() -> u128,
-   |                                                ^^^^ this type doesn't fit in the available registers
-   |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
-   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
-
-error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:42:48
-   |
-LL |     i128: extern "cmse-nonsecure-call" fn() -> i128,
-   |                                                ^^^^ this type doesn't fit in the available registers
-   |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
-   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
-
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/return-via-stack.rs:30:46
    |
@@ -70,6 +52,24 @@ LL |     f6: extern "cmse-nonsecure-call" fn() -> [u8; 5],
    = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
+error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
+  --> $DIR/return-via-stack.rs:41:48
+   |
+LL |     u128: extern "cmse-nonsecure-call" fn() -> u128,
+   |                                                ^^^^ this type doesn't fit in the available registers
+   |
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
+   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
+
+error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
+  --> $DIR/return-via-stack.rs:42:48
+   |
+LL |     i128: extern "cmse-nonsecure-call" fn() -> i128,
+   |                                                ^^^^ this type doesn't fit in the available registers
+   |
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
+   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
+
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/return-via-stack.rs:57:46
    |

tests/ui/dyn-keyword/suggest-struct-or-union-add-generic-impl-trait.stderr

@@ -46,6 +46,17 @@ LL |     A(u32),
 LL ~     B(T),
    |
 
+error[E0782]: expected a type, found a trait
+  --> $DIR/suggest-struct-or-union-add-generic-impl-trait.rs:31:5
+   |
+LL |     Trait:, {}
+   |     ^^^^^
+   |
+help: you can add the `dyn` keyword if you want a trait object
+   |
+LL |     dyn Trait:, {}
+   |     +++
+
 error[E0782]: expected a type, found a trait
   --> $DIR/suggest-struct-or-union-add-generic-impl-trait.rs:35:8
    |
@@ -58,17 +69,6 @@ LL ~ struct HasGenerics<T, U: Trait> {
 LL ~     f: U,
    |
 
-error[E0782]: expected a type, found a trait
-  --> $DIR/suggest-struct-or-union-add-generic-impl-trait.rs:31:5
-   |
-LL |     Trait:, {}
-   |     ^^^^^
-   |
-help: you can add the `dyn` keyword if you want a trait object
-   |
-LL |     dyn Trait:, {}
-   |     +++
-
 error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0782`.

tests/ui/generic-const-items/implied-outlives-bounds-0.neg.stderr

@@ -0,0 +1,18 @@
+error: lifetime may not live long enough
+  --> $DIR/implied-outlives-bounds-0.rs:20:9
+   |
+LL | fn env0<'any>() {
+   |         ---- lifetime `'any` defined here
+LL |     _ = TYPE_OUTLIVES_0::<'static, &'any ()>;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'any` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/implied-outlives-bounds-0.rs:25:9
+   |
+LL | fn env1<'any>() {
+   |         ---- lifetime `'any` defined here
+LL |     _ = REGION_OUTLIVES_0::<'static, 'any>;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'any` must outlive `'static`
+
+error: aborting due to 2 previous errors
+

tests/ui/generic-const-items/implied-outlives-bounds-0.rs

@@ -0,0 +1,28 @@
+// Check that we imply outlives-bounds on (generic) free const items.
+//@ revisions: pos neg
+//@[pos] check-pass
+#![feature(generic_const_items)]
+#![feature(freeze)] // only used in the test case `TYPE_OUTLIVES_1`
+#![expect(incomplete_features)]
+
+const REGION_OUTLIVES_0<'a, 'b>: Option<&'a &'b ()> = None; // we imply `'a: 'b`
+const REGION_OUTLIVES_1<'a, 'b>: &'a &'b () = &&(); // we imply `'a: 'b`
+
+const TYPE_OUTLIVES_0<'a, T>: Option<&'a T> = None; // we imply `T: 'a`
+
+const TYPE_OUTLIVES_1<'a, T: Def>: &'a T = &T::DEF; // we imply `T: 'a`
+trait Def: std::marker::Freeze { const DEF: Self; }
+
+// Ensure that we actually enforce these implied bounds at usage sites:
+
+#[cfg(neg)]
+fn env0<'any>() {
+    _ = TYPE_OUTLIVES_0::<'static, &'any ()>; //[neg]~ ERROR lifetime may not live long enough
+}
+
+#[cfg(neg)]
+fn env1<'any>() {
+    _ = REGION_OUTLIVES_0::<'static, 'any>; //[neg]~ ERROR lifetime may not live long enough
+}
+
+fn main() {}

tests/ui/generic-const-items/implied-outlives-bounds-1.rs

@@ -0,0 +1,26 @@
+// FIXME(fmease): This still needs to be implemented
+//@ ignore-test
+// Check that paths referring to (generic) free const items induce implied bounds.
+//@ revisions: pos neg
+//@[pos] check-pass
+#![feature(generic_const_items, min_generic_const_args)]
+#![expect(incomplete_items)]
+
+// References of `EXP::<'r, 'q>` should induce implied bound `'q: 'r` in the enclosing def.
+type const EXP<'a, 'b: 'a>: usize = 0;
+
+struct Ty<'a, 'b>([(); EXP::<'a, 'b>]); // we imply `'a: 'b`
+const CT<'a, 'b>: [(); EXP::<'a, 'b>] = {
+    let _: &'a &'b (); // OK since `EXP::<'a, 'b>` implies `'a: 'b`
+    []
+};
+
+#[cfg(neg)]
+fn env0<'any>() {
+    let _: Ty<'static, 'any>; //[neg]~ ERROR lifetime may not live long enough
+}
+
+#[cfg(neg)]
+fn env1<'any>() {
+    _ = CT::<'static, 'any>; //[neg]~ ERROR lifetime may not live long enough
+}