Apparently inconsistent treatment of local impls for functions and named and unnamed consts

[nicola-gigante]

This code compiles (albeit with warnings).

pub struct Test {
    x: i32
}

pub fn func() {
    impl Test {
        pub fn func_method(&self) -> i32 {
            self.x
        }
    }
}

pub const NAMED: () = {
    impl Test {
        pub fn named_method(&self) -> i32 {
            self.x
        }
    }
};

const _: () = {
    impl Test {
        pub fn unnamed_method(&self) -> i32 {
            self.x
        }
    }
};

pub fn test(t: Test) -> i32 {
    t.func_method() + t.named_method() + t.unnamed_method()
}

Playground

However, If I'm not doing mistakes, it seems that hir::Impl::all_for_type() only returns the impl declared inside the anonymous const block, and not the others.

Is there any reason the other impls are ignored or is it a bug?

[ShoyuVanilla]

It is intended for performance issues, as searching through all bodies would seriously regress the perf.

You could find multiple places we are collecting declarations/impls inside bodies only for anonymous consts:
https://github.com/search?q=repo%3Arust-lang%2Frust-analyzer%20unnamed_consts&type=code

Actually, rustc isn't so happy with those cases either so there is a clippy lint for it. You would see the lint for impl Test for the first two cases of your example code, but for the last case.

[ChayimFriedman2]

A minor correction: the lint is a rustc lint, not a clippy lint. And was significantly motivated by rust-analyzer.

[ShoyuVanilla]

Oh, I was wrong with that 😅

[ChayimFriedman2]

As @ShoyuVanilla said, this is a deliberate behavior we're not going to change. rustc now even warns on this, partly because rust-analyzer cannot work with this.

[nicola-gigante]

I see, it makes perfect sense, thanks for the clarification!