It is not clear to me why this method name has to be so lengthy, and why it should care about anon/super/type/etc. It takes two string values that represent two qualified names, and returns the count of characters that match between the two, right? private static int countMatchingQualifierChars(String pattern, String candidate)

AnonSuper imply that usage of it not general or at least we don't want to think if it could be general.

Naming "count......" Is good.

Why can’t it be general? This is my point.

We have no goal to make it general now, if someone wants, he can improve it to be general in separate PR, but current implementation is limited.

Similar to above, we are exposing implementation details in the method name, and it doesn't really help us to understand what this method does at a conceptual level or why we care about it. Additionally, using diff and match in the name is misleading; once we are comparing depths, we really aren't talking about a "diff" any longer.

Please make this method signature to be private static int calculateTypeDeclarationDistance(String outerTypeName, TypeDeclDesc firstType, TypeDeclDesc secondType).

If we name it a bit more general, could it be problem of misusage? Non of arguments imply that implementation is designed for annon type only for now.
If someone wants to make general method, he can create with general name and do appreciate implementation.

Just think on this one more time, this had concerns with names even in original PR.
I don't want to let this PR stuck again.
If you really see it should be changed , just confirm one more time, and we will do it.

The existing name tells me everything except for what this method actually does 😂

While we are here, we can also refactor this method a bit to use immutable data and make what we are doing more clear:

    final int firstMatchCount = countMatchingQualifierChars(outerTypeName, firstType.getQualifiedName());
    final int secondMatchCount = countMatchingQualifierChars(outerTypeName, secondType.getQualifiedName());

    final int matchDistance = Integer.compare(secondMatchCount, firstMatchCount);

    final int distance;
    if (matchDistance == 0) {
        distance = Integer.compare( firstType.getDepth(),  secondType.getDepth());
    } else {
        distance = matchDistance;
    }

    return distance;

Why do we care about this? This code is not obvious to me.

Shouldn’t this be getClosestMatchingTypeDeclaration?

The naming inconsistencies in this check really make this code difficult to understand: the type we use for nearly all the heavy lifting is called TypeDeclDesc, but we nearly always name the variables with class.

getClosestMatchingTypeDeclaration

Ok, Do you fully dislike OfAnonInner clarification in name?

I don’t know why it matters.

It is very specific method with very specific implementation

It is very specific method with very specific implementation

Leaking implementation details into the method name is also a red flag.

Are we "getting the nearest class of anonymous inner class"? What does this even mean? What is a nearest class "of" another class? Why is this method not returning a class, if we are getting a class?

Or, are we "getting the closest matching type declaration", since the method returns a type declaration description?