Is this word boundary check actually needed? If you omit it, then you'll next skip over any whitespace and do a check for =. This implicitly requires a word boundary.

Thanks for pointing this out, it was over-zealous, I removed the post-name boundary check and now rely on the existing whitespace + single = check, it reads better and works the same

There's still a bunch of code duplication here. Pretty much all of check_identifier_reference and check_reference_from_covering_node are being duplicated.

What I was thinking was having both KeywordArgumentReferencesFinder and LocalReferencesFinder share a common representation. You still need both types for the AST visiting, but it seems like they could both sit on top of a shared core.

I might be wrong about this because I haven't tried it. So if it's too unnatural, I think just adding a comment noting why there is code duplication here would be sufficient.

Thanks for catching that, I pushed a follow-up that de-dupes the shared logic
Though I kept LocalReferencesFinder and KeywordArgumentReferencesFinder as separate visitor types, since they still differ in how they classify/emits references, but the matching/resolution path is now shared

Or would you prefer a deeper shared-core type?

The only difference I can see between the two of them is that we're using ReferenceKind::Other explicitly in one and determine_reference_kind in the other. But it seems like we could just use determine_reference_kind in both. And then the differences disappear.

Moreover, you have:

struct KeywordArgumentReferencesFinder<'a> {
    model: &'a SemanticModel<'a>,
    tokens: &'a Tokens,
    target_definitions: &'a NavigationTargets,
    references: &'a mut Vec<ReferenceTarget>,
    mode: ReferencesMode,
    target_text: &'a str,
    ancestors: Vec<AnyNodeRef<'a>>,
}

But we already have:

struct LocalReferencesFinder<'a> {
    model: &'a SemanticModel<'a>,
    tokens: &'a Tokens,
    target_definitions: &'a NavigationTargets,
    references: &'a mut Vec<ReferenceTarget>,
    mode: ReferencesMode,
    target_text: &'a str,
    ancestors: Vec<AnyNodeRef<'a>>,
}

They are identical. I think we can de-duplicate more here. e.g.,

struct KeywordArgumentReferencesFinder<'a>(LocalReferencesFinder<'a>);

Or something similar.

Thanks for the tip with the tuple wrapper, I've implemented it as-is!