impl block on a type defined with type_alias_impl_trait can conflict with other unrelated impl

[douglas-raillard-arm]

I tried this code:

#![feature(type_alias_impl_trait)]

use std::any::TypeId;

pub trait Trait {}
impl<T: ?Sized> Trait for T {}

pub trait Other {}

macro_rules! mymac {
    () => {{
        struct S;
        type Foo = impl Trait;
        let x: Foo = S;
        println!("{:?}", TypeId::of::<Foo>());
        impl Foo {
            fn foo() -> () {}
        }
        impl Other for Foo {}
    }};
}

fn main() {
    mymac!();
    mymac!();
}

I expected to see this happen: compiles without error

Instead, this happened:

error[E0119]: conflicting implementations of trait `Other` for type `main::Foo`
  --> src/main.rs:19:9
   |
19 |         impl Other for Foo {}
   |         ^^^^^^^^^^^^^^^^^^
   |         |
   |         first implementation here
   |         conflicting implementation for `main::Foo`
...
25 |     mymac!();
   |     -------- in this macro invocation
   |
   = note: this error originates in the macro `mymac` (in Nightly builds, run with -Z macro-backtrace for more info)

Meta

Rust nightly version on the playground as of 9th of April 2025.

[douglas-raillard-arm]

As can be seen in the output, Rust considers both Foo types as being separate and associates a different TypeId to each. Both the inherent impl block and the "impl Other" block conflict though.

[douglas-raillard-arm]

Also note that wrapping Foo in a generic struct (e.g. struct Wrapper<T>(T)) and using Wrapper<Foo> has the same problem. However, if a fresh struct Wrapper(Foo) is made, impl on this one will not conflict with others.