Hi,

When doing dataflow analysis in Java, is it possible to "redirect" calls made to a method on a subinterface to a specific implementation?

I'm working in a microservices codebase where each service's client has interfaces that are generally organised like this;

package com.acme.foo.client

interface FooService {
  GetFooResponse getFoo(GetFooRequest req);
}

interface FooServiceAsync extends FooService {
  @Override
  default GetFooResponse getFoo(GetFooRequest req) {
  return AsyncHelperLibrary.wrap(getFooAsync(req))
  }

  CompletableFuture<GetFooResponse> getFooAsync(GetFooRequest req);
}

interface FooClient extends FooServiceAsync {}

The actual plumbing/implementation differences between sync and async calls happens at the transport layer (and is not relevant to my analysis), so on the server side only a single implementation exists for getFoo regardless on whether a sync or async call was made

package com.acme.foo.server 

public class FooServer implements FooService {

  @Override
  public GetFooResponse getFoo(GetFooRequest req) {
    //business logic implemented here
  }
}

Dataflow analysis is working out of the box as expected in simple cases where the base interface is used and the corresponding implementation can be found

package com.acme.bar.server 
import com.acme.foo.client.FooService

public class BarServer {
  private final FooService client
  //<cut>
  client.getFoo(req) 
}

However I also want CodeQL to follow the flow in these scenarios where a subinterface is used, and guide it to the implementation found in com.acme.foo.server.FooServer

package com.acme.baz.server
import com.acme.foo.client.FooServiceAsync

public class BazServer {
  private final FooServiceAsync client
  //<cut>
  client.getFoo(req) 
}

And

package com.acme.qux.server
import com.acme.foo.client.FooClient

public class QuxServer {
  private final FooClient client
  //<cut>
  client.getFoo(req) 
}

I've tried (and failed 😭) for a a few hours now to define an isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) predicate that achieves this, but I'm not exactly clear on how to connect the call to the actual implementation I'm after - would someone be able to help or point me towards an example I can borrow from? 🙏