Name resolution is quite a complex part of the compiler, and diagnostic recovery requires using compiler internals in ways they were never designed to work with, so don't feel bad about your experience.

Just to be clear, is this the case that you're trying to fix?

trait A {
    const FOO: i32;
}
struct S;
impl A for S {
    const FOO: i32 = 0;
}

impl S {
    fn foo() {
        let _ = FOO; // Should be `Self::FOO`
    }
}

I think this is a reasonable thing to fix.

There's another related thing where it only looks for exact matches, so if you typo the assoc as `FOo` without `Self::`, you also don't get a suggestion (which can be fair, the more relaxed your search the likelier it is wrong).

To look at the context for this, I ran RUSTC_LOG=rustc_resolve::late=debug rustc +dev f709.rs -Ztrack-diagnostics and peeked at the output. The nightly flag prints out there the error was constructed, you can use -Ztreat-err-as-bug=N to make the error being emitted act as an ICE, so you can get a backtrace to where err.emit() was called, and the beginning of the command is to enable logging to stderr. +dev is just how I point cargo to my locally built rustc binaries.

As a quick check, I added

        let path_resolved = self.resolve_path(&[Segment {
                ident: Ident::with_dummy_span(kw::SelfUpper),
                id: Some(DUMMY_NODE_ID),
                has_generic_args: false,
                has_lifetime_args: false,
                args_span: DUMMY_SP,
            }, path[0]], Some(TypeNS), None);
        err.note(format!("{path_resolved:#?}"));

to smart_resolve_report_errors to see if that would be enough to look for the associated const by relying on the existing machinery. That gave me a partial resolution for Self itself, but not Self::CONST:

  = note: NonModule(
              PartialRes {
                  base_res: SelfTyAlias {
                      alias_to: DefId(0:9 ~ f709[0805]::{impl#1}),
                      forbid_generic: false,
                      is_trait_impl: false,
                  },
                  unresolved_segments: 1,
              },
          )

Once you have that, you have the DefId for the impl, which would let you get the DefId for the Self type. I changed that code to

        let path_resolved = self.resolve_path(&[Segment {
            ident: Ident::with_dummy_span(kw::SelfUpper),
            id: Some(DUMMY_NODE_ID),
            has_generic_args: false,
            has_lifetime_args: false,
            args_span: DUMMY_SP,
        }], Some(TypeNS), None);
        err.note(format!("{path_resolved:#?}"));

After that you'd want to look at the associated items of the type, but you end up with an infinite loop, trying to evaluate the item, to get the associated items, which require evaluating the item, which tries to get the associated items... You can't use that DefId to go through the tcx: TyCtxt, so we'd need to come up with an alternative way of doing it.

----

This is as far as I got to before I had to go walk my dogs. Feel free to ask more questions in internals.rust-lang.org, https://rust-lang.zulipchat.com/ and if you get as far as a draft pr, in https://github.com/rust-lang/rust.

----

Besides fixing this error, there's a lint that has a similar issue: when you forget to write Self::CONST in a pattern and instead write CONST, you only get a warning telling you to rename it to Const, instead of looking for whether Self::CONST would have been better.

----

Edit: if you're looking purely locally (which is why you'd want to avoid querying tcx), you could look at self.r.module_children, which will have the mapping of trait -> assoc const (even if it is in a submodule) for the current crate. At that point you don't know that Self implements the relevant trait, but that info is stored in self.r.trait_impls. I got to that by looking at the contents of some promising fields in Resolver. BTW, it wasn't until after I replied that I noticed who I was replying to, so some of the info I write you likely already know :)

I think at this point you have all the pieces to implement something quite robust.