Auto merge of #142293 - fmease:gci-dont-eval-the-impossible, r=<try>

[early rough draft] GCI: Don't evaluate free const items with impossible predicates

Author: rust-bors[bot]

compiler/rustc_hir_analysis/src/lib.rs

@@ -239,12 +239,19 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
                 check::maybe_check_static_with_link_section(tcx, item_def_id);
             }
             DefKind::Const if !tcx.generics_of(item_def_id).own_requires_monomorphization() => {
-                // FIXME(generic_const_items): Passing empty instead of identity args is fishy but
-                //                             seems to be fine for now. Revisit this!
-                let instance = ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());
-                let cid = GlobalId { instance, promoted: None };
-                let typing_env = ty::TypingEnv::fully_monomorphized();
-                tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));
+                let predicates = tcx.predicates_of(item_def_id);
+                let predicates = predicates.instantiate_identity(tcx).predicates;
+
+                // FIXME(fmease): May its result be 'incorrect' if the preds have ReEarlyBound?
+                if !traits::impossible_predicates(tcx, predicates) {
+                    // FIXME(generic_const_items): Passing empty instead of identity args is fishy but
+                    //                             seems to be fine for now. Revisit this!
+                    let instance =
+                        ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());
+                    let cid = GlobalId { instance, promoted: None };
+                    let typing_env = ty::TypingEnv::fully_monomorphized();
+                    tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));
+                }
             }
             _ => (),
         }

compiler/rustc_middle/src/mir/interpret/queries.rs

@@ -13,7 +13,7 @@ use crate::ty::{self, GenericArgs, TyCtxt, TypeVisitableExt};
 
 impl<'tcx> TyCtxt<'tcx> {
     /// Evaluates a constant without providing any generic parameters. This is useful to evaluate consts
-    /// that can't take any generic arguments like const items or enum discriminants. If a
+    /// that can't take any generic arguments like enum discriminants. If a
     /// generic parameter is used within the constant `ErrorHandled::TooGeneric` will be returned.
     #[instrument(skip(self), level = "debug")]
     pub fn const_eval_poly(self, def_id: DefId) -> EvalToConstValueResult<'tcx> {
@@ -29,7 +29,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     /// Evaluates a constant without providing any generic parameters. This is useful to evaluate consts
-    /// that can't take any generic arguments like const items or enum discriminants. If a
+    /// that can't take any generic arguments like enum discriminants. If a
     /// generic parameter is used within the constant `ErrorHandled::TooGeneric` will be returned.
     #[instrument(skip(self), level = "debug")]
     pub fn const_eval_poly_to_alloc(self, def_id: DefId) -> EvalToAllocationRawResult<'tcx> {

compiler/rustc_monomorphize/src/collector.rs

@@ -1486,13 +1486,18 @@ impl<'v> RootCollector<'_, 'v> {
                 self.output.push(dummy_spanned(MonoItem::Static(def_id)));
             }
             DefKind::Const => {
+                let def_id = id.owner_id.to_def_id();
                 // Const items only generate mono items if they are actually used somewhere.
                 // Just declaring them is insufficient.
 
                 // But even just declaring them must collect the items they refer to
                 // unless their generics require monomorphization.
-                if !self.tcx.generics_of(id.owner_id).own_requires_monomorphization()
-                    && let Ok(val) = self.tcx.const_eval_poly(id.owner_id.to_def_id())
+                if !self.tcx.generics_of(def_id).own_requires_monomorphization()
+                    && !self.tcx.instantiate_and_check_impossible_predicates((
+                        def_id,
+                        ty::GenericArgs::identity_for_item(self.tcx, def_id),
+                    ))
+                    && let Ok(val) = self.tcx.const_eval_poly(def_id)
                 {
                     collect_const_value(self.tcx, val, self.output);
                 }

compiler/rustc_passes/src/reachable.rs

@@ -37,6 +37,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, ExistentialTraitRef, TyCtxt};
 use rustc_privacy::DefIdVisitor;
 use rustc_session::config::CrateType;
+use rustc_trait_selection::traits;
 use tracing::debug;
 
 /// Determines whether this item is recursive for reachability. See `is_recursively_reachable_local`
@@ -205,19 +206,35 @@ impl<'tcx> ReachableContext<'tcx> {
                     }
 
                     hir::ItemKind::Const(_, _, _, init) => {
-                        // Only things actually ending up in the final constant value are reachable
-                        // for codegen. Everything else is only needed during const-eval, so even if
-                        // const-eval happens in a downstream crate, all they need is
-                        // `mir_for_ctfe`.
+                        if self.tcx.generics_of(item.owner_id).own_requires_monomorphization() {
+                            // In this case, we don't want to evaluate the const initializer.
+                            // In lieu of that, we have to consider everything mentioned in it
+                            // as reachable, since it *may* end up in the final value.
+                            self.visit_nested_body(init);
+                            return;
+                        }
+
+                        let predicates = self.tcx.predicates_of(item.owner_id);
+                        let predicates = predicates.instantiate_identity(self.tcx).predicates;
+                        // FIXME(fmease): May its result be 'incorrect' if the preds have ReEarlyBound?
+                        if traits::impossible_predicates(self.tcx, predicates) {
+                            // The constant is impossible to reference.
+                            // Therefore nothing can be reachable via it.
+                            return;
+                        }
+
                         match self.tcx.const_eval_poly_to_alloc(item.owner_id.def_id.into()) {
                             Ok(alloc) => {
+                                // Only things actually ending up in the final constant value are
+                                // reachable for codegen. Everything else is only needed during
+                                // const-eval, so even if const-eval happens in a downstream crate,
+                                // all they need is `mir_for_ctfe`.
                                 let alloc = self.tcx.global_alloc(alloc.alloc_id).unwrap_memory();
                                 self.propagate_from_alloc(alloc);
                             }
-                            // We can't figure out which value the constant will evaluate to. In
-                            // lieu of that, we have to consider everything mentioned in the const
-                            // initializer reachable, since it *may* end up in the final value.
-                            Err(ErrorHandled::TooGeneric(_)) => self.visit_nested_body(init),
+                            // We've checked at the start that there aren't any non-lifetime params
+                            // in scope. The const initializer can't possibly be too generic.
+                            Err(ErrorHandled::TooGeneric(_)) => bug!(),
                             // If there was an error evaluating the const, nothing can be reachable
                             // via it, and anyway compilation will fail.
                             Err(ErrorHandled::Reported(..)) => {}

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -719,8 +719,13 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>(
 /// returns true, then either normalize encountered an error or one of the predicates did not
 /// hold. Used when creating vtables to check for unsatisfiable methods. This should not be
 /// used during analysis.
+#[instrument(level = "debug", skip(tcx))]
 pub fn impossible_predicates<'tcx>(tcx: TyCtxt<'tcx>, predicates: Vec<ty::Clause<'tcx>>) -> bool {
-    debug!("impossible_predicates(predicates={:?})", predicates);
+    // FIXME(fmease): Explainer.
+    if std::env::var_os("XOXO").is_some() {
+        debug_assert!(!predicates.has_non_region_param());
+    }
+
     let (infcx, param_env) = tcx
         .infer_ctxt()
         .with_next_trait_solver(true)

tests/codegen/dont_codegen_private_const_fn_only_used_in_const_eval.rs

@@ -0,0 +1,29 @@
+//! Check that we — where possible — don't codegen functions that are only used to evaluate
+//! static/const items, but never used in runtime code.
+
+//@ compile-flags: --crate-type=lib -Copt-level=0
+
+#![feature(generic_const_items)] // only used for latter test cases
+
+const fn foo() {}
+pub static FOO: () = foo();
+// CHECK-NOT: define{{.*}}foo{{.*}}
+
+const fn bar() {}
+pub const BAR: () = bar();
+// CHECK-NOT: define{{.*}}bar{{.*}}
+
+// We don't / can't evaluate the const initializer of `BAZ` because it's too generic. As a result,
+// we can't tell during reachability analysis if `baz` ends up in the final value or if it's only
+// used during const eval (just by looking at it here, it's obvious that it isn't needed at runtime;
+// it's a limitation of the compiler that it can't figure that out).
+const fn baz() {}
+pub const BAZ<const C: bool>: () = if C { baz() };
+// CHECK: define{{.*}}baz{{.*}}
+
+// The const `BAN` is impossible to reference and thus, we don't need to codegen `ban`.
+const fn ban() {}
+pub const BAN: fn() = ban
+where
+    for<'_delay> String: Copy;
+// CHECK-NOT: define{{.*}}ban{{.*}}

tests/codegen/private-const-fn-only-used-in-const-eval.rs

@@ -1,11 +1,11 @@
-#![feature(generic_const_items, trivial_bounds)]
-#![allow(incomplete_features)]
+#![feature(generic_const_items)]
+#![expect(incomplete_features)]
 
 // Ensure that we check if trivial bounds on const items hold or not.
 
-const UNUSABLE: () = () //~ ERROR entering unreachable code
+const UNUSABLE: () = ()
 where
-    String: Copy;
+    for<'_delay> String: Copy;
 
 fn main() {
     let _ = UNUSABLE; //~ ERROR the trait bound `String: Copy` is not satisfied

tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.rs

@@ -1,27 +1,18 @@
-error[E0080]: entering unreachable code
-  --> $DIR/trivially-unsatisfied-bounds-0.rs:6:1
-   |
-LL | / const UNUSABLE: () = ()
-LL | | where
-LL | |     String: Copy;
-   | |_________________^ evaluation of `UNUSABLE` failed here
-
 error[E0277]: the trait bound `String: Copy` is not satisfied
   --> $DIR/trivially-unsatisfied-bounds-0.rs:11:13
    |
 LL |     let _ = UNUSABLE;
    |             ^^^^^^^^ the trait `Copy` is not implemented for `String`
    |
 note: required by a bound in `UNUSABLE`
-  --> $DIR/trivially-unsatisfied-bounds-0.rs:8:13
+  --> $DIR/trivially-unsatisfied-bounds-0.rs:8:26
    |
 LL | const UNUSABLE: () = ()
    |       -------- required by a bound in this constant
 LL | where
-LL |     String: Copy;
-   |             ^^^^ required by this bound in `UNUSABLE`
+LL |     for<'_delay> String: Copy;
+   |                          ^^^^ required by this bound in `UNUSABLE`
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0080, E0277.
-For more information about an error, try `rustc --explain E0080`.
+For more information about this error, try `rustc --explain E0277`.

tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.stderr

@@ -1,12 +1,12 @@
-#![feature(generic_const_items, trivial_bounds)]
-#![allow(incomplete_features, dead_code, trivial_bounds)]
+//@ check-pass
+#![feature(generic_const_items)]
+#![expect(incomplete_features)]
+#![crate_type = "lib"]
 
-// FIXME(generic_const_items): This looks like a bug to me. I expected that we wouldn't emit any
-// errors. I thought we'd skip the evaluation of consts whose bounds don't hold.
-
-const UNUSED: () = ()
+const _UNUSED: () = ()
 where
-    String: Copy;
-//~^^^ ERROR unreachable code
+    for<'_delay> String: Copy;
 
-fn main() {}
+pub const PUBLIC: () = ()
+where
+    for<'_delay> String: Copy;