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

Author: fmease

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,16 @@ pub(super) fn infer_predicates(
                         &mut explicit_map,
                     );
                 }
-
+                DefKind::Const => {
+                    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 +315,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/generic-const-items/assoc-const-missing-type.rs

@@ -0,0 +1,18 @@
+error: lifetime may not live long enough
+  --> $DIR/implied-outlives-bounds.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.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/assoc-const-missing-type.stderr

@@ -0,0 +1,28 @@
+// Check that we imply outlives-bounds on 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.neg.stderr

@@ -0,0 +1,39 @@
+// Ensure that we properly deal with missing signatures and inferred types `_` in the signature.
+#![feature(generic_const_items)]
+#![expect(incomplete_features)]
+
+// For implicit & explicit inferred types in the item signature we generally try to infer the
+// type of the body which we can then suggest to the user.
+
+// However, in the type of trait impl assoc items specifically we first try to suggest the type of
+// the corresponding definition in the trait. While doing so, we once didn't use to instantiate GACs
+// correctly & couldn't handle mismatches in parameter list lengths very well (impl v trait).
+// issue: <https://github.com/rust-lang/rust/issues/124833>
+
+trait Trait {
+    const K<T>: T;
+    const Q<'a>: &'a str;
+}
+
+impl Trait for () {
+    const K<T> = ();
+    //~^ ERROR missing type for `const` item
+    //~| ERROR mismatched types
+    //~| SUGGESTION  ()
+     const Q = "";
+    //~^ ERROR missing type for `const` item
+    //~| ERROR lifetime parameters or bounds on associated constant `Q` do not match the trait declaration
+    //~| SUGGESTION : &str
+}
+
+// For parametrized free const items however, we can't typeck the body without causing a query cycle,
+// so we don't and thus fall back to a generic suggestion that has a placeholder.
+
+const _<T> = loop {};
+//~^ ERROR missing type for `const` item
+//~| SUGGESTION <type>
+
+const _<T>: _ = 0;
+//~^ ERROR the placeholder `_` is not allowed
+
+fn main() {}

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

@@ -0,0 +1,53 @@
+error[E0308]: mismatched types
+  --> $DIR/missing-or-inferred-type.rs:19:18
+   |
+LL |     const K<T> = ();
+   |             -    ^^ expected type parameter `T`, found `()`
+   |             |
+   |             expected this type parameter
+   |
+   = note: expected type parameter `T`
+                   found unit type `()`
+
+error: missing type for `const` item
+  --> $DIR/missing-or-inferred-type.rs:19:15
+   |
+LL |     const K<T> = ();
+   |               ^ help: provide a type for the associated constant: `()`
+
+error[E0195]: lifetime parameters or bounds on associated constant `Q` do not match the trait declaration
+  --> $DIR/missing-or-inferred-type.rs:23:13
+   |
+LL |     const Q<'a>: &'a str;
+   |            ---- lifetimes in impl do not match this associated constant in trait
+...
+LL |      const Q = "";
+   |             ^ lifetimes do not match associated constant in trait
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
+  --> $DIR/missing-or-inferred-type.rs:36:13
+   |
+LL | const _<T>: _ = 0;
+   |             ^ not allowed in type signatures
+
+error: missing type for `const` item
+  --> $DIR/missing-or-inferred-type.rs:23:13
+   |
+LL |      const Q = "";
+   |             ^ help: provide a type for the associated constant: `: &str`
+
+error: missing type for `const` item
+  --> $DIR/missing-or-inferred-type.rs:32:11
+   |
+LL | const _<T> = loop {};
+   |           ^
+   |
+help: provide a type for the item
+   |
+LL | const _<T>: <type> = loop {};
+   |           ++++++++
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0121, E0195, E0308.
+For more information about an error, try `rustc --explain E0121`.