Detecting overriding methods

[gzsombor]

Hi,

I'm trying to implement a rule which detects if a method can be made private. It checks, if a method is only called from the same class, and doesn't have a couple of annotations, which marks the method as called using reflection - like @VisibleForTesting,@post,@get, etc This works great, unless that method is public, because it overrides an interface or parent class method currently this fails, I've tried improve the detection, however, the best I could find, is to find a function in a parent class or interface, with matching name, and matching number of parameters. So if I have a

  Function<String, Integer> = new Function<String, Integer>() {
     public Integer apply(String str) { 
       return str.length();
     }
     public String apply(SomeOtherType type) {
      /// something
     } 
  }      

Both apply method would be accepted, as correct - even though, the second could be made into private (or deleted).
Unfortunately I couldn't find an easy way to handle function overriding with generic parameters. (I know, this is a hard problem even for the compiler), but maybe, someone already tried to do something, and could suggest the perfect solution?
Otherwise, I can contribute my solution, which only matches based on name and function arguments, if someone is interested

[nbrugger-tgm]

you can also test the types of the parameters

boolean isOverridden = method.getOwner().getAllRawInterfaces()
    .stream()
    .anyMatch(c -> c.tryGetMethod(
        method.getName(),
        getTypeNames(method.getParameters())
    ).isPresent());

[gzsombor]

This is what I've first tried, but this is incorrect, as doesn't properly handle the generic types. For example, in the java.util.Function case, it tries to find apply(java.lang.String) but it could only find an apply(java.lang.Object)

[hankem]

You can at least use method.getOwner()'s .getSuperclass() and .getInterfaces() (instead of .getRawSuperclass() and .getRawInterfaces() – but note that you have to recurse the hierarchy unlike with .getAllRawSuperclasses() and .getAllRawInterfaces()) and check whether the supertype's JavaType is an instanceof JavaClass. In this case, you can specifically search for the overridden method using parameter types as suggested in #903 (comment). If the supertype is however a JavaParameterizedType, it is indeed tricky (probably not possible at the moment).

[codecholeric]

I think meanwhile ArchUnit has all the information to resolve the full type information, as long as it's inside of the bytecode. I.e. you could do something like (DISCLAIMER: pseudo-code, not tested, just out of my head 😉)

JavaParameterizedType functionInterfaceClass = 
  (JavaParameterizedType) functionImplementationClass.getInterfaces().iterator().next();
Map<String, JavaClass> typeVariableNamesToActualTypes = 
  associateTypeVariables(functionInterfaceClass, functionInterfaceClass.toErasure());
JavaMethod apply = getApplyMethod(functionInterfaceClass.toErasure());
JavaClass actualParameterType = 
  resolveTypeArgument(apply.getParameterTypes().get(0), typeVariableNamesToActualTypes);

Pretty much reimplement something like org.springframework.core.GenericTypeResolver if you want this more flexible for different cases 😬