Help: How to order the callees of a method selected using polyCalls+ in a DFS order.

[oriana19993926782]

I am trying to let chatGPT do some static analysis for some methods in a java project. In order for chatGPT to fully understand the behavior of a method, I used the polyCalls+() to select all the callee methods that are called by a target method. But the callee methods in the results are not listed/arranged in the same order as they are called inside the target method body. If you think of call hierarchy or call graph as a ordered-tree, our target method is the root, and the callee methods are the nodes, the order I am talking about here will be Pre-order Traversal(one specific type of Depth-First Search, DFS )

Take a simple java method named isJobNodeExisted from apache/shardingsphere-elasticjob for example:

Below is the call hierarchy of this isJobNodeExisted, the callee methods in white from top to down is in the order they are called inside the body of this isJobNodeExisted.(I get this call hierarchy by using cmd + shift + H on a target method in IDEA.)

However, the callees of isJobNodeExisted I selected using ployCalls+() is listed/arranged in a very strange and confusing order. For example, the callee handleException further directly calls RegException and isIgnoredException, which you can see from following code.

    public static void handleException(final Exception cause) {
        if (null == cause) {
            return;
        }
        if (isIgnoredException(cause) || null != cause.getCause() && isIgnoredException(cause.getCause())) {
            log.debug("Elastic job: ignored exception for: {}", cause.getMessage());
        } else if (cause instanceof InterruptedException) {
            Thread.currentThread().interrupt();
        } else {
            throw new RegException(cause);
        }
    }

However, in the query result(pic below), the direct caller of RegException and isIgnoredException, which is handleException here, is actually located in between these two. The order here is messy.

The confusing order of callees here makes it really hard for me or chatGPT to do static analysis. I wonder what kind of order pattern in which codeQL are presenting the callees in the results?

Is there any way for me to get the callees in the same order as they are actually called inside my target method body or re-order the callees in a DFS order?

Below is my query to get all the callees of a target method isJobNodeExisted. Greatly appreciate guidance on this DFS order problem! Many thanks!!!

import java

class TargetMethod extends Callable {
  TargetMethod() {
    this.getName()= "isJobNodeExisted"
    // this.getName() = "checkConflictJob"
  }
}

predicate hasMethodCall(Expr expr) {
  expr instanceof MethodAccess
  or
  exists(Expr child |
    child = expr.getAChildExpr() and
    hasMethodCall(child)) 
}


from TargetMethod tm, Callable calledMethod
// , Callable directCaller
where
tm.polyCalls+(calledMethod) 
and calledMethod.fromSource()

// // Find direct caller of 'calledMethod'
// and ((directCaller.polyCalls(calledMethod) and tm.polyCalls+(directCaller))
// // or tm = directCaller
// )

select
  tm.getSignature(), 
  // directCaller.getSignature(),
  // directCaller.getBody(),
  calledMethod.getBody(),
  calledMethod.getSignature()

[mbg]

Hi @oriana19993926782, so sorry for the delay in responding to you about this!

Broadly speaking, we make no guarantees about the order in which queries return their results. You should expect them to essentially be random. Query results can be ordered with order by clauses so you could e.g. order results of a query based on their source location (for a roughly approximate call order) or by hooking into information from our control flow graph (for a more precise call order), depending on your needs. Doing this for calls in one method is fairly straightforward, but it gets more complicated if you want to include the entire call tree for a method.

Let me know if that's enough to steer you in the right direction or if you need more help, or if you have already figured it out in the time since posting your question. Sorry again for the long delay in a response here!