[ICE]: could not normalize `Foo: 'static`

[matthiaskrgr]

Code

//@ compile-flags -Znext-solver=globally
#![feature(lazy_type_alias)]
#![feature(trivial_bounds)]
type Foo
    = ()
where
    Foo: 'static;

fn main() {}

Meta

rustc --version --verbose:

rustc 1.97.0-nightly (507271bc1 2026-05-17)
binary: rustc
commit-hash: 507271bc119683008ec719ecee48814e8ac86c65
commit-date: 2026-05-17
host: x86_64-unknown-linux-gnu
release: 1.97.0-nightly
LLVM version: 22.1.4

Error output

<output>

Backtrace

warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
 --> a.rs:2:12
  |
2 | #![feature(lazy_type_alias)]
  |            ^^^^^^^^^^^^^^^
  |
  = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
  = note: `#[warn(incomplete_features)]` on by default

warning: type alias `Foo` is never used
 --> a.rs:4:6
  |
4 | type Foo
  |      ^^^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: lifetime bound Foo: 'static does not depend on any type or lifetime parameters
 --> a.rs:7:10
  |
7 |     Foo: 'static;
  |          ^^^^^^^
  |
  = note: `#[warn(trivial_bounds)]` on by default

warning: 3 warnings emitted

note: no errors encountered even though delayed bugs were created

note: those delayed bugs will now be shown as internal compiler errors

error: internal compiler error: could not normalize `Foo: 'static`
  |
  = note: delayed at /rustc-dev/507271bc119683008ec719ecee48814e8ac86c65/compiler/rustc_trait_selection/src/regions.rs:42:41
             0: <rustc_errors::DiagCtxtInner>::emit_diagnostic
             1: <rustc_errors::DiagCtxtHandle>::emit_diagnostic
             2: <rustc_span::ErrorGuaranteed as rustc_errors::diagnostic::EmissionGuarantee>::emit_producing_guarantee
             3: <rustc_errors::DiagCtxtHandle>::delayed_bug::<alloc::string::String>
             4: <rustc_infer::infer::outlives::env::OutlivesEnvironment as rustc_trait_selection::regions::OutlivesEnvironmentBuildExt>::new_with_implied_bounds_compat::<core::iter::adapters::copied::Copied<indexmap::set::iter::Iter<rustc_middle::ty::Ty>>>
             5: rustc_hir_analysis::check::check::check_item_type
             6: rustc_hir_analysis::check::wfcheck::check_well_formed
             7: rustc_query_impl::query_impl::check_well_formed::invoke_provider_fn::__rust_begin_short_backtrace
             8: rustc_query_impl::execution::try_execute_query::<rustc_data_structures::vec_cache::VecCache<rustc_span::def_id::LocalDefId, rustc_middle::query::erase::ErasedData<[u8; 1]>, rustc_middle::dep_graph::graph::DepNodeIndex>, false>
             9: rustc_query_impl::query_impl::check_well_formed::execute_query_non_incr::__rust_end_short_backtrace
            10: rustc_hir_analysis::check::wfcheck::check_type_wf
            11: rustc_query_impl::query_impl::check_type_wf::invoke_provider_fn::__rust_begin_short_backtrace
            12: rustc_query_impl::execution::try_execute_query::<rustc_middle::query::caches::SingleCache<rustc_middle::query::erase::ErasedData<[u8; 1]>>, false>
            13: rustc_query_impl::query_impl::check_type_wf::execute_query_non_incr::__rust_end_short_backtrace
            14: rustc_hir_analysis::check_crate
            15: rustc_interface::passes::analysis
            16: rustc_query_impl::execution::try_execute_query::<rustc_middle::query::caches::SingleCache<rustc_middle::query::erase::ErasedData<[u8; 0]>>, false>
            17: rustc_query_impl::query_impl::analysis::execute_query_non_incr::__rust_end_short_backtrace
            18: rustc_interface::interface::run_compiler::<(), rustc_driver_impl::run_compiler::{closure#0}>::{closure#1}
            19: std::sys::backtrace::__rust_begin_short_backtrace::<rustc_interface::util::run_in_thread_with_globals<rustc_interface::util::run_in_thread_pool_with_globals<rustc_interface::interface::run_compiler<(), rustc_driver_impl::run_compiler::{closure#0}>::{closure#1}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>
            20: <std::thread::lifecycle::spawn_unchecked<rustc_interface::util::run_in_thread_with_globals<rustc_interface::util::run_in_thread_pool_with_globals<rustc_interface::interface::run_compiler<(), rustc_driver_impl::run_compiler::{closure#0}>::{closure#1}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
            21: <std::sys::thread::unix::Thread>::new::thread_start
            22: <unknown>
            23: <unknown>


note: we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new?labels=C-bug%2C+I-ICE%2C+T-compiler&template=ice.md

note: please make sure that you have updated to the latest nightly

note: please attach the file at `/tmp/im4/2/rustc-ice-2026-05-18T09_14_18-2216916.txt` to your bug report

note: rustc 1.97.0-nightly (507271bc1 2026-05-17) running on x86_64-unknown-linux-gnu

note: compiler flags: -Z next-solver=globally

query stack during panic:
end of query stack

[Dnreikronos]

I've been digging into this. The ICE comes from compiler/rustc_trait_selection/src/regions.rs when building the OutlivesEnvironment during wf checking.

Here's the cycle:

1. new_with_implied_bounds_compat iterates param_env bounds and deeply normalizes each TypeOutlives predicate
2. For Foo: 'static, the solver enters normalize_free_alias, which adds predicates_of(Foo) as sub-goals, and that includes Foo: 'static itself
3. Proving Foo: 'static requires normalizing Foo again, which creates a cycle and normalization fails
4. delayed_bug fires, but trivial_bounds suppressed the overflow error that would otherwise exist, so there's no real error to back it up. ICE.

The fix I'm working on replaces the delayed_bug with continue (skip the bound on normalization failure). If normalization fails due to a real error, that error was already emitted during obligation evaluation in enter_wf_checking_ctxt. If it fails due to a self-referential cycle like this, the bound doesn't contribute useful region information anyway.

One thing I keep thinking about though: should the next solver be able to handle this cycle without failing in the first place? Right now the where-clause goals in normalize_free_alias use GoalSource::Misc, which maps to PathKind::Unknown, which means ambiguity on cycle. It feels like there's a longer-term question about how TypeOutlives goals interact with alias normalization. Ideally, proving Foo: 'static shouldn't need to re-normalize Foo when we're already in the middle of normalizing it.

Curious what you think about this approach. Would also like to hear if anyone on the types team has thoughts on the solver-level interaction here.

@matthiaskrgr

[fmease]

Feature trivial_bounds can trivially be made unnecessary by introducing an (unused) higher-ranked binder:

//@ compile-flags: -Znext-solver=globally
#![feature(lazy_type_alias)]

type Foo
    = ()
where
    for<'_delay> Foo: 'static;

fn main() {}

[fmease]

Do note however that I can no longer repro this. This repro (adjusted for the new feature name) doesn't ICE on nightly 2026-08-21 (which has the next solver enabled by default):

#![feature(checked_type_aliases)]

type Foo
    = ()
where
    for<'_delay> Foo: 'static;

fn main() {}

instead it now errors with

error[E0275]: overflow evaluating the requirement `Foo == _`
 --> cta.rs:3:1
  |
3 | type Foo
  | ^^^^^^^^

[fmease]

However I want to hold off on adding any sort of regression test since I've yet to read Dnreikronos's comment / figure out which PR fixed this to be able to determine whether this was fixed for good by some PR or if it's now only masked and can be repro'd differently.