"missing optimized MIR" due to privacy violation, via associated type equality constraint in TAIT

[theemathas]

This bug is a variation of #151284. cc @petrochenkov

I tried this code:

src/dep/lib.rs

#![feature(type_alias_impl_trait)]

struct Priv;
struct Middle;

// Priv -> Middle
pub trait Chain {
    type AssocChain: GetUnreachable;
}
impl Chain for Priv {
    type AssocChain = Middle;
}

// Middle -> Unreachable
pub trait GetUnreachable {
    type AssocUnreachable;
}
impl GetUnreachable for Middle {
    type AssocUnreachable = m::Unreachable;
}

type Opaque = impl Chain<AssocChain: GetUnreachable<AssocUnreachable = m::Unreachable>>;
#[define_opaque(Opaque)]
const _: Opaque = Priv;

// This trait is used to mention Opaque without mentioning Priv
pub trait GetOpaque<T> {}
impl GetOpaque<Opaque> for i32 {}

mod m {
    pub struct Unreachable;
    impl Unreachable {
        #[expect(dead_code)]
        pub fn exploit() {
            println!("huh");
        }
    }
}

src/main.rs

use dep::{Chain, GetOpaque, GetUnreachable};

fn main() {
    <i32 as Access<_>>::Goal::exploit();
}

trait Access<T> {
    type Goal;
}

impl<T: Chain, U: GetOpaque<T>> Access<T> for U {
    type Goal = <<T as Chain>::AssocChain as GetUnreachable>::AssocUnreachable;
}

Compiling the above code resulted in the following error:

error: missing optimized MIR for `dep::m::Unreachable::exploit` in the crate `dep`
   |
note: missing optimized MIR for this item (was the crate `dep` compiled with `--emit=metadata`?)
  --> dep\src\lib.rs:34:9
   |
34 |         pub fn exploit() {
   |         ^^^^^^^^^^^^^^^^

I assume that this error isn't supposed to happen for normal cargo usage.

The use of the only-one-trait-impl rule to access a private type is from #151115

Meta

rustc --version --verbose:

rustc 1.95.0-nightly (a293cc4af 2026-01-30)
binary: rustc
commit-hash: a293cc4af8b26701c42738381c0c6f9d2ba881e0
commit-date: 2026-01-30
host: x86_64-pc-windows-msvc
release: 1.95.0-nightly
LLVM version: 22.1.0

[theemathas]

The following variation of the code causes rustc to output a very strange warning.

dep/src/lib.rs

#![feature(type_alias_impl_trait)]

struct Priv;

// Priv -> Unreachable
pub trait GetUnreachable {
    type AssocUnreachable;
}
impl GetUnreachable for Priv {
    type AssocUnreachable = m::Unreachable;
}

type Opaque = impl GetUnreachable<AssocUnreachable = m::Unreachable>;
#[define_opaque(Opaque)]
const _: Opaque = Priv;

// This trait is used to mention Opaque without mentioning Priv
pub trait GetOpaque<T> {}
impl GetOpaque<Opaque> for i32 {}

mod m {
    pub struct Unreachable;
    impl Unreachable {
        #[expect(dead_code)]
        pub fn exploit<T>() {
            println!("huh");
        }
    }
}

src/main.rs

use dep::{GetOpaque, GetUnreachable};

fn main() {
    <i32 as Access<_>>::Goal::exploit::<_>();
}

trait Access<T> {
    type Goal;
}

impl<T: GetUnreachable, U: GetOpaque<T>> Access<T> for U {
    type Goal = <T as GetUnreachable>::AssocUnreachable;
}

Error output

   Compiling foo v0.1.0 (C:\Users\theem\Documents\foo)
 WARN rustc_trait_selection::error_reporting::infer::need_type_info unexpected path: def=dep::m::Unreachable args=[] path=Path { span: src\main.rs:4:5: 4:29 (#0), res: Def(AssocTy, DefId(0:9 ~ foo[5dc6]::Access::Goal)), segments: [PathSegment { ident: Access#0, hir_id: HirId(DefId(0:6 ~ foo[5dc6]::main).7), res: Def(Trait, DefId(0:7 ~ foo[5dc6]::Access)), args: Some(GenericArgs { args: [Infer(InferArg { hir_id: HirId(DefId(0:6 ~ foo[5dc6]::main).6), span: src\main.rs:4:20: 4:21 (#0) })], constraints: [], parenthesized: No, span_ext: src\main.rs:4:19: 4:22 (#0) }), infer_args: false }, PathSegment { ident: Goal#0, hir_id: HirId(DefId(0:6 ~ foo[5dc6]::main).8), res: Def(AssocTy, DefId(0:9 ~ foo[5dc6]::Access::Goal)), args: None, infer_args: true }] }
error[E0282]: type annotations needed
 --> src\main.rs:4:41
  |
4 |     <i32 as Access<_>>::Goal::exploit::<_>();
  |                                         ^ cannot infer type

For more information about this error, try `rustc --explain E0282`.        
error: could not compile `foo` (bin "foo") due to 1 previous error

The warning came from

rust/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

Lines 1153 to 1159 in 271951b

	// There cannot be inference variables in the self type,
	// so there's nothing for us to do here.
	Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => {}
	_ => warn!(
	"unexpected path: def={:?} args={:?} path={:?}",
	def, args, path,
	),

Additionally, changing <i32 as Access<_>>::Goal::exploit::<_>(); to <i32 as Access<_>>::Goal::exploit::<i64>(); causes the program to compile and run fine without any errors or warnings. Despite this, rust seems to think that the exploit() function is never used (as indicated with the #[expect(dead_code)].)

[petrochenkov]

type_alias_impl_traits are known to not be checked correctly - #146470 (comment).
Unlike associated types, they are not stable, so it can be fixed with breaking changes (hard errors on anything private in TAIT's interface).