GCI: Don't eval the impossible

Author: fmease

Cargo.lock

@@ -4197,6 +4197,7 @@ dependencies = [
  "rustc_span",
  "rustc_symbol_mangling",
  "rustc_target",
+ "rustc_trait_selection",
  "serde",
  "serde_json",
  "tracing",

compiler/rustc_hir_analysis/src/lib.rs

@@ -202,12 +202,23 @@ 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);
+
+                // FIXME: Calling impossible_predicates is likely incorrect.
+                if predicates.predicates.is_empty()
+                    || !rustc_trait_selection::traits::impossible_predicates(
+                        tcx,
+                        predicates.instantiate_identity(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_monomorphize/Cargo.toml

@@ -18,6 +18,7 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
+rustc_trait_selection = { path = "../rustc_trait_selection" }
 serde = "1"
 serde_json = "1"
 tracing = "0.1"

compiler/rustc_monomorphize/src/collector.rs

@@ -1484,6 +1484,12 @@ impl<'v> RootCollector<'_, 'v> {
                 // 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 predicates = self.tcx.predicates_of(id.owner_id)
+                    && (predicates.predicates.is_empty()
+                        || !rustc_trait_selection::traits::impossible_predicates(
+                            self.tcx,
+                            predicates.instantiate_identity(self.tcx).predicates,
+                        ))
                     && let Ok(val) = self.tcx.const_eval_poly(id.owner_id.to_def_id())
                 {
                     collect_const_value(self.tcx, val, self.output);

compiler/rustc_passes/src/reachable.rs

@@ -205,22 +205,32 @@ 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`.
-                        match self.tcx.const_eval_poly_to_alloc(item.owner_id.def_id.into()) {
-                            Ok(alloc) => {
-                                let alloc = self.tcx.global_alloc(alloc.alloc_id).unwrap_memory();
-                                self.propagate_from_alloc(alloc);
+                        let predicates = self.tcx.predicates_of(item.owner_id);
+
+                        if predicates.predicates.is_empty()
+                            || !rustc_trait_selection::traits::impossible_predicates(
+                                self.tcx,
+                                predicates.instantiate_identity(self.tcx).predicates,
+                            )
+                        {
+                            // 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`.
+                            match self.tcx.const_eval_poly_to_alloc(item.owner_id.def_id.into()) {
+                                Ok(alloc) => {
+                                    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),
+                                // If there was an error evaluating the const, nothing can be reachable
+                                // via it, and anyway compilation will fail.
+                                Err(ErrorHandled::Reported(..)) => {}
                             }
-                            // 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),
-                            // If there was an error evaluating the const, nothing can be reachable
-                            // via it, and anyway compilation will fail.
-                            Err(ErrorHandled::Reported(..)) => {}
                         }
                     }
                     hir::ItemKind::Static(..) => {

tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.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.stderr

@@ -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-1.rs

@@ -1,12 +1,13 @@
-#![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: () = ()
+where
+    for<'_delay> String: Copy;
 
-const UNUSED: () = ()
+pub const PUB: () = ()
 where
-    String: Copy;
-//~^^^ ERROR unreachable code
+    for<'_delay> String: Copy;
 
-fn main() {}