Trait bound in associated type isn't checked when normalizing type that doesn't require inspecting the AT

[theemathas]

The below code shouldn't compile, since i64 does not implement Bound, so I shouldn't be allowed to write Output<i64>. However, it compiles without errors.

I'm guessing that rustc sees <.... as Super>::Assoc and immediately concludes that the type must be i32 without further checking.

trait Super {
    type Assoc;
}
trait Sub: Super<Assoc = i32> {}

// no impl for Bound anywhere
trait Bound {}

trait Apply {
    // Bound requirement here
    type Output<T: Bound>: Sub;
}

trait Trait {
    type What;
}

impl<A: Apply> Trait for A {
    // i64 doesn't implement Bound
    type What = <<A as Apply>::Output<i64> as Super>::Assoc;
}

cc @lcnr

Meta

Reproducible on the playground with version 1.96.0-nightly (2026-03-12 3102493c71626b5912d1)

[theemathas]

Trying to inspect the What type results in some strange behavior.

trait Super {
    type Assoc;
}
trait Sub: Super<Assoc = i32> {}

// no impl for Bound anywhere
trait Bound {}

trait Apply {
    // Bound requirement here
    type Output<T: Bound>: Sub;
}

trait Trait {
    type What;
}

impl<A: Apply> Trait for A {
    // i64 doesn't implement Bound
    type What = <<A as Apply>::Output<i64> as Super>::Assoc;
}

// Code above this is the same as the original issue
// Code below this is new

struct ApplyStruct;
struct SubStruct;
impl Apply for ApplyStruct {
    type Output<T: Bound> = SubStruct;
}
impl Super for SubStruct {
    type Assoc = i32;
}
impl Sub for SubStruct {}

// compiles without errors
pub fn works1<A: Apply>() {
    let x: <A as Trait>::What = 1i32;
}

// compiles without errors
pub fn works2() {
    works1::<ApplyStruct>();
}

// Compile error
pub fn works3() {
    let x: <ApplyStruct as Trait>::What = 1i32;
}

error[E0277]: the trait bound `i64: Bound` is not satisfied
  --> src/lib.rs:47:12
   |
47 |     let x: <ApplyStruct as Trait>::What = 1i32;
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bound` is not implemented for `i64`
   |
help: this trait has no implementations, consider adding one
  --> src/lib.rs:7:1
   |
 7 | trait Bound {}
   | ^^^^^^^^^^^
note: required by a bound in `Apply::Output`
  --> src/lib.rs:11:20
   |
11 |     type Output<T: Bound>: Sub;
   |                    ^^^^^ required by this bound in `Apply::Output`

[theemathas]

This can also cause an ICE.

In this code, I think that, pre-mono, the compiler is OK with the type <A as Trait>::What. But post-mono, the compiler doesn't like the type <ApplyStruct as Trait>::What

trait Super {
    type Assoc;
}
trait Sub: Super<Assoc = i32> {}

// no impl for Bound anywhere
trait Bound {}

trait Apply {
    // Bound requirement here
    type Output<T: Bound>: Sub;
}

trait Trait {
    type What;
}

impl<A: Apply> Trait for A {
    // i64 doesn't implement Bound
    type What = <<A as Apply>::Output<i64> as Super>::Assoc;
}

// Code above this is the same as the original issue
// Code below this is new

struct ApplyStruct;
struct SubStruct;
impl Apply for ApplyStruct {
    type Output<T: Bound> = SubStruct;
}
impl Super for SubStruct {
    type Assoc = i32;
}
impl Sub for SubStruct {}

fn discard<A: Apply>(_: <A as Trait>::What) {}

fn foo<A: Apply>() {
    discard::<A>(1i32);
}

pub fn bar() {
    foo::<ApplyStruct>();
}

Error output

error: internal compiler error: /rustc-dev/3102493c71626b5912d11d06c393b013569beb52/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs:171:13: Failed to normalize Alias(Projection, AliasTy { args: [ApplyStruct], def_id: DefId(0:11 ~ playground[c01b]::Trait::What), .. }) in typing_env=TypingEnv { typing_mode: PostAnalysis, param_env: ParamEnv { caller_bounds: [] } }, maybe try to call `try_normalize_erasing_regions` instead


thread 'rustc' (27) panicked at /rustc-dev/3102493c71626b5912d11d06c393b013569beb52/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs:171:13:
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_middle::util::bug::opt_span_bug_fmt::<rustc_span::span_encoding::Span>::{closure#0}
   3: rustc_middle::ty::context::tls::with_opt::<rustc_middle::util::bug::opt_span_bug_fmt<rustc_span::span_encoding::Span>::{closure#0}, !>::{closure#0}
   4: 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}, !>
   5: rustc_middle::util::bug::bug_fmt
   6: <rustc_middle::ty::normalize_erasing_regions::NormalizeAfterErasingRegionsFolder as rustc_type_ir::fold::TypeFolder<rustc_middle::ty::context::TyCtxt>>::fold_ty
   7: <rustc_ty_utils::abi::FnAbiDesc>::for_instance
      [... omitted 1 frame ...]
   8: rustc_monomorphize::mono_checks::check_mono_item
   9: rustc_query_impl::execution::try_execute_query::<rustc_middle::query::caches::DefaultCache<rustc_middle::ty::instance::Instance, rustc_middle::query::erase::ErasedData<[u8; 0]>>, false>
  10: rustc_monomorphize::collector::items_of_instance
      [... omitted 1 frame ...]
  11: rustc_monomorphize::collector::collect_items_rec
  12: rustc_monomorphize::collector::collect_items_rec
  13: rustc_monomorphize::collector::collect_items_rec
  14: rustc_monomorphize::collector::collect_crate_mono_items::{closure#1}::{closure#0}
  15: rustc_monomorphize::partitioning::collect_and_partition_mono_items
      [... omitted 1 frame ...]
  16: rustc_codegen_ssa::back::symbol_export::exported_generic_symbols_provider_local
      [... omitted 1 frame ...]
  17: <rustc_metadata::rmeta::encoder::EncodeContext>::encode_crate_root
  18: <rustc_metadata::rmeta::encoder::encode_metadata::{closure#3} as core::ops::function::FnOnce<(rustc_middle::ty::context::TyCtxt, &std::path::Path)>>::call_once
  19: rustc_metadata::rmeta::encoder::encode_metadata
  20: rustc_metadata::fs::encode_and_write_metadata
  21: <rustc_interface::queries::Linker>::codegen_and_build_linker
  22: 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-03-22T03_22_37-25.txt` to your bug report

note: rustc 1.96.0-nightly (3102493c7 2026-03-12) running on x86_64-unknown-linux-gnu

note: compiler flags: --crate-type lib -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 [fn_abi_of_instance_no_deduced_attrs] computing unadjusted call ABI of `discard::<ApplyStruct>`
#1 [check_mono_item] monomorphization-time checking
#2 [items_of_instance] collecting items used by `discard::<ApplyStruct>`
#3 [collect_and_partition_mono_items] collect_and_partition_mono_items
#4 [exported_generic_symbols] collecting exported generic symbols for crate `0`
end of query stack

[theemathas]

Here's a variant of the bug that uses a where clause on an associated type instead of a GAT.

The below code compiles, even though it shouldn't.

trait Super {
    type Assoc;
}
trait Sub: Super<Assoc = i32> {}

// no impl for Bound anywhere
trait Bound {}

trait Apply<T> {
    // Bound requirement here
    type Output: Sub where T: Bound;
}

trait Trait {
    type What;
}

impl<A: Apply<i64>> Trait for A {
    // i64 doesn't implement Bound
    type What = <<A as Apply<i64>>::Output as Super>::Assoc;
}