[Work Item]: normalize instead of evaluating type const patterns

[BoxyUwU]

currently using a type const in a pattern, e.g. type const FOO: usize = 1_usize; if let FOO = 1 {} ICEs as we try to invoke const eval on FOO to evaluate the pattern. We should instead check if the constant is a type const and if so call try_normalize_erasing_regions.

Related to #105 in that we'll get this "for free" once const patterns are cleaned up, but we probably don't want to wait for that :)

[Shourya742]

Can I work on this?

The backtrace came out pretty;

Backtrace

   Compiling playground v0.0.1 (/playground)
warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
 --> src/main.rs:1:12
  |
1 | #![feature(min_generic_const_args)]
  |            ^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
  = note: `#[warn(incomplete_features)]` on by default

error: internal compiler error: /rustc-dev/f20a92ec01483dc5c58e90e246f266bdad822d86/compiler/rustc_hir_typeck/src/lib.rs:122:9: can't type-check body of DefId(0:3 ~ playground[adaf]::FOO)
 --> src/main.rs:3:1
  |
3 | type const FOO: usize = 1_usize;
  | ^^^^^^^^^^^^^^^^^^^^^


thread 'rustc' (75) panicked at /rustc-dev/f20a92ec01483dc5c58e90e246f266bdad822d86/compiler/rustc_hir_typeck/src/lib.rs:122:9:
Box<dyn Any>
stack backtrace:
   0: std::panicking::begin_panic::<rustc_errors::ExplicitBug>
   1: <rustc_errors::diagnostic::BugAbort as rustc_errors::diagnostic::EmissionGuarantee>::emit_producing_guarantee
   2: <rustc_errors::DiagCtxtHandle>::span_bug::<rustc_span::span_encoding::Span, alloc::string::String>
   3: rustc_middle::util::bug::opt_span_bug_fmt::<rustc_span::span_encoding::Span>::{closure#0}
   4: rustc_middle::ty::context::tls::with_opt::<rustc_middle::util::bug::opt_span_bug_fmt<rustc_span::span_encoding::Span>::{closure#0}, !>::{closure#0}
   5: rustc_middle::ty::context::tls::with_context_opt::<rustc_middle::ty::context::tls::with_opt<rustc_middle::util::bug::opt_span_bug_fmt<rustc_span::span_encoding::Span>::{closure#0}, !>::{closure#0}, !>
   6: rustc_middle::util::bug::span_bug_fmt::<rustc_span::span_encoding::Span>
   7: rustc_hir_typeck::typeck_with_inspect::{closure#0}::{closure#0}
   8: rustc_hir_typeck::typeck_with_inspect::{closure#0}
      [... omitted 1 frame ...]
   9: rustc_mir_build::thir::pattern::check_match::check_match
      [... omitted 1 frame ...]
  10: rustc_mir_build::builder::build_mir_inner_impl
  11: rustc_mir_transform::mir_built
  12: rustc_query_impl::execution::try_execute_query::<rustc_data_structures::vec_cache::VecCache<rustc_span::def_id::LocalDefId, rustc_middle::query::erase::ErasedData<[u8; 8]>, rustc_middle::dep_graph::graph::DepNodeIndex>, false>
      [... omitted 1 frame ...]
  13: rustc_const_eval::const_eval::eval_queries::eval_to_allocation_raw_provider
      [... omitted 1 frame ...]
  14: rustc_const_eval::const_eval::eval_queries::eval_to_allocation_raw_provider
      [... omitted 1 frame ...]
  15: rustc_const_eval::const_eval::valtrees::eval_to_valtree
  16: <rustc_const_eval::provide::{closure#0} as core::ops::function::FnOnce<(rustc_middle::ty::context::TyCtxt, rustc_middle::ty::PseudoCanonicalInput<rustc_middle::mir::interpret::GlobalId>)>>::call_once
      [... omitted 1 frame ...]
  17: <rustc_middle::ty::context::TyCtxt>::const_eval_resolve_for_typeck
  18: <rustc_mir_build::thir::pattern::PatCtxt>::const_to_pat
  19: <rustc_mir_build::thir::pattern::PatCtxt>::lower_pat_expr
  20: <rustc_mir_build::thir::pattern::PatCtxt>::lower_pattern
  21: rustc_mir_build::thir::pattern::pat_from_hir::{closure#0}
  22: <rustc_mir_build::thir::cx::ThirBuildCx>::mirror_expr
  23: <rustc_mir_build::thir::cx::ThirBuildCx>::mirror_expr
  24: <rustc_mir_build::thir::cx::ThirBuildCx>::mirror_expr
  25: rustc_mir_build::thir::cx::thir_body
      [... omitted 1 frame ...]
  26: rustc_mir_build::check_unsafety::check_unsafety
  27: rustc_query_impl::execution::try_execute_query::<rustc_data_structures::vec_cache::VecCache<rustc_span::def_id::LocalDefId, rustc_middle::query::erase::ErasedData<[u8; 0]>, rustc_middle::dep_graph::graph::DepNodeIndex>, false>
  28: <rustc_middle::ty::context::TyCtxt>::par_hir_body_owners::<rustc_interface::passes::run_required_analyses::{closure#2}::{closure#0}>::{closure#0}
  29: rustc_interface::passes::analysis
  30: rustc_query_impl::execution::try_execute_query::<rustc_middle::query::caches::SingleCache<rustc_middle::query::erase::ErasedData<[u8; 0]>>, false>
  31: rustc_interface::interface::run_compiler::<(), rustc_driver_impl::run_compiler::{closure#0}>::{closure#1}
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

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 `/playground/rustc-ice-2026-06-08T04_11_45-73.txt` to your bug report

note: rustc 1.98.0-nightly (f20a92ec0 2026-06-07) running on x86_64-unknown-linux-gnu

note: compiler flags: --crate-type bin -C embed-bitcode=no -C codegen-units=1 -C debuginfo=2

note: some of the compiler flags provided by cargo are hidden

query stack during panic:
#0 [typeck_root] type-checking `FOO`
#1 [check_match] match-checking `FOO`
#2 [mir_built] building MIR for `FOO`
#3 [trivial_const] checking if `FOO` is a trivial const
#4 [eval_to_allocation_raw] const-evaluating + checking `FOO`
#5 [eval_to_allocation_raw] const-evaluating + checking `FOO`
#6 [eval_to_valtree] evaluating type-level constant
#7 [thir_body] building THIR for `main`
#8 [check_unsafety] unsafety-checking `main`
#9 [analysis] running analysis passes on crate `playground`
end of query stack

[Shourya742]

Following the backtrace, const_to_pat calls unevaluated_to_pat for unevaluated consts. I think, following the above instructions, we just need to check for type consts and normalize them.

fn unevaluated_to_pat(
    &mut self,
    uv: ty::UnevaluatedConst<'tcx>,
    ty: Ty<'tcx>,
) -> Box<Pat<'tcx>> {
    let mut thir_pat;
    let mut typing_env = self.typing_env;
    if self.tcx.is_type_const(uv.def) {
        let Ok(normalize) =
            self.tcx.try_normalize_erasing_regions(typing_env, Unnormalized::new_wip(self.c))
        else {
            let err = self.tcx.dcx().create_err(CouldNotEvalConstPattern { span: self.span });
            return self.mk_err(err, ty);
        };
        self.c = normalize;
        thir_pat = match self.c.kind() {
            ty::ConstKind::Unevaluated(uv) => self.unevaluated_to_pat(uv, ty),
            ty::ConstKind::Value(value) => self.valtree_to_pat(value),
            _ => {
                let err =
                    self.tcx.dcx().create_err(CouldNotEvalConstPattern { span: self.span });
                return self.mk_err(err, ty);
            }
        };
    } else {
   // CTFE pathway
  }
}

This passes the above example. We first try to normalize, and if anything goes wrong, we return an error. Otherwise, if normalization still results in an unevaluated const, we recurse; if it results in a value, then we proceed normally. Any other kind should error out.

I am not very sure about typing_env and uv, considering in CTFE we erases and anonymize the regions. But I think they should still be important for normalization, so I am using them as-is from the type.

Let me know what you think?

[BoxyUwU]

you can totally work on this! what you've done looks like generally like the right solution. want to go ahead and open a PR to rust-lang/rust with your changes and I can review it properly? :)

[Shourya742]

@BoxyUwU sure!!! thanks.